0024023: Revamp the OCCT Handle -- downcast (automatic)
[occt.git] / src / Geom2dAdaptor / Geom2dAdaptor_Curve.cxx
index e1869eb..f544e31 100644 (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)