OpenCascade/occt
1
0
Fork 0
mirror of https://git.dev.opencascade.org/repos/occt.git synced 2025-08-14 13:30:48 +03:00
Code Activity

0024023: Revamp the OCCT Handle -- downcast (automatic)

Browse Source 
Automatic update by command "occt_upgrade . -downcast"

C-style cast of Handle to that of derived type (now illegal) is replaced by call to DownCast()
Const reference local variables of Handle type initialized by result of DownCast are replaced by normal variables.
This commit is contained in:
abv
2015-07-02 16:41:05 +03:00
parent ce8b059af3
commit c5f3a42524
158 changed files with 863 additions and 888 deletions
Download Patch File Download Diff File Expand all files Collapse all files

52
src/Geom2dAdaptor/Geom2dAdaptor_Curve.cxx
View File

@@ -53,7 +53,7 @@
#include <Standard_NullObject.hxx>
#include <Standard_NotImplemented.hxx>
#define myBspl (*((Handle(Geom2d_BSplineCurve)*)&myCurve))
#define myBspl Handle(Geom2d_BSplineCurve)::DownCast (myCurve)
#define PosTol Precision::PConfusion()/2
static const int maxDerivOrder = 3;
@@ -189,7 +189,7 @@ void Geom2dAdaptor_Curve::load(const Handle(Geom2d_Curve)& C,
Handle(Standard_Type) TheType = C->DynamicType();
if ( TheType == STANDARD_TYPE(Geom2d_TrimmedCurve)) {
Load((*((Handle(Geom2d_TrimmedCurve)*)&C))->BasisCurve(),
Load(Handle(Geom2d_TrimmedCurve)::DownCast (C)->BasisCurve(),
UFirst,ULast);
}
else if ( TheType == STANDARD_TYPE(Geom2d_Circle)) {
@@ -245,7 +245,7 @@ GeomAbs_Shape Geom2dAdaptor_Curve::Continuity() const
}
else if (myCurve->DynamicType() == STANDARD_TYPE(Geom2d_OffsetCurve)){
GeomAbs_Shape S =
(*((Handle(Geom2d_OffsetCurve)*)&myCurve))->GetBasisCurveContinuity();
Handle(Geom2d_OffsetCurve)::DownCast (myCurve)->GetBasisCurveContinuity();
switch(S){
case GeomAbs_CN: return GeomAbs_CN;
case GeomAbs_C3: return GeomAbs_C2;
@@ -1002,23 +1002,23 @@ Standard_Real Geom2dAdaptor_Curve::Resolution(const Standard_Real Ruv) const {
case GeomAbs_Line :
return Ruv;
case GeomAbs_Circle: {
Standard_Real R = (*((Handle(Geom2d_Circle)*)&myCurve))->Circ2d().Radius();
Standard_Real R = Handle(Geom2d_Circle)::DownCast (myCurve)->Circ2d().Radius();
if ( R > Ruv/2.)
return 2*ASin(Ruv/(2*R));
else
return 2*M_PI;
}
case GeomAbs_Ellipse: {
return Ruv / (*((Handle(Geom2d_Ellipse)*)&myCurve))->MajorRadius();
return Ruv / Handle(Geom2d_Ellipse)::DownCast (myCurve)->MajorRadius();
}
case GeomAbs_BezierCurve: {
Standard_Real res;
(*((Handle(Geom2d_BezierCurve)*)&myCurve))->Resolution(Ruv,res);
Handle(Geom2d_BezierCurve)::DownCast (myCurve)->Resolution(Ruv,res);
return res;
}
case GeomAbs_BSplineCurve: {
Standard_Real res;
(*((Handle(Geom2d_BSplineCurve)*)&myCurve))->Resolution(Ruv,res);
Handle(Geom2d_BSplineCurve)::DownCast (myCurve)->Resolution(Ruv,res);
return res;
}
default:
@@ -1040,7 +1040,7 @@ Standard_Real Geom2dAdaptor_Curve::Resolution(const Standard_Real Ruv) const {
gp_Lin2d Geom2dAdaptor_Curve::Line() const
{
Standard_NoSuchObject_Raise_if(myTypeCurve != GeomAbs_Line, "");
return (*((Handle(Geom2d_Line)*)&myCurve))->Lin2d();
return Handle(Geom2d_Line)::DownCast (myCurve)->Lin2d();
}
//=======================================================================
@@ -1051,7 +1051,7 @@ gp_Lin2d Geom2dAdaptor_Curve::Line() const
gp_Circ2d Geom2dAdaptor_Curve::Circle() const
{
Standard_NoSuchObject_Raise_if(myTypeCurve != GeomAbs_Circle, "");
return (*((Handle(Geom2d_Circle)*)&myCurve))->Circ2d();
return Handle(Geom2d_Circle)::DownCast (myCurve)->Circ2d();
}
//=======================================================================
@@ -1062,7 +1062,7 @@ gp_Circ2d Geom2dAdaptor_Curve::Circle() const
gp_Elips2d Geom2dAdaptor_Curve::Ellipse() const
{
Standard_NoSuchObject_Raise_if(myTypeCurve != GeomAbs_Ellipse, "");
return (*((Handle(Geom2d_Ellipse)*)&myCurve))->Elips2d();
return Handle(Geom2d_Ellipse)::DownCast (myCurve)->Elips2d();
}
//=======================================================================
@@ -1073,7 +1073,7 @@ gp_Elips2d Geom2dAdaptor_Curve::Ellipse() const
gp_Hypr2d Geom2dAdaptor_Curve::Hyperbola() const
{
Standard_NoSuchObject_Raise_if(myTypeCurve != GeomAbs_Hyperbola, "");
return (*((Handle(Geom2d_Hyperbola)*)&myCurve))->Hypr2d();
return Handle(Geom2d_Hyperbola)::DownCast (myCurve)->Hypr2d();
}
//=======================================================================
@@ -1084,7 +1084,7 @@ gp_Hypr2d Geom2dAdaptor_Curve::Hyperbola() const
gp_Parab2d Geom2dAdaptor_Curve::Parabola() const
{
Standard_NoSuchObject_Raise_if(myTypeCurve != GeomAbs_Parabola, "");
return (*((Handle(Geom2d_Parabola)*)&myCurve))->Parab2d();
return Handle(Geom2d_Parabola)::DownCast (myCurve)->Parab2d();
}
//=======================================================================
@@ -1095,9 +1095,9 @@ gp_Parab2d Geom2dAdaptor_Curve::Parabola() const
Standard_Integer Geom2dAdaptor_Curve::Degree() const
{
if (myTypeCurve == GeomAbs_BezierCurve)
return (*((Handle(Geom2d_BezierCurve)*)&myCurve))->Degree();
return Handle(Geom2d_BezierCurve)::DownCast (myCurve)->Degree();
else if (myTypeCurve == GeomAbs_BSplineCurve)
return (*((Handle(Geom2d_BSplineCurve)*)&myCurve))->Degree();
return Handle(Geom2d_BSplineCurve)::DownCast (myCurve)->Degree();
else
Standard_NoSuchObject::Raise();
// portage WNT
@@ -1112,9 +1112,9 @@ Standard_Integer Geom2dAdaptor_Curve::Degree() const
Standard_Boolean Geom2dAdaptor_Curve::IsRational() const {
switch( myTypeCurve) {
case GeomAbs_BSplineCurve:
return (*((Handle(Geom2d_BSplineCurve)*)&myCurve))->IsRational();
return Handle(Geom2d_BSplineCurve)::DownCast (myCurve)->IsRational();
case GeomAbs_BezierCurve:
return (*((Handle(Geom2d_BezierCurve)*)&myCurve))->IsRational();
return Handle(Geom2d_BezierCurve)::DownCast (myCurve)->IsRational();
default:
return Standard_False;
}
@@ -1128,9 +1128,9 @@ Standard_Boolean Geom2dAdaptor_Curve::IsRational() const {
Standard_Integer Geom2dAdaptor_Curve::NbPoles() const
{
if (myTypeCurve == GeomAbs_BezierCurve)
return (*((Handle(Geom2d_BezierCurve)*)&myCurve))->NbPoles();
return Handle(Geom2d_BezierCurve)::DownCast (myCurve)->NbPoles();
else if (myTypeCurve == GeomAbs_BSplineCurve)
return (*((Handle(Geom2d_BSplineCurve)*)&myCurve))->NbPoles();
return Handle(Geom2d_BSplineCurve)::DownCast (myCurve)->NbPoles();
else
Standard_NoSuchObject::Raise();
// portage WNT
@@ -1145,7 +1145,7 @@ Standard_Integer Geom2dAdaptor_Curve::NbPoles() const
Standard_Integer Geom2dAdaptor_Curve::NbKnots() const {
if ( myTypeCurve != GeomAbs_BSplineCurve)
Standard_NoSuchObject::Raise("Geom2dAdaptor_Curve::NbKnots");
return (*((Handle(Geom2d_BSplineCurve)*)&myCurve))->NbKnots();
return Handle(Geom2d_BSplineCurve)::DownCast (myCurve)->NbKnots();
}
@@ -1156,7 +1156,7 @@ Standard_Integer Geom2dAdaptor_Curve::NbKnots() const {
Handle(Geom2d_BezierCurve) Geom2dAdaptor_Curve::Bezier() const
{
return *((Handle(Geom2d_BezierCurve)*)&myCurve);
return Handle(Geom2d_BezierCurve)::DownCast (myCurve);
}
//=======================================================================
@@ -1166,7 +1166,7 @@ Handle(Geom2d_BezierCurve) Geom2dAdaptor_Curve::Bezier() const
Handle(Geom2d_BSplineCurve) Geom2dAdaptor_Curve::BSpline() const
{
return *((Handle(Geom2d_BSplineCurve)*)&myCurve);
return Handle(Geom2d_BSplineCurve)::DownCast (myCurve);
}
static Standard_Integer nbPoints(const Handle(Geom2d_Curve)& theCurve)
@@ -1178,22 +1178,22 @@ static Standard_Integer nbPoints(const Handle(Geom2d_Curve)& theCurve)
nbs = 2;
else if(theCurve->IsKind(STANDARD_TYPE( Geom2d_BezierCurve)))
{
nbs = 3 + (*((Handle(Geom2d_BezierCurve)*)&theCurve))->NbPoles();
nbs = 3 + Handle(Geom2d_BezierCurve)::DownCast (theCurve)->NbPoles();
}
else if(theCurve->IsKind(STANDARD_TYPE( Geom2d_BSplineCurve))) {
nbs = (*((Handle(Geom2d_BSplineCurve)*)&theCurve))->NbKnots();
nbs*= (*((Handle(Geom2d_BSplineCurve)*)&theCurve))->Degree();
nbs = Handle(Geom2d_BSplineCurve)::DownCast (theCurve)->NbKnots();
nbs*= Handle(Geom2d_BSplineCurve)::DownCast (theCurve)->Degree();
if(nbs < 2.0) nbs=2;
}
else if (theCurve->IsKind(STANDARD_TYPE(Geom2d_OffsetCurve)))
{
Handle(Geom2d_Curve) aCurve = (*((Handle(Geom2d_OffsetCurve)*)&theCurve))->BasisCurve();
Handle(Geom2d_Curve) aCurve = Handle(Geom2d_OffsetCurve)::DownCast (theCurve)->BasisCurve();
return Max(nbs, nbPoints(aCurve));
}
else if (theCurve->IsKind(STANDARD_TYPE(Geom2d_TrimmedCurve)))
{
Handle(Geom2d_Curve) aCurve = (*((Handle(Geom2d_TrimmedCurve)*)&theCurve))->BasisCurve();
Handle(Geom2d_Curve) aCurve = Handle(Geom2d_TrimmedCurve)::DownCast (theCurve)->BasisCurve();
return Max(nbs, nbPoints(aCurve));
}
if(nbs>300)