0031004: Coding - eliminate warnings issued by gcc 9.1.0
authorkgv <kgv@opencascade.com>
Fri, 8 May 2020 20:41:22 +0000 (23:41 +0300)
committerbugmaster <bugmaster@opencascade.com>
Fri, 15 May 2020 15:08:07 +0000 (18:08 +0300)
Fixed -Wrestrict warning within OSD::SetSignal().

Fixed -Wdeprecated-copy warning by adding missing counterpart
in pair copy constructor / assignment operator or by removing trivial constructor.

AdvApp2Var_Node, AdvApp2Var_Patch are now declared as Handle.
AdvApp2Var_Iso is now passed by Handle.

Disabled operator= for TDF_Transaction and TDF_IDFilter.

Standard.cxx - fixed GCC version mischeck causing building failure with experimental GCC versions.

TopOpeBRepDS_EXPORT.cxx - fixed -Wmaybe-uninitialized warnings.

55 files changed:
src/AdvApp2Var/AdvApp2Var_ApproxAFunc2Var.cxx
src/AdvApp2Var/AdvApp2Var_Framework.cxx
src/AdvApp2Var/AdvApp2Var_Framework.hxx
src/AdvApp2Var/AdvApp2Var_Framework.lxx [deleted file]
src/AdvApp2Var/AdvApp2Var_Iso.cxx
src/AdvApp2Var/AdvApp2Var_Iso.hxx
src/AdvApp2Var/AdvApp2Var_Network.cxx
src/AdvApp2Var/AdvApp2Var_Network.hxx
src/AdvApp2Var/AdvApp2Var_Network.lxx [deleted file]
src/AdvApp2Var/AdvApp2Var_Node.cxx
src/AdvApp2Var/AdvApp2Var_Node.hxx
src/AdvApp2Var/AdvApp2Var_Patch.cxx
src/AdvApp2Var/AdvApp2Var_Patch.hxx
src/AdvApp2Var/AdvApp2Var_SequenceOfNode.hxx
src/AdvApp2Var/AdvApp2Var_SequenceOfPatch.hxx
src/AdvApp2Var/AdvApp2Var_Strip.hxx
src/AdvApp2Var/FILES
src/BOPTools/BOPTools_Set.cxx
src/BOPTools/BOPTools_Set.hxx
src/BVH/BVH_Box.hxx
src/Geom2dHatch/Geom2dHatch_Element.cxx
src/Geom2dHatch/Geom2dHatch_Element.hxx
src/Graphic3d/Graphic3d_CubeMapOrder.hxx
src/Graphic3d/Graphic3d_Vertex.hxx
src/Graphic3d/Graphic3d_WorldViewProjState.hxx
src/HatchGen/HatchGen_PointOnElement.cxx
src/HatchGen/HatchGen_PointOnElement.hxx
src/HatchGen/HatchGen_PointOnHatching.cxx
src/HatchGen/HatchGen_PointOnHatching.hxx
src/IGESToBRep/IGESToBRep_CurveAndSurface.cxx
src/IGESToBRep/IGESToBRep_CurveAndSurface.hxx
src/IntPolyh/IntPolyh_Point.hxx
src/IntRes2d/IntRes2d_Intersection.hxx
src/Interface/Interface_Graph.cxx
src/Interface/Interface_Graph.hxx
src/Interface/Interface_STAT.hxx
src/Intf/Intf_SectionLine.hxx
src/Intf/Intf_TangentZone.cxx
src/Intf/Intf_TangentZone.hxx
src/Intrv/Intrv_Intervals.cxx
src/Intrv/Intrv_Intervals.hxx
src/NCollection/NCollection_Array1.hxx
src/OSD/OSD_signal.cxx
src/OpenGl/OpenGl_Context.cxx
src/Standard/Standard.cxx
src/StepData/StepData_Field.hxx
src/TDF/TDF_CopyLabel.cxx
src/TDF/TDF_IDFilter.cxx
src/TDF/TDF_IDFilter.hxx
src/TDF/TDF_Transaction.cxx
src/TDF/TDF_Transaction.hxx
src/TDocStd/TDocStd_Document.cxx
src/TopOpeBRepDS/TopOpeBRepDS_EXPORT.cxx
src/gp/gp_Quaternion.hxx
src/gp/gp_Quaternion.lxx

index 6cdb96d..bb2e29f 100644 (file)
@@ -244,7 +244,7 @@ void AdvApp2Var_ApproxAFunc2Var::InitGrid(const Standard_Integer NbInt)
 {
   Standard_Integer iu=myConditions.UOrder(),iv=myConditions.VOrder(),iint;
 
-  AdvApp2Var_Patch M0(myFirstParInU,myLastParInU,myFirstParInV,myLastParInV,iu,iv);
+  Handle(AdvApp2Var_Patch) M0 = new AdvApp2Var_Patch (myFirstParInU,myLastParInU,myFirstParInV,myLastParInV,iu,iv);
 
   AdvApp2Var_SequenceOfPatch Net;
   Net.Append(M0);
@@ -259,29 +259,29 @@ void AdvApp2Var_ApproxAFunc2Var::InitGrid(const Standard_Integer NbInt)
 
 
   gp_XY UV1(myFirstParInU,myFirstParInV);
-  AdvApp2Var_Node C1(UV1,iu,iv);
+  Handle(AdvApp2Var_Node) C1 = new AdvApp2Var_Node (UV1,iu,iv);
   gp_XY UV2(myLastParInU,myFirstParInV);
-  AdvApp2Var_Node C2(UV2,iu,iv);
+  Handle(AdvApp2Var_Node) C2 = new AdvApp2Var_Node (UV2,iu,iv);
   gp_XY UV4(myLastParInU,myLastParInV);
-  AdvApp2Var_Node C4(UV4,iu,iv);
+  Handle(AdvApp2Var_Node) C4 = new AdvApp2Var_Node (UV4,iu,iv);
   gp_XY UV3(myFirstParInU,myLastParInV);
-  AdvApp2Var_Node C3(UV3,iu,iv);
+  Handle(AdvApp2Var_Node) C3 = new AdvApp2Var_Node (UV3,iu,iv);
   AdvApp2Var_SequenceOfNode Bag;
   Bag.Append(C1);
   Bag.Append(C2);
   Bag.Append(C3);
   Bag.Append(C4);
 
-  AdvApp2Var_Iso V0(GeomAbs_IsoV,myFirstParInV,
+  Handle(AdvApp2Var_Iso) V0 = new AdvApp2Var_Iso (GeomAbs_IsoV,myFirstParInV,
                    myFirstParInU,myLastParInU,myFirstParInV,myLastParInV,
                    1,iu,iv);
-  AdvApp2Var_Iso V1(GeomAbs_IsoV,myLastParInV,
+  Handle(AdvApp2Var_Iso) V1 = new AdvApp2Var_Iso (GeomAbs_IsoV,myLastParInV,
                    myFirstParInU,myLastParInU,myFirstParInV,myLastParInV,
                    2,iu,iv);
-  AdvApp2Var_Iso U0(GeomAbs_IsoU,myFirstParInU,
+  Handle(AdvApp2Var_Iso) U0 = new AdvApp2Var_Iso (GeomAbs_IsoU,myFirstParInU,
                    myFirstParInU,myLastParInU,myFirstParInV,myLastParInV,
                    3,iu,iv);
-  AdvApp2Var_Iso U1(GeomAbs_IsoU,myLastParInU,
+  Handle(AdvApp2Var_Iso) U1 = new AdvApp2Var_Iso (GeomAbs_IsoU,myLastParInU,
                    myFirstParInU,myLastParInU,myFirstParInV,myLastParInV,
                    4,iu,iv);
 
@@ -557,68 +557,74 @@ void AdvApp2Var_ApproxAFunc2Var::ComputeConstraints(const AdvApprox_Cutting& UCh
   Standard_Real dec;
   Standard_Boolean more;
   Standard_Integer ind1, ind2, NbPatch, NbU, NbV;
-  AdvApp2Var_Iso Is;
-  Standard_Integer indN1, indN2;
   Standard_Integer iu = myConditions.UOrder(), iv = myConditions.VOrder();
   AdvApp2Var_Node N1(iu,iv), N2(iu,iv);
 
-  while ( myConstraints.FirstNotApprox(ind1, ind2, Is) ) {
-
-// approximation of iso and calculation of constraints at extremities
-    indN1 = myConstraints.FirstNode(Is.Type(),ind1,ind2);
-    N1 = myConstraints.Node(indN1);
-    indN2 = myConstraints.LastNode(Is.Type(),ind1,ind2);
-    N2 = myConstraints.Node(indN2);
-
-    Is.MakeApprox(myConditions,
-                 myFirstParInU, myLastParInU,
-                 myFirstParInV, myLastParInV,
-                 Func, N1 , N2);
-
-    if (Is.IsApproximated()) {
-// iso is approached at the required tolerance
-      myConstraints.ChangeIso(ind1,ind2,Is);
-      myConstraints.ChangeNode(indN1) = N1;
-      myConstraints.ChangeNode(indN2) = N2;
+  for (Handle(AdvApp2Var_Iso) anIso = myConstraints.FirstNotApprox(ind1, ind2); !anIso.IsNull(); anIso = myConstraints.FirstNotApprox(ind1, ind2))
+  {
+    // approximation of iso and calculation of constraints at extremities
+    const Standard_Integer indN1 = myConstraints.FirstNode(anIso->Type(),ind1,ind2);
+    N1 = *myConstraints.Node(indN1);
+    const Standard_Integer indN2 = myConstraints.LastNode(anIso->Type(),ind1,ind2);
+    N2 = *myConstraints.Node(indN2);
+
+    // note that old code attempted to make copy of anIso here (but copy was incomplete)
+    anIso->MakeApprox (myConditions,
+                       myFirstParInU, myLastParInU,
+                       myFirstParInV, myLastParInV,
+                       Func, N1 , N2);
+    if (anIso->IsApproximated())
+    {
+      // iso is approached at the required tolerance
+      myConstraints.ChangeIso(ind1,ind2,anIso);
+      *myConstraints.Node(indN1) = N1;
+      *myConstraints.Node(indN2) = N2;
     }
-
-    else {
-// Approximation is not satisfactory
+    else
+    {
+      // Approximation is not satisfactory
       NbU = myResult.NbPatchInU();
       NbV = myResult.NbPatchInV();
-      if (Is.Type()==GeomAbs_IsoV) {
-       NbPatch = (NbU+1)*NbV;
-       more = UChoice.Value(Is.T0(),Is.T1(),dec);
+      if (anIso->Type()==GeomAbs_IsoV)
+      {
+        NbPatch = (NbU+1)*NbV;
+        more = UChoice.Value(anIso->T0(), anIso->T1(), dec);
       }
-      else {
-       NbPatch = (NbV+1)*NbU;
-       more = VChoice.Value(Is.T0(),Is.T1(),dec);
+      else
+      {
+        NbPatch = (NbV+1)*NbU;
+        more = VChoice.Value(anIso->T0(),anIso->T1(),dec);
       }
 
-      if (NbPatch<=myMaxPatches && more) {
-//     It is possible to cut iso
-       if (Is.Type()==GeomAbs_IsoV) {
-         myResult.UpdateInU(dec);
-         myConstraints.UpdateInU(dec);
-       }
-       else {
-         myResult.UpdateInV(dec);
-         myConstraints.UpdateInV(dec);
-       }
+      if (NbPatch<=myMaxPatches && more)
+      {
+        // It is possible to cut iso
+        if (anIso->Type()==GeomAbs_IsoV)
+        {
+          myResult.UpdateInU(dec);
+          myConstraints.UpdateInU(dec);
+        }
+        else
+        {
+          myResult.UpdateInV(dec);
+          myConstraints.UpdateInV(dec);
+        }
       }
-
-      else {
-//     It is not possible to cut : the result is preserved
-       if (Is.HasResult()) {
-         Is.OverwriteApprox();
-         myConstraints.ChangeIso(ind1,ind2,Is);
-         myConstraints.ChangeNode(indN1) = N1;
-         myConstraints.ChangeNode(indN2) = N2; 
-       }
-       else {
-         myHasResult =  myDone = Standard_False;
-         throw Standard_ConstructionError("AdvApp2Var_ApproxAFunc2Var : Curve Approximation Error");
-       }
+      else
+      {
+        // It is not possible to cut : the result is preserved
+        if (anIso->HasResult())
+        {
+          anIso->OverwriteApprox();
+          myConstraints.ChangeIso(ind1,ind2,anIso);
+          *myConstraints.Node(indN1) = N1;
+          *myConstraints.Node(indN2) = N2;
+        }
+        else
+        {
+          myHasResult =  myDone = Standard_False;
+          throw Standard_ConstructionError("AdvApp2Var_ApproxAFunc2Var : Curve Approximation Error");
+        }
       }
     }
   }
@@ -638,74 +644,82 @@ void AdvApp2Var_ApproxAFunc2Var::ComputeConstraints(const AdvApprox_Cutting& UCh
   Standard_Real dec;
   Standard_Boolean more, CritRel = (Crit.Type() == AdvApp2Var_Relative);
   Standard_Integer ind1, ind2, NbPatch, NbU, NbV;
-  AdvApp2Var_Iso Is;
   Standard_Integer indN1, indN2;
   Standard_Integer iu = myConditions.UOrder(), iv = myConditions.VOrder();
   AdvApp2Var_Node N1(iu,iv), N2(iu,iv);
 
-    while ( myConstraints.FirstNotApprox(ind1, ind2, Is) ) {
-
-// approximation of the iso and calculation of constraints at the extremities
-      indN1 = myConstraints.FirstNode(Is.Type(),ind1,ind2);
-      N1 = myConstraints.Node(indN1);
-      indN2 = myConstraints.LastNode(Is.Type(),ind1,ind2);
-      N2 = myConstraints.Node(indN2);
-
-      Is.MakeApprox(myConditions,
-                    myFirstParInU, myLastParInU,
-                    myFirstParInV, myLastParInV,
-                    Func, N1 , N2);
-
-      if (Is.IsApproximated()) {
-// iso is approached at the required tolerance
-       myConstraints.ChangeIso(ind1,ind2,Is);
-       myConstraints.ChangeNode(indN1) = N1;
-       myConstraints.ChangeNode(indN2) = N2;
+  for (Handle(AdvApp2Var_Iso) anIso = myConstraints.FirstNotApprox(ind1, ind2); !anIso.IsNull(); anIso = myConstraints.FirstNotApprox(ind1, ind2))
+  {
+    // approximation of the iso and calculation of constraints at the extremities
+    indN1 = myConstraints.FirstNode(anIso->Type(),ind1,ind2);
+    N1 = *myConstraints.Node(indN1);
+    indN2 = myConstraints.LastNode(anIso->Type(),ind1,ind2);
+    N2 = *myConstraints.Node(indN2);
+
+    // note that old code attempted to make copy of anIso here (but copy was incomplete)
+    anIso->MakeApprox (myConditions,
+                       myFirstParInU, myLastParInU,
+                       myFirstParInV, myLastParInV,
+                       Func, N1 , N2);
+
+    if (anIso->IsApproximated())
+    {
+      // iso is approached at the required tolerance
+      myConstraints.ChangeIso(ind1,ind2,anIso);
+      *myConstraints.Node(indN1) = N1;
+      *myConstraints.Node(indN2) = N2;
+    }
+    else
+    {
+      // Approximation is not satisfactory
+      NbU = myResult.NbPatchInU();
+      NbV = myResult.NbPatchInV();
+      if (anIso->Type()==GeomAbs_IsoV)
+      {
+        NbPatch = (NbU+1)*NbV;
+        more = UChoice.Value(anIso->T0(),anIso->T1(),dec);
+      }
+      else
+      {
+        NbPatch = (NbV+1)*NbU;
+        more = VChoice.Value(anIso->T0(),anIso->T1(),dec);
       }
 
-      else {
-// Approximation is not satisfactory
-       NbU = myResult.NbPatchInU();
-       NbV = myResult.NbPatchInV();
-       if (Is.Type()==GeomAbs_IsoV) {
-         NbPatch = (NbU+1)*NbV;
-         more = UChoice.Value(Is.T0(),Is.T1(),dec);
-       }
-       else {
-         NbPatch = (NbV+1)*NbU;
-         more = VChoice.Value(Is.T0(),Is.T1(),dec);
-       }
-
-//      To force Overwrite if the criterion is Absolute
-       more = more && (CritRel);
-
-       if (NbPatch<=myMaxPatches && more) {
-//     It is possible to cut iso
-         if (Is.Type()==GeomAbs_IsoV) {
-           myResult.UpdateInU(dec);
-           myConstraints.UpdateInU(dec);
-         }
-         else {
-           myResult.UpdateInV(dec);
-           myConstraints.UpdateInV(dec);
-         }
-       }
+      // To force Overwrite if the criterion is Absolute
+      more = more && (CritRel);
 
-       else {
-//     It is not possible to cut: the result is preserved
-          if (Is.HasResult()) {
-           Is.OverwriteApprox();
-           myConstraints.ChangeIso(ind1,ind2,Is);
-           myConstraints.ChangeNode(indN1) = N1;
-           myConstraints.ChangeNode(indN2) = N2;       
-          }
-          else {
-           myHasResult =  myDone = Standard_False;
-           throw Standard_ConstructionError("AdvApp2Var_ApproxAFunc2Var : Curve Approximation Error");
-          }
-       }
+      if (NbPatch<=myMaxPatches && more)
+      {
+        // It is possible to cut iso
+        if (anIso->Type()==GeomAbs_IsoV)
+        {
+          myResult.UpdateInU(dec);
+          myConstraints.UpdateInU(dec);
+        }
+       else
+        {
+          myResult.UpdateInV(dec);
+          myConstraints.UpdateInV(dec);
+        }
+      }
+      else
+      {
+        // It is not possible to cut: the result is preserved
+        if (anIso->HasResult())
+        {
+          anIso->OverwriteApprox();
+          myConstraints.ChangeIso(ind1,ind2,anIso);
+          *myConstraints.Node(indN1) = N1;
+          *myConstraints.Node(indN2) = N2;
+        }
+        else
+        {
+          myHasResult =  myDone = Standard_False;
+          throw Standard_ConstructionError("AdvApp2Var_ApproxAFunc2Var : Curve Approximation Error");
+        }
       }
     }
+  }
 }
 
 //=======================================================================
index facf918..846781e 100644 (file)
@@ -57,43 +57,30 @@ AdvApp2Var_Framework::AdvApp2Var_Framework(const AdvApp2Var_SequenceOfNode& Fram
 //purpose  : return the first Iso not approximated
 //==========================================================================================
 
-Standard_Boolean  AdvApp2Var_Framework::FirstNotApprox(Standard_Integer& IndexIso,
-                                                       Standard_Integer& IndexStrip,
-                                                      AdvApp2Var_Iso& anIso) const
+Handle(AdvApp2Var_Iso) AdvApp2Var_Framework::FirstNotApprox(Standard_Integer& IndexIso,
+                                                       Standard_Integer& IndexStrip) const
 {
-  Standard_Boolean good = Standard_True;
-  Standard_Integer i,j;
-  AdvApp2Var_Strip S;
-
-  for (i = 1; i <= myUConstraints.Length() && good ; i++) {
-    S = myUConstraints.Value(i);
-    for (j = 1; j <= S.Length() && good ; j++) {
-      good = (S.Value(j)).IsApproximated();
-      if (!good) {
-       IndexIso = j;
-       IndexStrip = i;
-       anIso = S.Value(j);
+  for (int anUVIter = 0; anUVIter < 2; ++anUVIter)
+  {
+    const AdvApp2Var_SequenceOfStrip& aSeq = anUVIter == 0 ? myUConstraints : myVConstraints;
+    Standard_Integer i = 1;
+    for (AdvApp2Var_SequenceOfStrip::Iterator aConstIter (aSeq); aConstIter.More(); aConstIter.Next(), i++)
+    {
+      const AdvApp2Var_Strip& S = aConstIter.Value();
+      Standard_Integer j = 1;
+      for (AdvApp2Var_Strip::Iterator anIsoIter (S); anIsoIter.More(); anIsoIter.Next(), j++)
+      {
+        const Handle(AdvApp2Var_Iso)& anIso = anIsoIter.Value();
+        if (!anIso->IsApproximated())
+        {
+          IndexIso = j;
+          IndexStrip = i;
+          return anIso;
+        }
       }
     }
   }
-  if (!good)  {
-    goto FINISH;
-  }
-
-  for (i = 1; i <= myVConstraints.Length() && good; i++) {
-    S = myVConstraints.Value(i);
-    for (j = 1; j <= S.Length() && good ; j++) {
-      good = (S.Value(j)).IsApproximated();
-      if (!good) {
-       IndexIso = j;
-       IndexStrip = i;
-       anIso = S.Value(j);
-      }
-    }
-  }
-
-  FINISH:
-  return !good;
+  return Handle(AdvApp2Var_Iso)();
 }
 
 //==========================================================================================
@@ -145,19 +132,12 @@ Standard_Integer AdvApp2Var_Framework::LastNode(const GeomAbs_IsoType Type,
 
 void AdvApp2Var_Framework::ChangeIso(const Standard_Integer IndexIso,
                                     const Standard_Integer IndexStrip,
-                                    const AdvApp2Var_Iso& anIso)
+                     const Handle(AdvApp2Var_Iso)& theIso)
 {
-  AdvApp2Var_Strip S0;
-  if (anIso.Type()==GeomAbs_IsoV) {
-    S0 = myUConstraints.Value(IndexStrip); 
-    S0.SetValue(IndexIso,anIso);
-    myUConstraints.SetValue(IndexStrip,S0);
-  }
-  else {
-    S0 = myVConstraints.Value(IndexStrip);
-    S0.SetValue(IndexIso,anIso);
-    myVConstraints.SetValue(IndexStrip,S0);
-  }
+  AdvApp2Var_Strip& S0 = theIso->Type() == GeomAbs_IsoV
+                       ? myUConstraints.ChangeValue (IndexStrip)
+                       : myVConstraints.ChangeValue (IndexStrip);
+  S0.SetValue (IndexIso, theIso);
 }
 
 //==========================================================================================
@@ -165,16 +145,19 @@ void AdvApp2Var_Framework::ChangeIso(const Standard_Integer IndexIso,
 //purpose  : return the node of coordinates (U,V)
 //==========================================================================================
 
-const AdvApp2Var_Node& AdvApp2Var_Framework::Node(const Standard_Real U,
+const Handle(AdvApp2Var_Node)& AdvApp2Var_Framework::Node(const Standard_Real U,
                                                  const Standard_Real V) const
 {
-  Standard_Integer Index=1;
-  while ( ( ((myNodeConstraints.Value(Index)).Coord()).X() != U
-        || ((myNodeConstraints.Value(Index)).Coord()).Y() != V )
-         && (Index<myNodeConstraints.Length()) ) {
-    Index++;
+  for (AdvApp2Var_SequenceOfNode::Iterator aNodeIter (myNodeConstraints); aNodeIter.More(); aNodeIter.Next())
+  {
+    const Handle(AdvApp2Var_Node)& aNode = aNodeIter.Value();
+    if (aNode->Coord().X() == U
+     && aNode->Coord().Y() == V)
+    {
+      return aNode;
+    }
   }
-  return myNodeConstraints.Value(Index);
+  return myNodeConstraints.Last();
 }
 
 //==========================================================================================
@@ -187,17 +170,20 @@ AdvApp2Var_Framework::IsoU(const Standard_Real U,
                              const Standard_Real V0,
                              const Standard_Real V1) const 
 {
-  Standard_Integer IndexStrip=1,IndexIso=1;
-  while ( ( ((myVConstraints.Value(IndexStrip)).Value(1)).T0() != V0
-        || ((myVConstraints.Value(IndexStrip)).Value(1)).T1() != V1 )
-         && (IndexStrip<myVConstraints.Length()) ) {
+  Standard_Integer IndexStrip = 1;
+  while (IndexStrip < myVConstraints.Length()
+      && (myVConstraints.Value(IndexStrip).First()->T0() != V0
+       || myVConstraints.Value(IndexStrip).First()->T1() != V1))
+  {
     IndexStrip++;
   }
-  while ( ( ((myVConstraints.Value(IndexStrip)).Value(IndexIso)).Constante() != U)
-         && (IndexIso<=myUConstraints.Length()) ) {
+  Standard_Integer IndexIso = 1;
+  while (IndexIso<=myUConstraints.Length()
+      && myVConstraints.Value(IndexStrip).Value(IndexIso)->Constante() != U)
+  {
     IndexIso++;
   }
-  return (myVConstraints.Value(IndexStrip)).Value(IndexIso);
+  return *(myVConstraints.Value(IndexStrip).Value(IndexIso));
 }
 
 //==========================================================================================
@@ -210,17 +196,20 @@ AdvApp2Var_Framework::IsoV(const Standard_Real U0,
                              const Standard_Real U1,
                              const Standard_Real V) const
 {
-  Standard_Integer IndexStrip=1,IndexIso=1;
-  while ( ( ((myUConstraints.Value(IndexStrip)).Value(1)).T0() != U0
-        || ((myUConstraints.Value(IndexStrip)).Value(1)).T1() != U1 )
-         && (IndexStrip<myUConstraints.Length()) ) {
+  Standard_Integer IndexStrip = 1;
+  while (IndexStrip < myUConstraints.Length()
+      && (myUConstraints.Value(IndexStrip).First()->T0() != U0
+       || myUConstraints.Value(IndexStrip).First()->T1() != U1))
+  {
     IndexStrip++;
   }
-  while ( ( ((myUConstraints.Value(IndexStrip)).Value(IndexIso)).Constante() != V)
-         && (IndexIso<=myVConstraints.Length()) ) {
+  Standard_Integer IndexIso = 1;
+  while (IndexIso<=myVConstraints.Length()
+      && myUConstraints.Value(IndexStrip).Value(IndexIso)->Constante() != V)
+  {
     IndexIso++;
   }
-  return (myUConstraints.Value(IndexStrip)).Value(IndexIso);
+  return *(myUConstraints.Value(IndexStrip).Value(IndexIso));
 }
 
 //==========================================================================================
@@ -230,65 +219,74 @@ AdvApp2Var_Framework::IsoV(const Standard_Real U0,
 
 void AdvApp2Var_Framework::UpdateInU(const Standard_Real CuttingValue)
 {
-  Standard_Integer i=1,j;
-  while (((myUConstraints.Value(i)).Value(1)).U0()>CuttingValue
-        || ((myUConstraints.Value(i)).Value(1)).U1()<CuttingValue) {
-    i++;
-  }
-  AdvApp2Var_Strip S0;
-  AdvApp2Var_Iso Is;
-  S0 = myUConstraints.Value(i);
-  Standard_Real Udeb = (S0.Value(1)).U0(), Ufin = (S0.Value(1)).U1(); 
-
-//  modification des Isos V de la bande en U d'indice i
-  for (j=1;j<=S0.Length();j++) {
-    Is = S0.Value(j);
-    Is.ChangeDomain(Udeb,CuttingValue);
-    Is.ResetApprox();
-    S0.SetValue(j,Is);
+  Standard_Integer i = 1;
+  for (AdvApp2Var_SequenceOfStrip::Iterator anUConstIter (myUConstraints); anUConstIter.More(); anUConstIter.Next(), ++i)
+  {
+    if (anUConstIter.Value().First()->U0() <= CuttingValue
+     && anUConstIter.Value().First()->U1() >= CuttingValue)
+    {
+      break;
+    }
   }
-  myUConstraints.SetValue(i,S0);
-
-//  insertion d'une nouvelle bande en U apres l'indice i
-  AdvApp2Var_Strip NewStrip;
-  for (j=1;j<=S0.Length();j++) {
-    AdvApp2Var_Iso NewIso((S0.Value(j)).Type(),(S0.Value(j)).Constante(),
-                          CuttingValue,Ufin,(S0.Value(j)).V0(),(S0.Value(j)).V1(),
-                         0,(S0.Value(j)).UOrder(),(S0.Value(j)).VOrder());
-    NewIso.ResetApprox();
-    NewStrip.Append(NewIso);
+
+  {
+    const AdvApp2Var_Strip& S0 = myUConstraints.Value(i);
+    const Standard_Real Udeb = S0.First()->U0(), Ufin = S0.First()->U1();
+
+    // modification des Isos V de la bande en U d'indice i
+    for (AdvApp2Var_Strip::Iterator aStripIter (S0); aStripIter.More(); aStripIter.Next())
+    {
+      const Handle(AdvApp2Var_Iso)& anIso = aStripIter.Value();
+      anIso->ChangeDomain (Udeb, CuttingValue);
+      anIso->ResetApprox();
+    }
+
+    // insertion d'une nouvelle bande en U apres l'indice i
+    AdvApp2Var_Strip aNewStrip;
+    for (AdvApp2Var_Strip::Iterator aStripIter (S0); aStripIter.More(); aStripIter.Next())
+    {
+      const Handle(AdvApp2Var_Iso)& anIso = aStripIter.Value();
+      Handle(AdvApp2Var_Iso) aNewIso = new AdvApp2Var_Iso (anIso->Type(), anIso->Constante(),
+                                                           CuttingValue, Ufin, anIso->V0(), anIso->V1(),
+                                                           0, anIso->UOrder(), anIso->VOrder());
+      aNewIso->ResetApprox();
+      aNewStrip.Append (aNewIso);
+    }
+    myUConstraints.InsertAfter (i, aNewStrip);
   }
-  myUConstraints.InsertAfter(i,NewStrip);
 
 //  insertion d'une nouvelle Iso U=U* dans chaque bande en V apres l'indice i
 //  et restriction des paves des Isos adjacentes
-  for (j=1;j<=myVConstraints.Length();j++) {
-    S0 = myVConstraints.Value(j);
-    Is = S0.Value(i);
-    Is.ChangeDomain(Is.U0(),CuttingValue,Is.V0(),Is.V1());
-    S0.SetValue(i,Is);
-    AdvApp2Var_Iso NewIso(Is.Type(),CuttingValue,Is.U0(),CuttingValue,Is.V0(),Is.V1(),
-                         0,Is.UOrder(),Is.VOrder());
-    NewIso.ResetApprox();
-    S0.InsertAfter(i,NewIso);
-    Is = S0.Value(i+2);
-    Is.ChangeDomain(CuttingValue,Is.U1(),Is.V0(),Is.V1());
-    S0.SetValue(i+2,Is);
-    myVConstraints.SetValue(j,S0);
+  for (Standard_Integer j = 1; j <= myVConstraints.Length(); j++)
+  {
+    AdvApp2Var_Strip& S0 = myVConstraints.ChangeValue(j);
+    Handle(AdvApp2Var_Iso) anIso = S0.Value(i);
+    anIso->ChangeDomain (anIso->U0(), CuttingValue, anIso->V0(), anIso->V1());
+
+    Handle(AdvApp2Var_Iso) aNewIso = new AdvApp2Var_Iso (anIso->Type(), CuttingValue, anIso->U0(), CuttingValue, anIso->V0(), anIso->V1(),
+                                                         0, anIso->UOrder(), anIso->VOrder());
+    aNewIso->ResetApprox();
+    S0.InsertAfter (i, aNewIso);
+
+    anIso = S0.Value(i+2);
+    anIso->ChangeDomain (CuttingValue, anIso->U1(), anIso->V0(), anIso->V1());
   }
 
 //  insertion des nouveaux noeuds (U*,Vj)
-  AdvApp2Var_Node Prev, Next;
-  Prev=myNodeConstraints.Value(1);
-  for (j=1;j<myNodeConstraints.Length();j++) {
-    Next=myNodeConstraints.Value(j+1);
-    if ((Prev.Coord()).X()<CuttingValue && ((Next.Coord()).X()>CuttingValue)
-       && ((Prev.Coord()).Y()==(Next.Coord()).Y())) {
-      gp_XY NewUV(CuttingValue,(Prev.Coord()).Y());
-      AdvApp2Var_Node NewNode(NewUV,Prev.UOrder(),Prev.VOrder());
-      myNodeConstraints.InsertAfter(j,NewNode);
+  Handle(AdvApp2Var_Node) aNext;
+  Handle(AdvApp2Var_Node) aPrev = myNodeConstraints.First();
+  for (Standard_Integer j = 1; j < myNodeConstraints.Length(); j++)
+  {
+    aNext = myNodeConstraints.Value(j+1);
+    if (aPrev->Coord().X() < CuttingValue
+     && aNext->Coord().X() > CuttingValue
+     && aPrev->Coord().Y() == aNext->Coord().Y())
+    {
+      gp_XY aNewUV (CuttingValue, aPrev->Coord().Y());
+      Handle(AdvApp2Var_Node) aNewNode = new AdvApp2Var_Node (aNewUV, aPrev->UOrder(), aPrev->VOrder());
+      myNodeConstraints.InsertAfter (j, aNewNode);
     }
-    Prev=Next;
+    aPrev = aNext;
   }
 }
 
@@ -299,65 +297,69 @@ void AdvApp2Var_Framework::UpdateInU(const Standard_Real CuttingValue)
 
 void AdvApp2Var_Framework::UpdateInV(const Standard_Real CuttingValue)
 {
-  Standard_Integer i,j=1;
-  while (((myVConstraints.Value(j)).Value(1)).V0()>CuttingValue
-        || ((myVConstraints.Value(j)).Value(1)).V1()<CuttingValue) {
+  Standard_Integer j=1;
+  while (myVConstraints.Value(j).First()->V0() > CuttingValue
+      || myVConstraints.Value(j).First()->V1() < CuttingValue)
+  {
     j++;
   }
-  AdvApp2Var_Strip S0;
-  AdvApp2Var_Iso Is;
-  S0 = myVConstraints.Value(j);
-  Standard_Real Vdeb = (S0.Value(1)).V0(), Vfin = (S0.Value(1)).V1(); 
-
-//  modification des Isos U de la bande en V d'indice j
-  for (i=1;i<=S0.Length();i++) {
-    Is = S0.Value(i);
-    Is.ChangeDomain(Vdeb,CuttingValue);
-    Is.ResetApprox();
-    S0.SetValue(i,Is);
-  }
-  myVConstraints.SetValue(j,S0);
-
-//  insertion d'une nouvelle bande en V apres l'indice j
-  AdvApp2Var_Strip NewStrip;
-  for (i=1;i<=S0.Length();i++) {
-    AdvApp2Var_Iso NewIso((S0.Value(i)).Type(),(S0.Value(i)).Constante(),
-                          (S0.Value(i)).U0(),(S0.Value(i)).U1(),CuttingValue,Vfin,
-                         0,(S0.Value(i)).UOrder(),(S0.Value(i)).VOrder());
-    NewIso.ResetApprox();
-    NewStrip.Append(NewIso);
+
+  {
+    AdvApp2Var_Strip& S0 = myVConstraints.ChangeValue(j);
+    const Standard_Real Vdeb = S0.First()->V0(), Vfin = S0.First()->V1();
+
+    // modification des Isos U de la bande en V d'indice j
+    for (AdvApp2Var_Strip::Iterator anIsoIter (S0); anIsoIter.More(); anIsoIter.Next())
+    {
+      const Handle(AdvApp2Var_Iso)& anIso = anIsoIter.Value();
+      anIso->ChangeDomain (Vdeb, CuttingValue);
+      anIso->ResetApprox();
+    }
+
+    // insertion d'une nouvelle bande en V apres l'indice j
+    AdvApp2Var_Strip aNewStrip;
+    for (AdvApp2Var_Strip::Iterator anIsoIter (S0); anIsoIter.More(); anIsoIter.Next())
+    {
+      const Handle(AdvApp2Var_Iso)& anIso = anIsoIter.Value();
+      Handle(AdvApp2Var_Iso) aNewIso = new AdvApp2Var_Iso (anIso->Type(), anIso->Constante(),
+                                                           anIso->U0(), anIso->U1(), CuttingValue, Vfin,
+                                                           0, anIso->UOrder(), anIso->VOrder());
+      aNewIso->ResetApprox();
+      aNewStrip.Append (aNewIso);
+    }
+    myVConstraints.InsertAfter(j, aNewStrip);
   }
-  myVConstraints.InsertAfter(j,NewStrip);
 
-//  insertion d'une nouvelle Iso V=V* dans chaque bande en U apres l'indice j
-//  et restriction des paves des Isos adjacentes
-  for (i=1;i<=myUConstraints.Length();i++) {
-    S0 = myUConstraints.Value(i);
-    Is = S0.Value(j);
-    Is.ChangeDomain(Is.U0(),Is.U1(),Is.V0(),CuttingValue);
-    S0.SetValue(j,Is);
-    AdvApp2Var_Iso NewIso(Is.Type(),CuttingValue,Is.U0(),Is.U1(),Is.V0(),CuttingValue,
-                         0,Is.UOrder(),Is.VOrder());
-    NewIso.ResetApprox();
-    S0.InsertAfter(j,NewIso);
-    Is = S0.Value(j+2);
-    Is.ChangeDomain(Is.U0(),Is.U1(),CuttingValue,Is.V1());
-    S0.SetValue(j+2,Is);
-    myUConstraints.SetValue(i,S0);
+  // insertion d'une nouvelle Iso V=V* dans chaque bande en U apres l'indice j
+  // et restriction des paves des Isos adjacentes
+  for (AdvApp2Var_SequenceOfStrip::Iterator anUConstIter (myUConstraints); anUConstIter.More(); anUConstIter.Next())
+  {
+    AdvApp2Var_Strip& S0 = anUConstIter.ChangeValue();
+    Handle(AdvApp2Var_Iso) anIso = S0.Value(j);
+    anIso->ChangeDomain (anIso->U0(), anIso->U1(), anIso->V0(), CuttingValue);
+
+    Handle(AdvApp2Var_Iso) aNewIso = new AdvApp2Var_Iso (anIso->Type(), CuttingValue, anIso->U0(), anIso->U1(), anIso->V0(), CuttingValue,
+                                                         0, anIso->UOrder(), anIso->VOrder());
+    aNewIso->ResetApprox();
+    S0.InsertAfter (j, aNewIso);
+
+    anIso = S0.Value (j + 2);
+    anIso->ChangeDomain (anIso->U0(), anIso->U1(), CuttingValue, anIso->V1());
   }
 
 //  insertion des nouveaux noeuds (Ui,V*)
-  i = 1;
-  while ( i<=myNodeConstraints.Length() 
-        && ( ((myNodeConstraints.Value(i)).Coord()).Y()) < CuttingValue) {
-    i+=myUConstraints.Length()+1;
+  Standard_Integer i = 1;
+  while (i <= myNodeConstraints.Length()
+      && myNodeConstraints.Value(i)->Coord().Y() < CuttingValue)
+  {
+    i += myUConstraints.Length() + 1;
   }
-  for (j=1;j<=myUConstraints.Length()+1;j++) {
-    gp_XY NewUV(((myNodeConstraints.Value(j)).Coord()).X(),CuttingValue);
-    AdvApp2Var_Node NewNode(NewUV,
-                           (myNodeConstraints.Value(j)).UOrder(),
-                           (myNodeConstraints.Value(j)).VOrder());
-    myNodeConstraints.InsertAfter(i+j-2,NewNode);
+  for (j = 1; j <= myUConstraints.Length() + 1; j++)
+  {
+    const Handle(AdvApp2Var_Node)& aJNode = myNodeConstraints.Value(j);
+    gp_XY NewUV (aJNode->Coord().X(), CuttingValue);
+    Handle(AdvApp2Var_Node) aNewNode = new AdvApp2Var_Node (NewUV, aJNode->UOrder(), aJNode->VOrder());
+    myNodeConstraints.InsertAfter (i+j-2, aNewNode);
   }
 }
 
@@ -370,7 +372,7 @@ const Handle(TColStd_HArray1OfReal)&
 AdvApp2Var_Framework::UEquation(const Standard_Integer IndexIso,
                                const Standard_Integer IndexStrip) const
 {
-  return ((myVConstraints.Value(IndexStrip)).Value(IndexIso)).Polynom();
+  return myVConstraints.Value(IndexStrip).Value(IndexIso)->Polynom();
 }
 
 //==========================================================================================
@@ -382,6 +384,6 @@ const Handle(TColStd_HArray1OfReal)&
 AdvApp2Var_Framework::VEquation(const Standard_Integer IndexIso,
                                const Standard_Integer IndexStrip) const
 {  
-  return myUConstraints.Value(IndexStrip).Value(IndexIso).Polynom();
+  return myUConstraints.Value(IndexStrip).Value(IndexIso)->Polynom();
 }
 
index 2bcf69a..6cddd61 100644 (file)
@@ -44,27 +44,25 @@ public:
   Standard_EXPORT AdvApp2Var_Framework();
   
   Standard_EXPORT AdvApp2Var_Framework(const AdvApp2Var_SequenceOfNode& Frame, const AdvApp2Var_SequenceOfStrip& UFrontier, const AdvApp2Var_SequenceOfStrip& VFrontier);
-  
+
   //! search the Index of the first Iso not approximated,
-  //! if all Isos are approximated Standard_False is returned.
-  Standard_EXPORT Standard_Boolean FirstNotApprox (Standard_Integer& IndexIso, Standard_Integer& IndexStrip, AdvApp2Var_Iso& anIso) const;
+  //! if all Isos are approximated NULL is returned.
+  Standard_EXPORT Handle(AdvApp2Var_Iso) FirstNotApprox (Standard_Integer& IndexIso, Standard_Integer& IndexStrip) const;
   
   Standard_EXPORT Standard_Integer FirstNode (const GeomAbs_IsoType Type, const Standard_Integer IndexIso, const Standard_Integer IndexStrip) const;
   
   Standard_EXPORT Standard_Integer LastNode (const GeomAbs_IsoType Type, const Standard_Integer IndexIso, const Standard_Integer IndexStrip) const;
   
-  Standard_EXPORT void ChangeIso (const Standard_Integer IndexIso, const Standard_Integer IndexStrip, const AdvApp2Var_Iso& anIso);
+  Standard_EXPORT void ChangeIso (const Standard_Integer IndexIso, const Standard_Integer IndexStrip, const Handle(AdvApp2Var_Iso)& anIso);
   
-    const AdvApp2Var_Node& Node (const Standard_Integer IndexNode) const;
+  const Handle(AdvApp2Var_Node)& Node (const Standard_Integer IndexNode) const { return myNodeConstraints.Value(IndexNode); }
   
-  Standard_EXPORT const AdvApp2Var_Node& Node (const Standard_Real U, const Standard_Real V) const;
+  Standard_EXPORT const Handle(AdvApp2Var_Node)& Node (const Standard_Real U, const Standard_Real V) const;
   
   Standard_EXPORT const AdvApp2Var_Iso& IsoU (const Standard_Real U, const Standard_Real V0, const Standard_Real V1) const;
   
   Standard_EXPORT const AdvApp2Var_Iso& IsoV (const Standard_Real U0, const Standard_Real U1, const Standard_Real V) const;
   
-    AdvApp2Var_Node& ChangeNode (const Standard_Integer IndexNode);
-  
   Standard_EXPORT void UpdateInU (const Standard_Real CuttingValue);
   
   Standard_EXPORT void UpdateInV (const Standard_Real CuttingValue);
@@ -73,31 +71,12 @@ public:
   
   Standard_EXPORT const Handle(TColStd_HArray1OfReal)& VEquation (const Standard_Integer IndexIso, const Standard_Integer IndexStrip) const;
 
-
-
-
-protected:
-
-
-
-
-
 private:
 
-
-
   AdvApp2Var_SequenceOfNode myNodeConstraints;
   AdvApp2Var_SequenceOfStrip myUConstraints;
   AdvApp2Var_SequenceOfStrip myVConstraints;
 
-
 };
 
-
-#include <AdvApp2Var_Framework.lxx>
-
-
-
-
-
 #endif // _AdvApp2Var_Framework_HeaderFile
diff --git a/src/AdvApp2Var/AdvApp2Var_Framework.lxx b/src/AdvApp2Var/AdvApp2Var_Framework.lxx
deleted file mode 100644 (file)
index ff657d1..0000000
+++ /dev/null
@@ -1,27 +0,0 @@
-// Created on: 1996-06-17
-// Created by: Philippe MANGIN
-// Copyright (c) 1996-1999 Matra Datavision
-// Copyright (c) 1999-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-inline const AdvApp2Var_Node& AdvApp2Var_Framework::Node(
-                                           const Standard_Integer IndexNode) const 
-{
-  return myNodeConstraints.Value(IndexNode);
-}
-
-inline AdvApp2Var_Node& AdvApp2Var_Framework::ChangeNode(
-                                             const Standard_Integer IndexNode)
-{
-  return myNodeConstraints.ChangeValue(IndexNode);
-}
index 1f2c6a0..9f34a45 100644 (file)
 // Alternatively, this file may be used under the terms of Open CASCADE
 // commercial license or contractual agreement.
 
+#include <AdvApp2Var_Iso.hxx>
 
 #include <AdvApp2Var_ApproxF2var.hxx>
 #include <AdvApp2Var_Context.hxx>
-#include <AdvApp2Var_Iso.hxx>
 #include <AdvApp2Var_Node.hxx>
 #include <gp_Pnt.hxx>
 #include <TColStd_HArray1OfInteger.hxx>
 #include <TColStd_HArray1OfReal.hxx>
 #include <TColStd_HArray2OfReal.hxx>
 
+IMPLEMENT_STANDARD_RTTIEXT(AdvApp2Var_Iso, Standard_Transient)
+
 //=======================================================================
 //function : AdvApp2Var_Iso
 //purpose  : 
index 67d601e..09a2ace 100644 (file)
 class AdvApp2Var_Context;
 class AdvApp2Var_Node;
 
-
-
 //! used to store constraints on a line U = Ui or V = Vj
-class AdvApp2Var_Iso 
+class AdvApp2Var_Iso : public Standard_Transient
 {
+  DEFINE_STANDARD_RTTIEXT(AdvApp2Var_Iso, Standard_Transient)
 public:
 
-  DEFINE_STANDARD_ALLOC
-
-  
   Standard_EXPORT AdvApp2Var_Iso();
   
   Standard_EXPORT AdvApp2Var_Iso(const GeomAbs_IsoType type, const Standard_Integer iu, const Standard_Integer iv);
@@ -99,20 +95,12 @@ public:
   
   Standard_EXPORT Handle(TColStd_HArray2OfReal) MoyErrors() const;
 
-
-
-
-protected:
-
-
-
-
-
 private:
 
-  
-  Standard_EXPORT AdvApp2Var_Iso(const AdvApp2Var_Iso& Other);
+  AdvApp2Var_Iso(const AdvApp2Var_Iso& Other);
+  AdvApp2Var_Iso& operator= (const AdvApp2Var_Iso& theOther);
 
+private:
 
   GeomAbs_IsoType myType;
   Standard_Real myConstPar;
@@ -132,13 +120,6 @@ private:
   Handle(TColStd_HArray1OfReal) mySomTab;
   Handle(TColStd_HArray1OfReal) myDifTab;
 
-
 };
 
-
-
-
-
-
-
 #endif // _AdvApp2Var_Iso_HeaderFile
index f90ec77..bef0ef4 100644 (file)
@@ -52,15 +52,19 @@ AdvApp2Var_Network::AdvApp2Var_Network(const AdvApp2Var_SequenceOfPatch& Net,
 //purpose  : return the first Patch not approximated
 //==========================================================================================
 
-Standard_Boolean AdvApp2Var_Network::FirstNotApprox(Standard_Integer& Index) const 
+Standard_Boolean AdvApp2Var_Network::FirstNotApprox(Standard_Integer& theIndex) const
 {
-  Standard_Boolean good = Standard_True;
-  Standard_Integer i;
-  for (i = 1; i <= myNet.Length() && good; i++) {
-    good = myNet.Value(i).IsApproximated();
-    if (!good) {Index = i;}
+  Standard_Integer anIndex = 1;
+  for (AdvApp2Var_SequenceOfPatch::Iterator aPatchIter (myNet); aPatchIter.More(); aPatchIter.Next(), ++anIndex)
+  {
+    const Handle(AdvApp2Var_Patch)& aPatch = aPatchIter.Value();
+    if (!aPatch->IsApproximated())
+    {
+      theIndex = anIndex;
+      return true;
+    }
   }
-  return !good;
+  return false;
 }
 
 //==========================================================================================
@@ -78,23 +82,20 @@ void AdvApp2Var_Network::UpdateInU(const Standard_Real CuttingValue)
   }
   myUParameters.InsertBefore(i,CuttingValue);
 
-  Standard_Integer indice;
-  for (j=1; j< myVParameters.Length() ; j++){
-
+  for (j=1; j< myVParameters.Length() ; j++)
+  {
 //    modification des patches concernes par la decoupe
-    AdvApp2Var_Patch Pat;
-    indice = (myUParameters.Length()-1) * (j-1) + i - 1;
-    Pat = myNet.Value(indice);
-    Pat.ChangeDomain(Pat.U0(), CuttingValue, Pat.V0(), Pat.V1());
-    Pat.ResetApprox();
-    myNet.SetValue(indice, Pat);
+    Standard_Integer indice = (myUParameters.Length()-1) * (j-1) + i - 1;
+    const Handle(AdvApp2Var_Patch)& aPat = myNet.Value(indice);
+    aPat->ChangeDomain (aPat->U0(), CuttingValue, aPat->V0(), aPat->V1());
+    aPat->ResetApprox();
 
 //    insertion des nouveaux patches
-    AdvApp2Var_Patch NewPat(CuttingValue,myUParameters.Value(i+1),
+    Handle(AdvApp2Var_Patch) aNewPat = new AdvApp2Var_Patch (CuttingValue,myUParameters.Value(i+1),
                            myVParameters.Value(j),myVParameters.Value(j+1),
-                           Pat.UOrder(),Pat.VOrder());
-    NewPat.ResetApprox();
-    myNet.InsertAfter(indice, NewPat);
+                aPat->UOrder(), aPat->VOrder());
+    aNewPat->ResetApprox();
+    myNet.InsertAfter(indice, aNewPat);
   }
 
 }
@@ -108,31 +109,32 @@ void AdvApp2Var_Network::UpdateInV(const Standard_Real CuttingValue)
 {
 
 //  insertion du nouveau parametre de decoupe
-  Standard_Integer i,j=1;
-  AdvApp2Var_Patch Pat;
-  while (myVParameters.Value(j)<CuttingValue) {
+  Standard_Integer j = 1;
+  Handle(AdvApp2Var_Patch) Pat;
+  while (myVParameters.Value(j)<CuttingValue)
+  {
     j++;
   }
   myVParameters.InsertBefore(j,CuttingValue);
 
 //  modification des patches concernes par la decoupe
-  Standard_Integer indice;
-  for (i=1; i< myUParameters.Length() ; i++){
-    indice = (myUParameters.Length()-1) * (j-2) + i;
+  for (Standard_Integer i = 1; i < myUParameters.Length(); i++)
+  {
+    const Standard_Integer indice = (myUParameters.Length()-1) * (j-2) + i;
     Pat = myNet.Value(indice);
-    Pat.ChangeDomain(Pat.U0(), Pat.U1(), Pat.V0(), CuttingValue);
-    Pat.ResetApprox();
-    myNet.SetValue(indice,Pat);
+    Pat->ChangeDomain(Pat->U0(), Pat->U1(), Pat->V0(), CuttingValue);
+    Pat->ResetApprox();
   }
 
 //  insertion des nouveaux patches
-  for (i=1; i< myUParameters.Length() ; i++){
-    indice = (myUParameters.Length()-1) * (j-1) + i-1;
-    AdvApp2Var_Patch NewPat(myUParameters.Value(i), myUParameters.Value(i+1),
+  for (Standard_Integer i = 1; i < myUParameters.Length(); i++)
+  {
+    const Standard_Integer indice = (myUParameters.Length()-1) * (j-1) + i-1;
+    Handle(AdvApp2Var_Patch) aNewPat = new AdvApp2Var_Patch (myUParameters.Value(i), myUParameters.Value(i+1),
                            CuttingValue,myVParameters.Value(j+1),
-                           Pat.UOrder(),Pat.VOrder());
-    NewPat.ResetApprox();
-    myNet.InsertAfter(indice,NewPat);
+                Pat->UOrder(),Pat->VOrder());
+    aNewPat->ResetApprox();
+    myNet.InsertAfter (indice, aNewPat);
   }
 }
 
@@ -146,22 +148,21 @@ void AdvApp2Var_Network::SameDegree(const Standard_Integer iu,
                                    Standard_Integer& ncfu,
                                    Standard_Integer& ncfv)
 {
-
 //  calcul des coeff. max avec init selon l'ordre de continuite
-  Standard_Integer IndPat;
   ncfu = 2*iu+2;
   ncfv = 2*iv+2;
-  for (IndPat=1;IndPat<=myNet.Length();IndPat++) {
-    ncfu = Max(ncfu,myNet.Value(IndPat).NbCoeffInU());
-    ncfv = Max(ncfv,myNet.Value(IndPat).NbCoeffInV());
+  for (AdvApp2Var_SequenceOfPatch::Iterator aPatIter (myNet); aPatIter.More(); aPatIter.Next())
+  {
+    const Handle(AdvApp2Var_Patch)& aPat = aPatIter.Value();
+    ncfu = Max(ncfu, aPat->NbCoeffInU());
+    ncfv = Max(ncfv, aPat->NbCoeffInV());
   }
 
 //  augmentation des nombres de coeff.
-  AdvApp2Var_Patch Pat;
-  for (IndPat=1;IndPat<=myNet.Length();IndPat++) {
-    Pat = myNet.Value(IndPat);
-    Pat.ChangeNbCoeff(ncfu,ncfv);
-    myNet.SetValue(IndPat,Pat);
+  for (AdvApp2Var_SequenceOfPatch::Iterator aPatIter (myNet); aPatIter.More(); aPatIter.Next())
+  {
+    const Handle(AdvApp2Var_Patch)& aPat = aPatIter.Value();
+    aPat->ChangeNbCoeff (ncfu, ncfv);
   }
 
 }
index b651da2..e886107 100644 (file)
@@ -46,11 +46,8 @@ public:
   //! if all Patches are approximated Standard_False is returned
   Standard_EXPORT Standard_Boolean FirstNotApprox (Standard_Integer& Index) const;
   
-    AdvApp2Var_Patch& ChangePatch (const Standard_Integer Index);
-  AdvApp2Var_Patch& operator() (const Standard_Integer Index)
-{
-  return ChangePatch(Index);
-}
+  AdvApp2Var_Patch& ChangePatch (const Standard_Integer Index) { return *myNet.Value(Index); }
+  AdvApp2Var_Patch& operator()  (const Standard_Integer Index) { return ChangePatch(Index); }
   
   Standard_EXPORT void UpdateInU (const Standard_Real CuttingValue);
   
@@ -67,38 +64,23 @@ public:
   Standard_EXPORT Standard_Real UParameter (const Standard_Integer Index) const;
   
   Standard_EXPORT Standard_Real VParameter (const Standard_Integer Index) const;
-  
-    const AdvApp2Var_Patch& Patch (const Standard_Integer UIndex, const Standard_Integer VIndex) const;
-  const AdvApp2Var_Patch& operator() (const Standard_Integer UIndex, const Standard_Integer VIndex) const
-{
-  return Patch(UIndex,VIndex);
-}
-
-
-
-
-protected:
-
-
 
+  const AdvApp2Var_Patch& Patch (const Standard_Integer UIndex, const Standard_Integer VIndex) const
+  {
+    return *myNet.Value ((VIndex-1)*(myUParameters.Length()-1) + UIndex);
+  }
 
+  const AdvApp2Var_Patch& operator() (const Standard_Integer UIndex, const Standard_Integer VIndex) const
+  {
+    return Patch(UIndex,VIndex);
+  }
 
 private:
 
-
-
   AdvApp2Var_SequenceOfPatch myNet;
   TColStd_SequenceOfReal myUParameters;
   TColStd_SequenceOfReal myVParameters;
 
-
 };
 
-
-#include <AdvApp2Var_Network.lxx>
-
-
-
-
-
 #endif // _AdvApp2Var_Network_HeaderFile
diff --git a/src/AdvApp2Var/AdvApp2Var_Network.lxx b/src/AdvApp2Var/AdvApp2Var_Network.lxx
deleted file mode 100644 (file)
index e17993c..0000000
+++ /dev/null
@@ -1,29 +0,0 @@
-// Created on: 1996-06-13
-// Created by: Philippe MANGIN
-// Copyright (c) 1996-1999 Matra Datavision
-// Copyright (c) 1999-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-//#include <TColStd_HArray1OfReal.hxx>
-
-inline AdvApp2Var_Patch& AdvApp2Var_Network::ChangePatch(const Standard_Integer Index)
-{
- return  myNet(Index);
-}
-
-inline const AdvApp2Var_Patch& AdvApp2Var_Network::Patch(const Standard_Integer UIndex, 
-                                                        const Standard_Integer VIndex) const 
-{
-  return myNet( (VIndex-1)*(myUParameters.Length()-1) + UIndex);
-}
-
index cc15392..59926ae 100644 (file)
 // Alternatively, this file may be used under the terms of Open CASCADE
 // commercial license or contractual agreement.
 
-
 #include <AdvApp2Var_Node.hxx>
-#include <gp_Pnt.hxx>
-#include <gp_XY.hxx>
-#include <TColgp_HArray2OfPnt.hxx>
-#include <TColStd_HArray2OfReal.hxx>
+
+IMPLEMENT_STANDARD_RTTIEXT(AdvApp2Var_Node, Standard_Transient)
 
 //=======================================================================
 //function : AdvApp2Var_Node
 //purpose  : 
 //=======================================================================
-AdvApp2Var_Node::AdvApp2Var_Node()  :
-myOrdInU(2),
-myOrdInV(2)
+AdvApp2Var_Node::AdvApp2Var_Node()
+: myTruePoints(0, 2, 0, 2),
+  myErrors    (0, 2, 0, 2),
+  myOrdInU (2),
+  myOrdInV (2)
 {
-  myTruePoints = new TColgp_HArray2OfPnt  ( 0, 2, 0, 2);
   gp_Pnt P0(0.,0.,0.);
-  myTruePoints->Init(P0);
-  myErrors     = new TColStd_HArray2OfReal( 0, 2, 0, 2);
-  myErrors->Init(0.);
+  myTruePoints.Init(P0);
+  myErrors.Init(0.);
 }
 
 //=======================================================================
@@ -42,15 +39,15 @@ myOrdInV(2)
 //=======================================================================
 
 AdvApp2Var_Node::AdvApp2Var_Node(const Standard_Integer iu,
-                                const Standard_Integer iv) :
-myOrdInU(iu),
-myOrdInV(iv)
+                 const Standard_Integer iv)
+: myTruePoints(0, Max(0,iu), 0, Max(0,iv)),
+  myErrors    (0, Max(0,iu), 0, Max(0,iv)),
+  myOrdInU (iu),
+  myOrdInV (iv)
 {
-  myTruePoints = new TColgp_HArray2OfPnt  ( 0, Max(0,iu), 0, Max(0,iv));
   gp_Pnt P0(0.,0.,0.);
-  myTruePoints->Init(P0);
-  myErrors     = new TColStd_HArray2OfReal( 0, Max(0,iu), 0, Max(0,iv));
-  myErrors->Init(0.);
+  myTruePoints.Init(P0);
+  myErrors.Init(0.);
 }
 
 //=======================================================================
@@ -60,118 +57,14 @@ myOrdInV(iv)
 
 AdvApp2Var_Node::AdvApp2Var_Node(const gp_XY& UV,
                                 const Standard_Integer iu,
-                                const Standard_Integer iv) :
-myCoord(UV),
-myOrdInU(iu),
-myOrdInV(iv)
+                 const Standard_Integer iv)
+: myTruePoints(0, iu, 0, iv),
+  myErrors    (0, iu, 0, iv),
+  myCoord (UV),
+  myOrdInU(iu),
+  myOrdInV(iv)
 {
-  myTruePoints = new TColgp_HArray2OfPnt  ( 0, iu, 0, iv);
   gp_Pnt P0(0.,0.,0.);
-  myTruePoints->Init(P0);
-  myErrors     = new TColStd_HArray2OfReal( 0, iu, 0, iv);
-  myErrors->Init(0.);
-}
-
-
-//=======================================================================
-//function : Coord
-//purpose  : returns the coordinates (U,V) of the node
-//=======================================================================
-
-gp_XY AdvApp2Var_Node::Coord() const
-{
-  return myCoord;
-}
-
-//=======================================================================
-//function : SetCoord
-//purpose  : changes the coordinates (U,V) to (x1,x2)
-//=======================================================================
-
-void AdvApp2Var_Node::SetCoord(const Standard_Real x1,
-                              const Standard_Real x2)
-{
-  myCoord.SetX(x1);
-  myCoord.SetY(x2);
-}
-
-//=======================================================================
-//function : UOrder
-//purpose  : returns the continuity order in U of the node
-//=======================================================================
-
-Standard_Integer AdvApp2Var_Node::UOrder() const
-{
-  return myOrdInU;
-}
-
-//=======================================================================
-//function : VOrder
-//purpose  : returns the continuity order in V of the node
-//=======================================================================
-
-Standard_Integer AdvApp2Var_Node::VOrder() const
-{
-  return myOrdInV;
-}
-
-
-//=======================================================================
-//function : SetPoint
-//purpose  : affects the value F(U,V) or its derivates on the node (U,V)
-//=======================================================================
-
-void AdvApp2Var_Node::SetPoint(const Standard_Integer iu,
-                              const Standard_Integer iv,
-                              const gp_Pnt& Pt)
-{
-  myTruePoints->SetValue(iu, iv, Pt);
+  myTruePoints.Init(P0);
+  myErrors.Init(0.);
 }
-
-
-//=======================================================================
-//function : Point
-//purpose  : returns the value F(U,V) or its derivates on the node (U,V)
-//=======================================================================
-
-gp_Pnt AdvApp2Var_Node::Point(const Standard_Integer iu,
-                             const Standard_Integer iv) const
-{
-  return myTruePoints->Value(iu, iv);
-}
-
-
-//=======================================================================
-//function : SetError
-//purpose  : affects the error between F(U,V) and its approximation
-//=======================================================================
-
-void AdvApp2Var_Node::SetError(const Standard_Integer iu,
-                              const Standard_Integer iv,
-                              const Standard_Real error)
-{
-  myErrors->SetValue(iu, iv, error);
-}
-
-
-//=======================================================================
-//function : Error
-//purpose  : returns the error between F(U,V) and its approximation
-//=======================================================================
-
-Standard_Real AdvApp2Var_Node::Error(const Standard_Integer iu,
-                                    const Standard_Integer iv) const
-{
-  return myErrors->Value(iu, iv);
-}
-
-
-
-
-
-
-
-
-
-
-
index 8b2fde5..9fdd814 100644 (file)
 #ifndef _AdvApp2Var_Node_HeaderFile
 #define _AdvApp2Var_Node_HeaderFile
 
+#include <gp_XY.hxx>
 #include <Standard.hxx>
-#include <Standard_DefineAlloc.hxx>
 #include <Standard_Handle.hxx>
-
-#include <gp_XY.hxx>
-#include <Standard_Integer.hxx>
-#include <TColgp_HArray2OfPnt.hxx>
-#include <TColStd_HArray2OfReal.hxx>
-#include <Standard_Real.hxx>
-class gp_XY;
-class gp_Pnt;
-
-
+#include <Standard_Type.hxx>
+#include <TColgp_Array2OfPnt.hxx>
+#include <TColStd_Array2OfReal.hxx>
 
 //! used to store constraints on a (Ui,Vj) point
-class AdvApp2Var_Node 
+class AdvApp2Var_Node : public Standard_Transient
 {
+  DEFINE_STANDARD_RTTIEXT(AdvApp2Var_Node, Standard_Transient)
 public:
 
-  DEFINE_STANDARD_ALLOC
-
-  
   Standard_EXPORT AdvApp2Var_Node();
   
   Standard_EXPORT AdvApp2Var_Node(const Standard_Integer iu, const Standard_Integer iv);
   
   Standard_EXPORT AdvApp2Var_Node(const gp_XY& UV, const Standard_Integer iu, const Standard_Integer iv);
-  
-  Standard_EXPORT gp_XY Coord() const;
-  
-  Standard_EXPORT void SetCoord (const Standard_Real x1, const Standard_Real x2);
-  
-  Standard_EXPORT Standard_Integer UOrder() const;
-  
-  Standard_EXPORT Standard_Integer VOrder() const;
-  
-  Standard_EXPORT void SetPoint (const Standard_Integer iu, const Standard_Integer iv, const gp_Pnt& Cte);
-  
-  Standard_EXPORT gp_Pnt Point (const Standard_Integer iu, const Standard_Integer iv) const;
-  
-  Standard_EXPORT void SetError (const Standard_Integer iu, const Standard_Integer iv, const Standard_Real error);
-  
-  Standard_EXPORT Standard_Real Error (const Standard_Integer iu, const Standard_Integer iv) const;
-
-
-
-
-protected:
-
-
-
 
+  //! Returns the coordinates (U,V) of the node
+  const gp_XY& Coord() const { return myCoord; }
+
+  //! changes the coordinates (U,V) to (x1,x2)
+  void SetCoord (const Standard_Real x1, const Standard_Real x2)
+  {
+    myCoord.SetX(x1);
+    myCoord.SetY(x2);
+  }
+
+  //! returns the continuity order in U of the node
+  Standard_Integer UOrder() const { return myOrdInU; }
+
+  //! returns the continuity order in V of the node
+  Standard_Integer VOrder() const { return myOrdInV; }
+
+  //! affects the value F(U,V) or its derivates on the node (U,V)
+  void SetPoint (const Standard_Integer iu, const Standard_Integer iv, const gp_Pnt& Pt)
+  {
+    myTruePoints.SetValue(iu, iv, Pt);
+  }
+
+  //! returns the value F(U,V) or its derivates on the node (U,V)
+  const gp_Pnt& Point (const Standard_Integer iu, const Standard_Integer iv) const
+  {
+    return myTruePoints.Value(iu, iv);
+  }
+
+  //! affects the error between F(U,V) and its approximation
+  void SetError (const Standard_Integer iu, const Standard_Integer iv, const Standard_Real error)
+  {
+    myErrors.SetValue(iu, iv, error);
+  }
+
+  //! returns the error between F(U,V) and its approximation
+  Standard_Real Error (const Standard_Integer iu, const Standard_Integer iv) const { return myErrors.Value(iu, iv); }
+
+  //! Assign operator.
+  AdvApp2Var_Node& operator= (const AdvApp2Var_Node& theOther)
+  {
+    myTruePoints = theOther.myTruePoints;
+    myErrors = theOther.myErrors;
+    myCoord  = theOther.myCoord;
+    myOrdInU = theOther.myOrdInU;
+    myOrdInV = theOther.myOrdInV;
+    return *this;
+  }
 
 private:
 
-  
-  Standard_EXPORT AdvApp2Var_Node(const AdvApp2Var_Node& Other);
+  AdvApp2Var_Node (const AdvApp2Var_Node& theOther);
 
+private:
 
+  TColgp_Array2OfPnt myTruePoints;
+  TColStd_Array2OfReal myErrors;
   gp_XY myCoord;
   Standard_Integer myOrdInU;
   Standard_Integer myOrdInV;
-  Handle(TColgp_HArray2OfPnt) myTruePoints;
-  Handle(TColStd_HArray2OfReal) myErrors;
-
 
 };
 
-
-
-
-
-
-
 #endif // _AdvApp2Var_Node_HeaderFile
index c789d34..49e86f0 100644 (file)
@@ -40,6 +40,8 @@
 #include <TColStd_HArray1OfReal.hxx>
 #include <TColStd_HArray2OfReal.hxx>
 
+IMPLEMENT_STANDARD_RTTIEXT(AdvApp2Var_Patch, Standard_Transient)
+
 //============================================================================
 //function : AdvApp2Var_Patch
 //purpose  :
@@ -144,35 +146,35 @@ void AdvApp2Var_Patch::Discretise(const AdvApp2Var_Context& Conditions,
       rho = pow(du,iu)*pow(dv,iv);
 
 // F(U0,V0) and its derivatives normalized on (-1,1)
-      valnorm = rho * ((Constraints.Node(myU0,myV0)).Point(iu,iv)).X();
+      valnorm = rho * ((Constraints.Node(myU0,myV0))->Point(iu,iv)).X();
       HCOINS->SetValue( 1+NDIMEN*iu+NDIMEN*(IORDRU+2)*iv , valnorm );
-      valnorm = rho * ((Constraints.Node(myU0,myV0)).Point(iu,iv)).Y();
+      valnorm = rho * ((Constraints.Node(myU0,myV0))->Point(iu,iv)).Y();
       HCOINS->SetValue( 2+NDIMEN*iu+NDIMEN*(IORDRU+2)*iv, valnorm );
-      valnorm = rho * ((Constraints.Node(myU0,myV0)).Point(iu,iv)).Z();
+      valnorm = rho * ((Constraints.Node(myU0,myV0))->Point(iu,iv)).Z();
       HCOINS->SetValue( 3+NDIMEN*iu+NDIMEN*(IORDRU+2)*iv, valnorm );
 
 // F(U1,V0) and its derivatives normalized on (-1,1)
-      valnorm = rho * ((Constraints.Node(myU1,myV0)).Point(iu,iv)).X();
+      valnorm = rho * ((Constraints.Node(myU1,myV0))->Point(iu,iv)).X();
       HCOINS->SetValue( SIZE+1+NDIMEN*iu+NDIMEN*(IORDRU+2)*iv, valnorm );
-      valnorm = rho * ((Constraints.Node(myU1,myV0)).Point(iu,iv)).Y();
+      valnorm = rho * ((Constraints.Node(myU1,myV0))->Point(iu,iv)).Y();
       HCOINS->SetValue( SIZE+2+NDIMEN*iu+NDIMEN*(IORDRU+2)*iv, valnorm );
-      valnorm = rho * ((Constraints.Node(myU1,myV0)).Point(iu,iv)).Z();
+      valnorm = rho * ((Constraints.Node(myU1,myV0))->Point(iu,iv)).Z();
       HCOINS->SetValue( SIZE+3+NDIMEN*iu+NDIMEN*(IORDRU+2)*iv, valnorm );
 
 // F(U0,V1) and its derivatives normalized on (-1,1)
-      valnorm = rho * ((Constraints.Node(myU0,myV1)).Point(iu,iv)).X();
+      valnorm = rho * ((Constraints.Node(myU0,myV1))->Point(iu,iv)).X();
       HCOINS->SetValue( 2*SIZE+1+NDIMEN*iu+NDIMEN*(IORDRU+2)*iv, valnorm );
-      valnorm = rho * ((Constraints.Node(myU0,myV1)).Point(iu,iv)).Y();
+      valnorm = rho * ((Constraints.Node(myU0,myV1))->Point(iu,iv)).Y();
       HCOINS->SetValue( 2*SIZE+2+NDIMEN*iu+NDIMEN*(IORDRU+2)*iv, valnorm );
-      valnorm = rho * ((Constraints.Node(myU0,myV1)).Point(iu,iv)).Z();
+      valnorm = rho * ((Constraints.Node(myU0,myV1))->Point(iu,iv)).Z();
       HCOINS->SetValue( 2*SIZE+3+NDIMEN*iu+NDIMEN*(IORDRU+2)*iv, valnorm );
 
 // F(U1,V1) and its derivatives normalized on (-1,1)
-      valnorm = rho * ((Constraints.Node(myU1,myV1)).Point(iu,iv)).X();
+      valnorm = rho * ((Constraints.Node(myU1,myV1))->Point(iu,iv)).X();
       HCOINS->SetValue( 3*SIZE+1+NDIMEN*iu+NDIMEN*(IORDRU+2)*iv, valnorm );
-      valnorm = rho * ((Constraints.Node(myU1,myV1)).Point(iu,iv)).Y();
+      valnorm = rho * ((Constraints.Node(myU1,myV1))->Point(iu,iv)).Y();
       HCOINS->SetValue( 3*SIZE+2+NDIMEN*iu+NDIMEN*(IORDRU+2)*iv, valnorm );
-      valnorm = rho * ((Constraints.Node(myU1,myV1)).Point(iu,iv)).Z();
+      valnorm = rho * ((Constraints.Node(myU1,myV1))->Point(iu,iv)).Z();
       HCOINS->SetValue( 3*SIZE+3+NDIMEN*iu+NDIMEN*(IORDRU+2)*iv, valnorm );
     }
   }
@@ -543,38 +545,38 @@ void AdvApp2Var_Patch::AddConstraints(const AdvApp2Var_Context& Conditions,
 
 // -F(U0,V0) and its derivatives normalized on (-1,1)
       ideb = HCOINS->Lower() + NDIMEN*iu+NDIMEN*(IORDRU+2)*iv - 1;
-      valnorm = -rho * ((Constraints.Node(myU0,myV0)).Point(iu,iv)).X();
+      valnorm = -rho * ((Constraints.Node(myU0,myV0))->Point(iu,iv)).X();
       HCOINS->SetValue( 1+ideb , valnorm );
-      valnorm = -rho * ((Constraints.Node(myU0,myV0)).Point(iu,iv)).Y();
+      valnorm = -rho * ((Constraints.Node(myU0,myV0))->Point(iu,iv)).Y();
       HCOINS->SetValue( 2+ideb , valnorm );
-      valnorm = -rho * ((Constraints.Node(myU0,myV0)).Point(iu,iv)).Z();
+      valnorm = -rho * ((Constraints.Node(myU0,myV0))->Point(iu,iv)).Z();
       HCOINS->SetValue( 3+ideb , valnorm );
 
 // -F(U1,V0) and its derivatives normalized on (-1,1)
       ideb += SIZE;
-      valnorm = -rho * ((Constraints.Node(myU1,myV0)).Point(iu,iv)).X();
+      valnorm = -rho * ((Constraints.Node(myU1,myV0))->Point(iu,iv)).X();
       HCOINS->SetValue( 1+ideb , valnorm );
-      valnorm = -rho * ((Constraints.Node(myU1,myV0)).Point(iu,iv)).Y();
+      valnorm = -rho * ((Constraints.Node(myU1,myV0))->Point(iu,iv)).Y();
       HCOINS->SetValue( 2+ideb , valnorm );
-      valnorm = -rho * ((Constraints.Node(myU1,myV0)).Point(iu,iv)).Z();
+      valnorm = -rho * ((Constraints.Node(myU1,myV0))->Point(iu,iv)).Z();
       HCOINS->SetValue( 3+ideb , valnorm );
 
 // -F(U0,V1) and its derivatives normalized on (-1,1)
       ideb += SIZE;
-      valnorm = -rho * ((Constraints.Node(myU0,myV1)).Point(iu,iv)).X();
+      valnorm = -rho * ((Constraints.Node(myU0,myV1))->Point(iu,iv)).X();
       HCOINS->SetValue( 1+ideb , valnorm );
-      valnorm = -rho * ((Constraints.Node(myU0,myV1)).Point(iu,iv)).Y();
+      valnorm = -rho * ((Constraints.Node(myU0,myV1))->Point(iu,iv)).Y();
       HCOINS->SetValue( 2+ideb , valnorm );
-      valnorm = -rho * ((Constraints.Node(myU0,myV1)).Point(iu,iv)).Z();
+      valnorm = -rho * ((Constraints.Node(myU0,myV1))->Point(iu,iv)).Z();
       HCOINS->SetValue( 3+ideb , valnorm );
 
 // -F(U1,V1) and its derivatives normalized on (-1,1)
       ideb += SIZE;
-      valnorm = -rho * ((Constraints.Node(myU1,myV1)).Point(iu,iv)).X();
+      valnorm = -rho * ((Constraints.Node(myU1,myV1))->Point(iu,iv)).X();
       HCOINS->SetValue( 1+ideb , valnorm );
-      valnorm = -rho * ((Constraints.Node(myU1,myV1)).Point(iu,iv)).Y();
+      valnorm = -rho * ((Constraints.Node(myU1,myV1))->Point(iu,iv)).Y();
       HCOINS->SetValue( 2+ideb , valnorm );
-      valnorm = -rho * ((Constraints.Node(myU1,myV1)).Point(iu,iv)).Z();
+      valnorm = -rho * ((Constraints.Node(myU1,myV1))->Point(iu,iv)).Z();
       HCOINS->SetValue( 3+ideb , valnorm );
     }
   }
@@ -721,13 +723,13 @@ void AdvApp2Var_Patch::AddErrors(const AdvApp2Var_Framework& Constraints)
     Standard_Real emax1=0.,emax2=0.,emax3=0.,emax4=0.,err1,err2,err3,err4;
     for (iu=0;iu<=myOrdInU;iu++) {
       for (iv=0;iv<=myOrdInV;iv++) {
-       error = (Constraints.Node(myU0,myV0)).Error(iu,iv);
+    error = (Constraints.Node(myU0,myV0))->Error(iu,iv);
        emax1 = Max(emax1,error);
-       error = (Constraints.Node(myU1,myV0)).Error(iu,iv);
+    error = (Constraints.Node(myU1,myV0))->Error(iu,iv);
        emax2 = Max(emax2,error);
-       error = (Constraints.Node(myU0,myV1)).Error(iu,iv);
+    error = (Constraints.Node(myU0,myV1))->Error(iu,iv);
        emax3 = Max(emax3,error);
-       error = (Constraints.Node(myU1,myV1)).Error(iu,iv);
+    error = (Constraints.Node(myU1,myV1))->Error(iu,iv);
        emax4 = Max(emax4,error);
       }
     }
index dcff09b..379a1f7 100644 (file)
@@ -35,12 +35,10 @@ class AdvApp2Var_Criterion;
 
 
 //! used to store results on a domain [Ui,Ui+1]x[Vj,Vj+1]
-class AdvApp2Var_Patch 
+class AdvApp2Var_Patch : public Standard_Transient
 {
+  DEFINE_STANDARD_RTTIEXT(AdvApp2Var_Patch, Standard_Transient)
 public:
-
-  DEFINE_STANDARD_ALLOC
-
   
   Standard_EXPORT AdvApp2Var_Patch();
   
@@ -102,20 +100,12 @@ public:
   
   Standard_EXPORT void SetCritValue (const Standard_Real dist);
 
-
-
-
-protected:
-
-
-
-
-
 private:
 
-  
-  Standard_EXPORT AdvApp2Var_Patch(const AdvApp2Var_Patch& P);
+  AdvApp2Var_Patch(const AdvApp2Var_Patch& P);
+  AdvApp2Var_Patch& operator= (const AdvApp2Var_Patch& theOther);
 
+private:
 
   Standard_Real myU0;
   Standard_Real myU1;
index ad9a91c..a0c17f4 100644 (file)
@@ -20,7 +20,6 @@
 #include <AdvApp2Var_Node.hxx>
 #include <NCollection_Sequence.hxx>
 
-typedef NCollection_Sequence<AdvApp2Var_Node> AdvApp2Var_SequenceOfNode;
-
+typedef NCollection_Sequence<Handle(AdvApp2Var_Node)> AdvApp2Var_SequenceOfNode;
 
 #endif
index c47a283..f780648 100644 (file)
@@ -20,7 +20,7 @@
 #include <AdvApp2Var_Patch.hxx>
 #include <NCollection_Sequence.hxx>
 
-typedef NCollection_Sequence<AdvApp2Var_Patch> AdvApp2Var_SequenceOfPatch;
+typedef NCollection_Sequence<Handle(AdvApp2Var_Patch)> AdvApp2Var_SequenceOfPatch;
 
 
 #endif
index 179e440..9ff45bf 100644 (file)
@@ -22,6 +22,6 @@
 
 //! Set of constraints along a same type of Iso on the same level
 
-typedef NCollection_Sequence<AdvApp2Var_Iso> AdvApp2Var_Strip;
+typedef NCollection_Sequence<Handle(AdvApp2Var_Iso)> AdvApp2Var_Strip;
 
 #endif
index 700d081..d47c038 100755 (executable)
@@ -22,7 +22,6 @@ AdvApp2Var_Data_f2c.hxx
 AdvApp2Var_EvaluatorFunc2Var.hxx
 AdvApp2Var_Framework.cxx
 AdvApp2Var_Framework.hxx
-AdvApp2Var_Framework.lxx
 AdvApp2Var_Iso.cxx
 AdvApp2Var_Iso.hxx
 AdvApp2Var_MathBase.cxx
@@ -30,7 +29,6 @@ AdvApp2Var_MathBase.hxx
 AdvApp2Var_MathBase_mathinit.cxx
 AdvApp2Var_Network.cxx
 AdvApp2Var_Network.hxx
-AdvApp2Var_Network.lxx
 AdvApp2Var_Node.cxx
 AdvApp2Var_Node.hxx
 AdvApp2Var_Patch.cxx
index aaf2bed..d6a146a 100644 (file)
@@ -51,6 +51,25 @@ BOPTools_Set::BOPTools_Set
   mySum=0;  
   myUpper=432123;
 }
+
+//=======================================================================
+//function : BOPTools_Set
+//purpose  :
+//=======================================================================
+BOPTools_Set::BOPTools_Set (const BOPTools_Set& theOther)
+: myAllocator(theOther.myAllocator),
+  myShape    (theOther.myShape),
+  myNbShapes (theOther.myNbShapes),
+  mySum      (theOther.mySum),
+  myUpper    (theOther.myUpper)
+{
+  for (TopTools_ListIteratorOfListOfShape aIt (theOther.myShapes); aIt.More(); aIt.Next())
+  {
+    const TopoDS_Shape& aShape = aIt.Value();
+    myShapes.Append (aShape);
+  }
+}
+
 //=======================================================================
 //function :~ 
 //purpose  : 
index 2104bbc..d4b1381 100644 (file)
@@ -40,7 +40,10 @@ public:
 Standard_EXPORT virtual ~BOPTools_Set();
   
   Standard_EXPORT BOPTools_Set(const Handle(NCollection_BaseAllocator)& theAllocator);
-  
+
+  //! Copy constructor.
+  Standard_EXPORT BOPTools_Set (const BOPTools_Set& theOther);
+
   Standard_EXPORT BOPTools_Set& Assign (const BOPTools_Set& Other);
 BOPTools_Set& operator = (const BOPTools_Set& Other)
 {
index 4d70b9e..8e0dc9f 100644 (file)
@@ -118,12 +118,6 @@ public:
     myMaxPoint (thePoint),
     myIsInited (Standard_True) {}
 
-  //! Creates copy of another bounding box.
-  BVH_Box (const BVH_Box& theBox)
-  : myMinPoint (theBox.myMinPoint),
-    myMaxPoint (theBox.myMaxPoint),
-    myIsInited (theBox.myIsInited) {}
-
   //! Creates bounding box from corner points.
   BVH_Box (const BVH_VecNt& theMinPoint,
            const BVH_VecNt& theMaxPoint)
index f7b5ebe..35248b8 100644 (file)
 // Alternatively, this file may be used under the terms of Open CASCADE
 // commercial license or contractual agreement.
 
-//=======================================================================
-// Function : Geom2dHatch_Element
-// Purpose  : Magic Constructor.
-//=======================================================================
-
-#include <Geom2dAdaptor_Curve.hxx>
 #include <Geom2dHatch_Element.hxx>
 
-Geom2dHatch_Element::Geom2dHatch_Element (const Geom2dHatch_Element& Other) 
-: myCurve(Other.myCurve), myOrientation(Other.myOrientation) { 
-}
+#include <Geom2dAdaptor_Curve.hxx>
   
 //=======================================================================
 // Function : Geom2dHatch_Element
index a375c8e..4ab038c 100644 (file)
@@ -35,10 +35,7 @@ public:
 
   
   Standard_EXPORT Geom2dHatch_Element();
-  
-  //! Magic constructor.
-  Standard_EXPORT Geom2dHatch_Element(const Geom2dHatch_Element& Other);
-  
+
   //! Creates an element.
   Standard_EXPORT Geom2dHatch_Element(const Geom2dAdaptor_Curve& Curve, const TopAbs_Orientation Orientation = TopAbs_FORWARD);
   
index ed0eeb1..cbdeafc 100644 (file)
@@ -138,6 +138,10 @@ public:
     return &Order;
   }
 
+  //! Copy constructor.
+  Graphic3d_ValidatedCubeMapOrder (const Graphic3d_ValidatedCubeMapOrder& theOther)
+  : Order (theOther.Order) {}
+
 public:
 
   const Graphic3d_CubeMapOrder Order; //!< Completely valid order
@@ -146,13 +150,11 @@ private:
 
   //! Only Graphic3d_CubeMapOrder can generate Graphic3d_ValidatedCubeMapOrder in 'Validated' method.
   Graphic3d_ValidatedCubeMapOrder(const Graphic3d_CubeMapOrder theOrder)
-    :
-    Order(theOrder)
-  {}
+  : Order(theOrder) {}
 
   //! Deleted 'operator='
   Graphic3d_ValidatedCubeMapOrder& operator= (const Graphic3d_ValidatedCubeMapOrder&);
 
 };
 
-#endif // _Graphic3d_CubeMapOrder_HeaderFile
\ No newline at end of file
+#endif // _Graphic3d_CubeMapOrder_HeaderFile
index 4148497..136c9e9 100644 (file)
@@ -35,12 +35,6 @@ public:
     SetCoord (0.0f, 0.0f, 0.0f);
   }
 
-  //! Creates a point with coordinates identical to thePoint.
-  Graphic3d_Vertex (const Graphic3d_Vertex& thePoint)
-  {
-    SetCoord (thePoint.X(), thePoint.Y(), thePoint.Z());
-  }
-
   //! Creates a point with theX, theY and theZ coordinates.
   Graphic3d_Vertex (const Standard_ShortReal theX,
                     const Standard_ShortReal theY,
index 03713cb..0793bda 100644 (file)
@@ -141,15 +141,6 @@ public:
         && myWorldViewState  == theOther.myWorldViewState;
   }
 
-  //! Copy world view projection state.
-  void operator = (const Graphic3d_WorldViewProjState& theOther)
-  {
-    myIsValid         = theOther.myIsValid;
-    myCamera          = theOther.myCamera;
-    myProjectionState = theOther.myProjectionState;
-    myWorldViewState  = theOther.myWorldViewState;
-  }
-
 private:
 
   Standard_Boolean    myIsValid;
index dab4ddd..c2679a5 100644 (file)
@@ -34,23 +34,6 @@ HatchGen_PointOnElement::HatchGen_PointOnElement () :
 // Purpose  : Constructor.
 //=======================================================================
 
-HatchGen_PointOnElement::HatchGen_PointOnElement (const HatchGen_PointOnElement& Point)
-{
-  myIndex  = Point.myIndex ;
-  myParam  = Point.myParam ;
-  myPosit  = Point.myPosit ;
-  myBefore = Point.myBefore ;
-  myAfter  = Point.myAfter ;
-  mySegBeg = Point.mySegBeg ;
-  mySegEnd = Point.mySegEnd ;
-  myType   = Point.myType ;
-}
-
-//=======================================================================
-// Function : HatchGen_PointOnElement
-// Purpose  : Constructor.
-//=======================================================================
-
 HatchGen_PointOnElement::HatchGen_PointOnElement (const IntRes2d_IntersectionPoint& Point)
 {
   const IntRes2d_Transition& TrsH = Point.TransitionOfFirst() ;
index 03cc920..2c37569 100644 (file)
@@ -40,9 +40,6 @@ public:
   //! ---Purpose; Creates an empty point on element
   Standard_EXPORT HatchGen_PointOnElement();
   
-  //! Creates a point from an other.
-  Standard_EXPORT HatchGen_PointOnElement(const HatchGen_PointOnElement& Point);
-  
   //! Creates a point from an intersection point.
   Standard_EXPORT HatchGen_PointOnElement(const IntRes2d_IntersectionPoint& Point);
   
index 79b2436..f8655fd 100644 (file)
@@ -39,23 +39,6 @@ HatchGen_PointOnHatching::HatchGen_PointOnHatching () :
 // Purpose  : Constructor.
 //=======================================================================
 
-HatchGen_PointOnHatching::HatchGen_PointOnHatching (const HatchGen_PointOnHatching& Point)
-{
-  myIndex  = Point.myIndex ;
-  myParam  = Point.myParam ;
-  myPosit  = Point.myPosit ;
-  myBefore = Point.myBefore ;
-  myAfter  = Point.myAfter ;
-  mySegBeg = Point.mySegBeg ;
-  mySegEnd = Point.mySegEnd ;
-  myPoints = Point.myPoints ;
-}
-
-//=======================================================================
-// Function : HatchGen_PointOnHatching
-// Purpose  : Constructor.
-//=======================================================================
-
 HatchGen_PointOnHatching::HatchGen_PointOnHatching (const IntRes2d_IntersectionPoint& Point)
 {
   myIndex = 0 ;
index e183f3b..ad5f1dd 100644 (file)
@@ -41,10 +41,7 @@ public:
   
   //! Creates an empty point.
   Standard_EXPORT HatchGen_PointOnHatching();
-  
-  //! Creates a point from an other.
-  Standard_EXPORT HatchGen_PointOnHatching(const HatchGen_PointOnHatching& Point);
-  
+
   //! Creates a point from an intersection point.
   Standard_EXPORT HatchGen_PointOnHatching(const IntRes2d_IntersectionPoint& Point);
   
index c3c5f43..b73e14f 100644 (file)
@@ -77,34 +77,6 @@ IGESToBRep_CurveAndSurface::IGESToBRep_CurveAndSurface()
   UpdateMinMaxTol();
 }
 
-
-//=======================================================================
-//function : IGESToBRep_CurveAndSurface
-//purpose  : 
-//=======================================================================
-
-IGESToBRep_CurveAndSurface::IGESToBRep_CurveAndSurface
-  (const IGESToBRep_CurveAndSurface& other)
-: myEps         (other.myEps),
-  myEpsCoeff    (other.myEpsCoeff),
-  myEpsGeom     (other.myEpsGeom),
-  myMinTol      (other.myMinTol),
-  myMaxTol      (other.myMaxTol),
-  myModeIsTopo  (other.myModeIsTopo),
-  myModeApprox  (other.myModeApprox),
-  myContIsOpti  (other.myContIsOpti),
-  myUnitFactor  (other.myUnitFactor),
-  mySurfaceCurve(other.mySurfaceCurve),
-  myContinuity  (other.myContinuity),
-  mySurface     (other.mySurface),
-  myUVResolution(other.myUVResolution),
-  myIsResolCom  (other.myIsResolCom),
-  myModel       (other.myModel),
-  myTP          (other.myTP)
-{  
-}
-
-
 //=======================================================================
 //function : IGESToBRep_CurveAndSurface
 //purpose  : 
index e87022c..3d46fef 100644 (file)
@@ -45,10 +45,6 @@ public:
   //! optimization of  the continuity to False.
   Standard_EXPORT IGESToBRep_CurveAndSurface();
   
-  //! Creates a tool CurveAndSurface ready to run and sets its
-  //! fields as CS's.
-  Standard_EXPORT IGESToBRep_CurveAndSurface(const IGESToBRep_CurveAndSurface& CS);
-  
   //! Creates a tool CurveAndSurface ready to run.
   Standard_EXPORT IGESToBRep_CurveAndSurface(const Standard_Real eps, const Standard_Real epsGeom, const Standard_Real epsCoeff, const Standard_Boolean mode, const Standard_Boolean modeapprox, const Standard_Boolean optimized);
   
index 0f8903c..cb21bc7 100644 (file)
@@ -78,19 +78,7 @@ public:
   {
     return myPOC;
   }
-  //! Assignment operator
-  void Equal (const IntPolyh_Point& Pt)
-  {
-    myX = Pt.myX;
-    myY = Pt.myY;
-    myZ = Pt.myZ;
-    myU = Pt.myU;
-    myV = Pt.myV;
-  }
-  void operator = (const IntPolyh_Point& Pt)
-  {
-    Equal(Pt);
-  }
+
   //! Sets the point
   void Set (const Standard_Real x,
             const Standard_Real y,
index ab39e3b..3553054 100644 (file)
@@ -87,6 +87,16 @@ protected:
   
     IntRes2d_Intersection(const IntRes2d_Intersection& Other);
 
+    //! Assignment
+    IntRes2d_Intersection& operator= (const IntRes2d_Intersection& theOther)
+    {
+      done = theOther.done;
+      reverse = theOther.reverse;
+      lpnt = theOther.lpnt;
+      lseg = theOther.lseg;
+      return *this;
+    }
+
   //! Destructor is protected, for safe inheritance
   ~IntRes2d_Intersection () {}
   
@@ -104,18 +114,12 @@ protected:
   
     Standard_Boolean ReversedParameters() const;
 
+protected:
 
-  Standard_Boolean done;
-
-
-private:
-
-
-
-  Standard_Boolean reverse;
   IntRes2d_SequenceOfIntersectionPoint lpnt;
   IntRes2d_SequenceOfIntersectionSegment lseg;
-
+  Standard_Boolean done;
+  Standard_Boolean reverse;
 
 };
 
index 5d66327..c1debc0 100644 (file)
@@ -102,6 +102,26 @@ Interface_Graph::Interface_Graph
   theflags.Initialize(agraph.BitMap(),Standard_True);
 }
 
+Interface_Graph& Interface_Graph::operator= (const Interface_Graph& theOther)
+{
+  themodel = theOther.Model();
+  thepresents = theOther.thepresents;
+  thesharings = theOther.SharingTable();
+  thestats.Nullify();
+
+  const Standard_Integer nb = theOther.NbStatuses();
+  if (nb != 0)
+  {
+    thestats = new TColStd_HArray1OfInteger(1, nb);
+    for (Standard_Integer i = 1; i <= nb; ++i)
+    {
+      thestats->SetValue (i, theOther.Status(i));
+    }
+    theflags.Initialize (theOther.BitMap(), Standard_True);
+  }
+  return *this;
+}
+
 void Interface_Graph::InitStats()
 {
   thestats = new TColStd_HArray1OfInteger(1,themodel->NbEntities()) , 
index 9714b12..480f318 100644 (file)
@@ -87,6 +87,9 @@ public:
   //! Remark that status are copied from <agraph>, but the other
   //! lists (sharing/shared) are copied only if <copied> = True
   Standard_EXPORT Interface_Graph(const Interface_Graph& agraph, const Standard_Boolean copied = Standard_False);
+
+  //! Assignment
+  Standard_EXPORT Interface_Graph& operator= (const Interface_Graph& theOther);
   
   //! Erases data, making graph ready to rebegin from void
   //! (also resets Shared lists redefinitions)
index f81ffc5..5d24f92 100644 (file)
@@ -97,7 +97,14 @@ public:
   
   //! used when starting
   Standard_EXPORT Interface_STAT(const Interface_STAT& other);
-  
+
+  //! Assignment
+  Interface_STAT& operator= (const Interface_STAT& theOther)
+  {
+    theOther.Internals (thetitle, thetotal, thephnam, thephw, thephdeb,thephfin, thestw);
+    return *this;
+  }
+
   //! Returns fields in once, without copying them, used for copy
   //! when starting
   Standard_EXPORT void Internals (Handle(TCollection_HAsciiString)& tit, Standard_Real& total, Handle(TColStd_HSequenceOfAsciiString)& phn, Handle(TColStd_HSequenceOfReal)& phw, Handle(TColStd_HSequenceOfInteger)& phdeb, Handle(TColStd_HSequenceOfInteger)& phfin, Handle(TColStd_HSequenceOfReal)& stw) const;
index f7840f1..c6a182a 100644 (file)
@@ -67,6 +67,14 @@ Standard_Boolean operator == (const Intf_SectionLine& Other) const
   //! Copies a SectionLine.
   Standard_EXPORT Intf_SectionLine(const Intf_SectionLine& Other);
   
+  //! Assignment
+  Intf_SectionLine& operator= (const Intf_SectionLine& theOther)
+  {
+    //closed = theOther.closed; // not copied as in copy constructor
+    myPoints = theOther.myPoints;
+    return *this;
+  }
+
   //! Adds a point at the end of the SectionLine.
   Standard_EXPORT void Append (const Intf_SectionPoint& Pi);
   
index 361b2fd..e57758d 100644 (file)
@@ -31,20 +31,6 @@ Intf_TangentZone::Intf_TangentZone       ()
   ParamOnFirstMax   = ParamOnSecondMax  = RealFirst();
 }
 
-
-//=======================================================================
-//function : Intf_TangentZone
-//purpose  : Copy
-//=======================================================================
-
-Intf_TangentZone::Intf_TangentZone (const Intf_TangentZone& Other)
-{
-  Result=Other.Result;
-  ParamOnFirstMin   = Other.ParamOnFirstMin;
-  ParamOnFirstMax   = Other.ParamOnFirstMax;
-  ParamOnSecondMin  = Other.ParamOnSecondMin;
-  ParamOnSecondMax  = Other.ParamOnSecondMax;
-}
 //=======================================================================
 //function : Append
 //purpose  : Append the section point to the tangent zone.
index 9e55b6b..d008194 100644 (file)
@@ -81,10 +81,7 @@ Standard_Boolean operator == (const Intf_TangentZone& Other) const
   
   //! Builds an empty tangent zone.
   Standard_EXPORT Intf_TangentZone();
-  
-  //! Copies a Tangent zone.
-  Standard_EXPORT Intf_TangentZone(const Intf_TangentZone& Other);
-  
+
   //! Adds a SectionPoint to the TangentZone.
   Standard_EXPORT void Append (const Intf_SectionPoint& Pi);
   
index a7a961c..f625ea7 100644 (file)
@@ -53,14 +53,6 @@ Intrv_Intervals::Intrv_Intervals (const Intrv_Interval& Int)
 { myInter.Append(Int); }
 
 //=======================================================================
-//function : Intrv_Intervals
-//purpose  :
-//=======================================================================
-
-Intrv_Intervals::Intrv_Intervals (const Intrv_Intervals& Int)
-{ myInter = Int.myInter; }
-
-//=======================================================================
 //function : Intersect
 //purpose  :
 //=======================================================================
index c2b89df..9841cce 100644 (file)
@@ -41,11 +41,7 @@ public:
   
   //! Creates a sequence of one interval.
   Standard_EXPORT Intrv_Intervals(const Intrv_Interval& Int);
-  
-  //! Creates   by   copying  an   existing  sequence of
-  //! intervals.
-  Standard_EXPORT Intrv_Intervals(const Intrv_Intervals& Int);
-  
+
   //! Intersects the intervals with the interval <Tool>.
   Standard_EXPORT void Intersect (const Intrv_Interval& Tool);
   
index 09f6c29..71ec657 100644 (file)
@@ -88,14 +88,6 @@ public:
       myPtrEnd = const_cast<TheItemType*> (&theArray.Last() + 1);
     }
 
-    //! Assignment
-    Iterator& operator= (const Iterator& theOther)
-    {
-      myPtrCur = theOther.myPtrCur;
-      myPtrEnd = theOther.myPtrEnd;
-      return *this;
-    }
-
     //! Check end
     Standard_Boolean More (void) const
     { return myPtrCur < myPtrEnd; }
index d36c531..9b5225f 100644 (file)
@@ -1027,7 +1027,9 @@ void OSD::SetSignal (OSD_SignalMode theSignalMode,
     }
     if (theSignalMode == OSD_SignalMode_SetUnhandled && retcode == 0 && anActOld.sa_handler != SIG_DFL)
     {
-      retcode = sigaction (aSignalTypes[i], &anActOld, &anActOld);
+      struct sigaction anActOld2;
+      sigemptyset(&anActOld2.sa_mask);
+      retcode = sigaction (aSignalTypes[i], &anActOld, &anActOld2);
     }
     Standard_ASSERT(retcode == 0, "sigaction() failed", std::cout << "OSD::SetSignal(): sigaction() failed for " << aSignalTypes[i] << std::endl);
   }
index 519715f..f47bcc7 100644 (file)
 #include <OpenGl_TextureSetPairIterator.hxx>
 #include <OpenGl_Workspace.hxx>
 #include <OpenGl_Aspects.hxx>
+
 #include <Graphic3d_TransformUtils.hxx>
 #include <Graphic3d_RenderingParams.hxx>
-
 #include <Message_Messenger.hxx>
-
 #include <NCollection_Vector.hxx>
-
 #include <Standard_ProgramError.hxx>
+#include <Standard_WarningDisableFunctionCast.hxx>
 
 IMPLEMENT_STANDARD_RTTIEXT(OpenGl_Context,Standard_Transient)
 
index a188ff1..78b25e1 100644 (file)
@@ -30,7 +30,7 @@
 
 #if defined(_MSC_VER) || defined(__ANDROID__) || defined(__QNX__)
   #include <malloc.h>
-#elif (defined(__GNUC__) && __GNUC__ >= 4 && __GNUC_MINOR__ >= 1 && (defined(__i386) || defined(__x86_64)))
+#elif (defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 1)) && (defined(__i386) || defined(__x86_64)))
   #include <mm_malloc.h>
 #else
   extern "C" int posix_memalign (void** thePtr, size_t theAlign, size_t theSize);
@@ -283,7 +283,7 @@ Standard_Address Standard::AllocateAligned (const Standard_Size theSize,
   return _aligned_malloc (theSize, theAlign);
 #elif defined(__ANDROID__) || defined(__QNX__)
   return memalign (theAlign, theSize);
-#elif (defined(__GNUC__) && __GNUC__ >= 4 && __GNUC_MINOR__ >= 1 && (defined(__i386) || defined(__x86_64)))
+#elif (defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 1)) && (defined(__i386) || defined(__x86_64)))
   return _mm_malloc (theSize, theAlign);
 #else
   void* aPtr;
@@ -306,7 +306,7 @@ void Standard::FreeAligned (Standard_Address thePtrAligned)
   _aligned_free (thePtrAligned);
 #elif defined(__ANDROID__) || defined(__QNX__)
   free (thePtrAligned);
-#elif (defined(__GNUC__) && __GNUC__ >= 4 && __GNUC_MINOR__ >= 1 && (defined(__i386) || defined(__x86_64)))
+#elif (defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 1)) && (defined(__i386) || defined(__x86_64)))
   _mm_free (thePtrAligned);
 #else
   free (thePtrAligned);
index 3569972..1ae79d6 100644 (file)
@@ -57,7 +57,14 @@ public:
   
   //! Gets the copy of the values of another field
   Standard_EXPORT void CopyFrom (const StepData_Field& other);
-  
+
+  //! Assignment
+  StepData_Field& operator= (const StepData_Field& theOther)
+  {
+    CopyFrom (theOther);
+    return *this;
+  }
+
   //! Clears the field, to set it as "no value defined"
   //! Just before SetList, predeclares it as "any"
   //! A Kind can be directly set here to declare a type
index f18947e..1a39237 100644 (file)
@@ -203,5 +203,5 @@ const Handle(TDF_RelocationTable)& TDF_CopyLabel::RelocationTable() const
 
 void TDF_CopyLabel::UseFilter(const TDF_IDFilter& aFilter) 
 {
-  myFilter = aFilter;
+  myFilter.Assign (aFilter);
 }
index 328d277..5b24e6a 100644 (file)
@@ -37,17 +37,6 @@ TDF_IDFilter::TDF_IDFilter(const Standard_Boolean ignoreMode) :
 myIgnore(ignoreMode)
 {}
 
-
-//=======================================================================
-//function : TDF_IDFilter
-//purpose  : Private, to forbid implicit or hidden accesses to
-//          the copy constructor.
-//=======================================================================
-
-TDF_IDFilter::TDF_IDFilter(const TDF_IDFilter& /*aFilter*/)
-{}
-
-
 //=======================================================================
 //function : IgnoreAll
 //purpose  : 
index 6b7f4b1..aad20f1 100644 (file)
@@ -104,27 +104,25 @@ public:
   //! Writes the contents of <me> to <OS>.
   Standard_EXPORT void Dump (Standard_OStream& anOS) const;
 
-
-
-
-protected:
-
-
-
-
+  //! Assignment
+  void Assign (const TDF_IDFilter& theFilter)
+  {
+    myIgnore = theFilter.myIgnore;
+    myIDMap  = theFilter.myIDMap;
+  }
 
 private:
 
-  
   //! Private, to forbid implicit or hidden accesses to
   //! the copy constructor.
-  Standard_EXPORT TDF_IDFilter(const TDF_IDFilter& aFilter);
+  TDF_IDFilter(const TDF_IDFilter& aFilter);
+  TDF_IDFilter& operator= (const TDF_IDFilter& theOther);
 
+private:
 
   Standard_Boolean myIgnore;
   TDF_IDMap myIDMap;
 
-
 };
 
 
index b3eab9e..d2395d9 100644 (file)
 
 TDF_Transaction::TDF_Transaction
 (const TCollection_AsciiString& aName)
-: myUntilTransaction(0),
-  myName(aName)
+: myName(aName),
+  myUntilTransaction(0)
 {}
 
-
-//=======================================================================
-//function : TDF_Transaction
-//purpose  : Private copy constructor.
-//=======================================================================
-
-TDF_Transaction::TDF_Transaction(const TDF_Transaction& /*aTrans*/)
-{}
-
-
 //=======================================================================
 //function : TDF_Transaction
 //purpose  : 
@@ -64,8 +54,8 @@ TDF_Transaction::TDF_Transaction
 (const Handle(TDF_Data)& aDF,
  const TCollection_AsciiString& aName)
 : myDF(aDF),
-  myUntilTransaction(0),
-  myName(aName)
+  myName(aName),
+  myUntilTransaction(0)
 {}
 
 
index e9c3708..dca67e8 100644 (file)
@@ -96,26 +96,17 @@ public:
   //! Dumps the content of me into the stream
   Standard_EXPORT void DumpJson (Standard_OStream& theOStream, Standard_Integer theDepth = -1) const;
 
-
-
-
-protected:
-
-
-
-
-
 private:
 
-  
   //! Private to avoid copy.
-  Standard_EXPORT TDF_Transaction(const TDF_Transaction& aTrans);
+  TDF_Transaction(const TDF_Transaction& aTrans);
+  TDF_Transaction& operator= (const TDF_Transaction& theOther);
 
+private:
 
   Handle(TDF_Data) myDF;
-  Standard_Integer myUntilTransaction;
   TCollection_AsciiString myName;
-
+  Standard_Integer myUntilTransaction;
 
 };
 
index 1319abb..f79a5e4 100644 (file)
@@ -76,12 +76,12 @@ TDocStd_Document::TDocStd_Document(const TCollection_ExtendedString& aStorageFor
 myStorageFormat(aStorageFormat),
 myData (new TDF_Data()),
 myUndoLimit(0),
+myUndoTransaction ("UNDO"),
 mySaveTime(0),
 myIsNestedTransactionMode(0),
 mySaveEmptyLabels(Standard_False)
 {
-  TDF_Transaction* pTr =  new TDF_Transaction (myData,"UNDO");
-  myUndoTransaction    = *pTr; delete pTr;
+  myUndoTransaction.Initialize (myData);
   TDocStd_Owner::SetDocument(myData,this);
 
 #ifdef SRN_DELTA_COMPACT
@@ -131,8 +131,7 @@ TCollection_ExtendedString TDocStd_Document::GetPath () const
 void TDocStd_Document::SetData (const Handle(TDF_Data)& D)
 {
   myData = D;
-  TDF_Transaction* pTr = new TDF_Transaction(myData,"UNDO");
-  myUndoTransaction = *pTr; delete pTr;  
+  myUndoTransaction.Initialize (myData);
 }
 
 //=======================================================================
index 523650f..ec6b96d 100644 (file)
@@ -290,7 +290,7 @@ Standard_EXPORT Standard_Boolean FDS_SIisGIofIofSBAofTofI(const TopOpeBRepDS_Dat
   if (I.IsNull()) return Standard_False;
   Standard_Boolean ya = Standard_False;
 
-  TopAbs_ShapeEnum SB1,SA1;Standard_Integer IB1,IA1;TopOpeBRepDS_Kind GT1,ST1;Standard_Integer G1,S1;
+  TopAbs_ShapeEnum SB1 = TopAbs_SHAPE, SA1 = TopAbs_SHAPE; Standard_Integer IB1 = 0, IA1 = 0; TopOpeBRepDS_Kind GT1 = TopOpeBRepDS_UNKNOWN, ST1 = TopOpeBRepDS_UNKNOWN; Standard_Integer G1 = 0, S1 = 0;
   FDS_Idata(I,SB1,IB1,SA1,IA1,GT1,G1,ST1,S1);
   
   if (SB1 == TopAbs_FACE) {
@@ -298,7 +298,7 @@ Standard_EXPORT Standard_Boolean FDS_SIisGIofIofSBAofTofI(const TopOpeBRepDS_Dat
     TopOpeBRepDS_ListIteratorOfListOfInterference it(Bloi);
     for(; it.More(); it.Next()) {
       const Handle(TopOpeBRepDS_Interference)& IB = it.Value();
-      TopAbs_ShapeEnum SBB,SAB;Standard_Integer IBB,IAB;TopOpeBRepDS_Kind GTB,STB;Standard_Integer GB,SB;
+      TopAbs_ShapeEnum SBB = TopAbs_SHAPE, SAB = TopAbs_SHAPE; Standard_Integer IBB = 0, IAB = 0; TopOpeBRepDS_Kind GTB = TopOpeBRepDS_UNKNOWN, STB = TopOpeBRepDS_UNKNOWN; Standard_Integer GB = 0, SB = 0;
       FDS_Idata(IB,SBB,IBB,SAB,IAB,GTB,GB,STB,SB);
       if (GTB == TopOpeBRepDS_EDGE && GB == SI) {
        // la face IB1 a une interference dont la geometrie est l'arete SI.
@@ -312,7 +312,7 @@ Standard_EXPORT Standard_Boolean FDS_SIisGIofIofSBAofTofI(const TopOpeBRepDS_Dat
     TopOpeBRepDS_ListIteratorOfListOfInterference it(Aloi);
     for(; it.More(); it.Next()) {
       const Handle(TopOpeBRepDS_Interference)& IA = it.Value();
-      TopAbs_ShapeEnum SBA,SAA;Standard_Integer IBA,IAA;TopOpeBRepDS_Kind GTA,STA;Standard_Integer GA,SA;
+      TopAbs_ShapeEnum SBA = TopAbs_SHAPE, SAA = TopAbs_SHAPE;Standard_Integer IBA = 0, IAA = 0; TopOpeBRepDS_Kind GTA = TopOpeBRepDS_UNKNOWN, STA = TopOpeBRepDS_UNKNOWN; Standard_Integer GA = 0, SA = 0;
       FDS_Idata(IA,SBA,IBA,SAA,IAA,GTA,GA,STA,SA);
       if (GTA == TopOpeBRepDS_EDGE && GA == SI) {
        // la face IA1 a une interference dont la geometrie est l'arete IS.
@@ -558,7 +558,7 @@ Standard_EXPORT void FUN_ds_PURGEforE9(const Handle(TopOpeBRepDS_HDataStructure)
     TopOpeBRepDS_ListIteratorOfListOfInterference it(l3dF);
     while (it.More()) {
       const Handle(TopOpeBRepDS_Interference)& I = it.Value();
-      TopAbs_ShapeEnum SB,SA;Standard_Integer IB,IA;TopOpeBRepDS_Kind GT,ST;Standard_Integer G,S;
+      TopAbs_ShapeEnum SB = TopAbs_SHAPE, SA = TopAbs_SHAPE;Standard_Integer IB = 0, IA = 0;TopOpeBRepDS_Kind GT = TopOpeBRepDS_UNKNOWN, ST = TopOpeBRepDS_UNKNOWN; Standard_Integer G = 0, S = 0;
       FDS_Idata(I,SB,IB,SA,IA,GT,G,ST,S);      
       Standard_Boolean FhasGE = FDS_SIisGIofIofSBAofTofI(BDS,IE,I);
       if (FhasGE) {removed = Standard_True; l3dF.Remove(it); continue;} // E has split ON F (cto904A3;e19,f14)
@@ -610,7 +610,7 @@ Standard_EXPORT void FUN_ds_completeforSE1(const Handle(TopOpeBRepDS_HDataStruct
     for (tki.Init(); tki.More(); tki.Next()) {     
 
       // ISE = (INTERNAL(FACE),G,EDGE) :
-      TopOpeBRepDS_Kind K; Standard_Integer G; const TopOpeBRepDS_ListOfInterference& loi = tki.Value(K,G);      
+      TopOpeBRepDS_Kind K = TopOpeBRepDS_UNKNOWN; Standard_Integer G = 0; const TopOpeBRepDS_ListOfInterference& loi = tki.Value(K,G);
       TopOpeBRepDS_ListOfInterference loicopy; FDS_assign(loi,loicopy);
       TopOpeBRepDS_ListOfInterference lI1; Standard_Boolean hasINT = ::FUN_selectTRAINTinterference(loicopy,lI1);
       if (!hasINT) continue;
@@ -636,8 +636,8 @@ Standard_EXPORT void FUN_ds_completeforSE1(const Handle(TopOpeBRepDS_HDataStruct
       it.Initialize(lI3) ;
       for ( ;it.More(); it.Next()){
        const Handle(TopOpeBRepDS_Interference)& I = it.Value();
-       TopOpeBRepDS_Kind GT,ST;
-        Standard_Integer G1,S;
+       TopOpeBRepDS_Kind GT = TopOpeBRepDS_UNKNOWN, ST = TopOpeBRepDS_UNKNOWN;
+        Standard_Integer G1 = 0, S = 0;
         FDS_data(I,GT,G1,ST,S);
        TopAbs_ShapeEnum tsb,tsa; Standard_Integer isb,isa; FDS_Tdata(I,tsb,isb,tsa,isa);
        const TopoDS_Edge& ES = TopoDS::Edge(BDS.Shape(S)); 
@@ -735,8 +735,8 @@ Standard_EXPORT void FUN_ds_completeforSE2(const Handle(TopOpeBRepDS_HDataStruct
       const Handle(TopOpeBRepDS_Interference)& I = lFE.First();
       Standard_Real par = FDS_Parameter(I);
 
-      TopOpeBRepDS_Kind ST; Standard_Integer S; FDS_data(I,K,G,ST,S);
-      TopAbs_ShapeEnum tsb,tsa; Standard_Integer isb,isa; FDS_Tdata(I,tsb,isb,tsa,isa);
+      TopOpeBRepDS_Kind ST = TopOpeBRepDS_UNKNOWN; Standard_Integer S = 0; FDS_data(I,K,G,ST,S);
+      TopAbs_ShapeEnum tsb = TopAbs_SHAPE, tsa = TopAbs_SHAPE; Standard_Integer isb = 0, isa = 0; FDS_Tdata(I,tsb,isb,tsa,isa);
       const TopoDS_Face& FTRA= TopoDS::Face(BDS.Shape(isb));
       const TopoDS_Edge& ES = TopoDS::Edge(BDS.Shape(S)); 
 
@@ -795,7 +795,7 @@ Standard_EXPORT void FUN_ds_completeforSE2(const Handle(TopOpeBRepDS_HDataStruct
 
        TopOpeBRepDS_Transition newT; 
        // -------
-       Standard_Boolean isonper; Standard_Real par1,par2; Standard_Real factor = 1.e-4;
+       Standard_Boolean isonper = false; Standard_Real par1 = 0.0, par2 = 0.0; Standard_Real factor = 1.e-4;
        FDS_LOIinfsup(BDS,SE,par,K,G,
                        BDS.ShapeInterferences(SE),par1,par2,isonper);
 
@@ -858,19 +858,19 @@ static Standard_Boolean FUN_ds_completeforSE3(const TopOpeBRepDS_DataStructure&
   // Tr
   //---
   const Handle(TopOpeBRepDS_Interference)& I3 = l3d.First();
-  TopOpeBRepDS_Kind K3,ST3; Standard_Integer G3,S3; FDS_data(I3,K3,G3,ST3,S3);
-  TopAbs_ShapeEnum tsb3,tsa3; Standard_Integer isb3,isa3; FDS_Tdata(I3,tsb3,isb3,tsa3,isa3);
+  TopOpeBRepDS_Kind K3 = TopOpeBRepDS_UNKNOWN, ST3 = TopOpeBRepDS_UNKNOWN; Standard_Integer G3 = 0, S3 = 0; FDS_data(I3,K3,G3,ST3,S3);
+  TopAbs_ShapeEnum tsb3 = TopAbs_SHAPE, tsa3 = TopAbs_SHAPE; Standard_Integer isb3 = 0, isa3 = 0; FDS_Tdata(I3,tsb3,isb3,tsa3,isa3);
   IES = S3; ITRASHA = isb3;
   
   const TopoDS_Edge& Eline = TopoDS::Edge(BDS.Shape(IES));
   const TopoDS_Face& F     = TopoDS::Face(BDS.Shape(ITRASHA));
   parE = FDS_Parameter(I3);
 
-  Standard_Real parline; Standard_Boolean ok = FUN_tool_parE(SE,parE,Eline,parline);
+  Standard_Real parline = 0.0; Standard_Boolean ok = FUN_tool_parE(SE,parE,Eline,parline);
   if (!ok) {return Standard_False;}
   gp_Pnt2d uv;    ok = FUN_tool_paronEF(Eline,parline,F,uv);
   if (!ok) {return Standard_False;}
-  Standard_Real par1,par2; FUN_tool_bounds(SE,par1,par2);
+  Standard_Real par1 = 0.0, par2 = 0.0; FUN_tool_bounds(SE,par1,par2);
   Standard_Real factor = 1.e-4;
 
 
@@ -910,8 +910,8 @@ Standard_EXPORT void FUN_ds_completeforSE3(const Handle(TopOpeBRepDS_HDataStruct
     tki.FillOnGeometry(LI);      
     for (tki.Init(); tki.More(); tki.Next()) {     
 
-      TopOpeBRepDS_Kind K; Standard_Integer G; const TopOpeBRepDS_ListOfInterference& loi = tki.Value(K,G);  
-      Standard_Real parE; Standard_Integer IES=0, ITRASHA=0; TopOpeBRepDS_Transition Tr; 
+      TopOpeBRepDS_Kind K = TopOpeBRepDS_UNKNOWN; Standard_Integer G = 0; const TopOpeBRepDS_ListOfInterference& loi = tki.Value(K,G);
+      Standard_Real parE = 0.0; Standard_Integer IES=0, ITRASHA=0; TopOpeBRepDS_Transition Tr;
       Standard_Boolean ok = FUN_ds_completeforSE3(BDS,SE,K,G,loi,parE,IES,ITRASHA,Tr);
       
       TopOpeBRepDS_ListOfInterference loicopy; FDS_assign(loi,loicopy);      
@@ -953,12 +953,12 @@ Standard_EXPORT Standard_Boolean FUN_ds_shareG
   const TopoDS_Edge& E2 = TopoDS::Edge(BDS.Shape(iE2));
 
   Standard_Real tol = Precision::Confusion()*1.e3;
-  Standard_Real f,l; FUN_tool_bounds(Esp,f,l);
+  Standard_Real f = 0.0, l = 0.0; FUN_tool_bounds(Esp,f,l);
   Standard_Real x = 0.45678; Standard_Real par = (1-x)*f + x*l;
   gp_Pnt P; Standard_Boolean ok = FUN_tool_value(par,Esp,P);
   if (!ok) return Standard_False;
   
-  Standard_Real d2,par2; ok = FUN_tool_projPonE(P,E2,par2,d2);
+  Standard_Real d2 = 0.0, par2 = 0.0; ok = FUN_tool_projPonE(P,E2,par2,d2);
   if (!ok) return Standard_False;
   if (d2 > tol)  return Standard_False;    
 
@@ -975,7 +975,7 @@ Standard_EXPORT Standard_Boolean FUN_ds_shareG
     Standard_Boolean isb = mE1.Contains(E1);
     if (!isb) continue;
 
-    Standard_Real d1,par1; ok = FUN_tool_projPonE(P,E1,par1,d1);
+    Standard_Real d1 = 0.0, par1 = 0.0; ok = FUN_tool_projPonE(P,E1,par1,d1);
     if (!ok) continue;
     if (d1 > tol) continue;
 
@@ -1026,11 +1026,11 @@ Standard_EXPORT Standard_Boolean FUN_ds_mkTonFsdm
   // beafter :
   // ---------
   Standard_Boolean ok = Standard_False;
-  gp_Pnt P; Standard_Real parEG;
+  gp_Pnt P; Standard_Real parEG = 0.0;
   if (pardef) parEG = paronEG;
   else {
-    Standard_Real f,l; FUN_tool_bounds(Esp,f,l);
-    Standard_Real dEG; ok = FUN_tool_projPonE(P,EG,parEG,dEG);
+    Standard_Real f = 0.0, l = 0.0; FUN_tool_bounds(Esp,f,l);
+    Standard_Real dEG = 0.0; ok = FUN_tool_projPonE(P,EG,parEG,dEG);
     if (!ok) return Standard_False;
     if (dEG > tol)  return Standard_False; 
   }
@@ -1044,10 +1044,10 @@ Standard_EXPORT Standard_Boolean FUN_ds_mkTonFsdm
   
   // nxx2 :
   // ------
-  Standard_Real par2;
+  Standard_Real par2 = 0.0;
   if (EGisE2) par2 = parEG;
   else {
-    Standard_Real d2; ok = FUN_tool_projPonE(P,E2,par2,d2);
+    Standard_Real d2 = 0.0; ok = FUN_tool_projPonE(P,E2,par2,d2);
     if (!ok) return Standard_False;
     if (d2 > tol)  return Standard_False;    
   }
@@ -1160,7 +1160,7 @@ static Standard_Integer FUN_EisSE2(const TopOpeBRepDS_DataStructure& BDS,
 {
   const TopOpeBRepDS_Transition& T = I->Transition();
   const TopAbs_Orientation O = T.Orientation(TopAbs_IN);
-  TopAbs_ShapeEnum SB,SA;Standard_Integer IB,IA;TopOpeBRepDS_Kind GT,ST;Standard_Integer G,S;
+  TopAbs_ShapeEnum SB = TopAbs_SHAPE, SA = TopAbs_SHAPE;Standard_Integer IB = 0, IA = 0;TopOpeBRepDS_Kind GT = TopOpeBRepDS_UNKNOWN, ST = TopOpeBRepDS_UNKNOWN; Standard_Integer G = 0, S = 0;
   FDS_Idata(I,SB,IB,SA,IA,GT,G,ST,S);
   if (GT != TopOpeBRepDS_VERTEX) return NONE;
   if (M_EXTERNAL(O)) return NONE;
@@ -1172,7 +1172,7 @@ static Standard_Integer FUN_EisSE2(const TopOpeBRepDS_DataStructure& BDS,
   Standard_Integer rkE = BDS.AncestorRank(E);
   Standard_Integer rkG = BDS.AncestorRank(G);   
   const TopoDS_Vertex& VG   = TopoDS::Vertex(BDS.Shape(G));
-  Standard_Integer Gsd; Standard_Boolean Ghsd = FUN_ds_getVsdm(BDS,G,Gsd);
+  Standard_Integer Gsd = 0; Standard_Boolean Ghsd = FUN_ds_getVsdm(BDS,G,Gsd);
   Standard_Integer oGinE = 0;
   if (Ghsd) {
     const TopoDS_Vertex& VGsd = TopoDS::Vertex(BDS.Shape(Gsd));
@@ -1286,14 +1286,14 @@ Standard_EXPORT Standard_Integer FUN_ds_hasI2d(
   TopOpeBRepDS_ListIteratorOfListOfInterference itE(LIE);
   for (; itE.More(); itE.Next()){
     const Handle(TopOpeBRepDS_Interference)& IE = itE.Value();
-    TopOpeBRepDS_Kind GTE,STE; Standard_Integer GE,SE; FDS_data(IE,GTE,GE,STE,SE);
-    TopAbs_ShapeEnum tsb,tsa; Standard_Integer isb,isa; FDS_Tdata(IE,tsb,isb,tsa,isa);
+    TopOpeBRepDS_Kind GTE = TopOpeBRepDS_UNKNOWN, STE = TopOpeBRepDS_UNKNOWN; Standard_Integer GE = 0, SE = 0; FDS_data(IE,GTE,GE,STE,SE);
+    TopAbs_ShapeEnum tsb = TopAbs_SHAPE, tsa = TopAbs_SHAPE; Standard_Integer isb = 0, isa = 0; FDS_Tdata(IE,tsb,isb,tsa,isa);
     
     TopOpeBRepDS_ListIteratorOfListOfInterference itF(LIF);
     Standard_Boolean is3d = Standard_False;
     for (; itF.More(); itF.Next()){
       const Handle(TopOpeBRepDS_Interference)& IF = itF.Value();
-      TopOpeBRepDS_Kind GTF,STF;
+      TopOpeBRepDS_Kind GTF = TopOpeBRepDS_UNKNOWN, STF = TopOpeBRepDS_UNKNOWN;
       Standard_Integer GF=0,SF=0;
       FDS_data(IF,GTF,GF,STF,SF);
       if (GE != GF) continue;
@@ -1329,7 +1329,7 @@ Standard_EXPORT void FUN_ds_completeforSE4(const Handle(TopOpeBRepDS_HDataStruct
     TopOpeBRepDS_TKI tki;
     tki.FillOnGeometry(LI);      
     for (tki.Init(); tki.More(); tki.Next()) {     
-      TopOpeBRepDS_Kind K; Standard_Integer G; const TopOpeBRepDS_ListOfInterference& loi = tki.Value(K,G); 
+      TopOpeBRepDS_Kind K = TopOpeBRepDS_UNKNOWN; Standard_Integer G = 0; const TopOpeBRepDS_ListOfInterference& loi = tki.Value(K,G);
       if (K != TopOpeBRepDS_POINT) continue;
 
       TopOpeBRepDS_ListOfInterference loicopy; FDS_assign(loi,loicopy);
@@ -1339,8 +1339,8 @@ Standard_EXPORT void FUN_ds_completeforSE4(const Handle(TopOpeBRepDS_HDataStruct
       if (n2 < 1) continue;
 
       const Handle(TopOpeBRepDS_Interference)& I = l2.First();
-      TopOpeBRepDS_Kind GT,ST; Standard_Integer S; FDS_data(I,GT,G,ST,S);
-      TopAbs_ShapeEnum tsb,tsa; Standard_Integer isb,isa; FDS_Tdata(I,tsb,isb,tsa,isa);
+      TopOpeBRepDS_Kind GT = TopOpeBRepDS_UNKNOWN, ST = TopOpeBRepDS_UNKNOWN; Standard_Integer S = 0; FDS_data(I,GT,G,ST,S);
+      TopAbs_ShapeEnum tsb = TopAbs_SHAPE, tsa = TopAbs_SHAPE; Standard_Integer isb = 0, isa = 0; FDS_Tdata(I,tsb,isb,tsa,isa);
       const TopoDS_Edge& ES = TopoDS::Edge(BDS.Shape(S));
       const TopoDS_Face& FTRA = TopoDS::Face(BDS.Shape(isb));
 
@@ -1350,8 +1350,8 @@ Standard_EXPORT void FUN_ds_completeforSE4(const Handle(TopOpeBRepDS_HDataStruct
       Standard_Boolean hasFOR=Standard_False,hasREV=Standard_False;
       for (TopOpeBRepDS_ListIteratorOfListOfInterference it(l2); it.More(); it.Next()){
        const Handle(TopOpeBRepDS_Interference)& I2 = it.Value();
-       TopOpeBRepDS_Kind GT2,ST2; Standard_Integer G2,S2; FDS_data(I2,GT2,G2,ST2,S2);
-       TopAbs_ShapeEnum tsb2,tsa2; Standard_Integer isb2,isa2; FDS_Tdata(I2,tsb2,isb2,tsa2,isa2);
+       TopOpeBRepDS_Kind GT2 = TopOpeBRepDS_UNKNOWN, ST2 = TopOpeBRepDS_UNKNOWN; Standard_Integer G2 = 0, S2 = 0; FDS_data(I2,GT2,G2,ST2,S2);
+       TopAbs_ShapeEnum tsb2 = TopAbs_SHAPE, tsa2 = TopAbs_SHAPE; Standard_Integer isb2 = 0, isa2 = 0; FDS_Tdata(I2,tsb2,isb2,tsa2,isa2);
        Standard_Boolean error = (S2 != S) || (isb2 != isb);
        if (error) return; // nyi raise
        TopAbs_Orientation O2 = I2->Transition().Orientation(TopAbs_IN);
@@ -1402,7 +1402,7 @@ Standard_EXPORT void FUN_ds_completeforSE5(const Handle(TopOpeBRepDS_HDataStruct
     TopOpeBRepDS_TKI tki;
     tki.FillOnGeometry(LI);      
     for (tki.Init(); tki.More(); tki.Next()) {     
-      TopOpeBRepDS_Kind K; Standard_Integer G; const TopOpeBRepDS_ListOfInterference& loi = tki.Value(K,G); 
+      TopOpeBRepDS_Kind K = TopOpeBRepDS_UNKNOWN; Standard_Integer G = 0; const TopOpeBRepDS_ListOfInterference& loi = tki.Value(K,G);
       if (K != TopOpeBRepDS_POINT) {FDS_copy(loi,newLI); continue;}
 
       TopOpeBRepDS_ListOfInterference loicopy; FDS_assign(loi,loicopy);
@@ -1617,7 +1617,7 @@ Standard_EXPORT void FUN_ds_completeforE7(const Handle(TopOpeBRepDS_HDataStructu
        
        TopOpeBRepDS_ListOfInterference lFSE; Standard_Integer nFSE = FUN_selectITRASHAinterference(loicopy,IFS,lFSE);
        Standard_Real par = FDS_Parameter(IFOR);
-       Standard_Boolean isonper; Standard_Real par1,par2; Standard_Real factor = 1.e-4;
+       Standard_Boolean isonper = false; Standard_Real par1 = 0.0, par2 = 0.0; Standard_Real factor = 1.e-4;
        FDS_LOIinfsup(BDS,E,par,K,G,BDS.ShapeInterferences(E),par1,par2,isonper);
 
        TopOpeBRepDS_Transition newT;
@@ -1678,7 +1678,7 @@ Standard_EXPORT void FUN_ds_completeforE7(const Handle(TopOpeBRepDS_HDataStructu
     TopOpeBRepDS_ListOfInterference& LII = BDS.ChangeShapeInterferences(E); 
     LII.Clear(); 
     for (tki.Init(); tki.More(); tki.Next()) {   
-      TopOpeBRepDS_Kind K; Standard_Integer G; const TopOpeBRepDS_ListOfInterference& loi = tki.Value(K,G); 
+      TopOpeBRepDS_Kind K = TopOpeBRepDS_UNKNOWN; Standard_Integer G = 0; const TopOpeBRepDS_ListOfInterference& loi = tki.Value(K,G);
       FDS_copy(loi,LII);
     }    
   } //i = 1..ns
@@ -1743,7 +1743,7 @@ Standard_EXPORT void FUN_ds_completeforSE8(const Handle(TopOpeBRepDS_HDataStruct
     TopOpeBRepDS_ListOfInterference& LII = BDS.ChangeShapeInterferences(SE); 
     LII.Clear();
     for (tki.Init(); tki.More(); tki.Next()) {  
-      TopOpeBRepDS_Kind KK; Standard_Integer GG; TopOpeBRepDS_ListOfInterference& loi = tki.ChangeValue(KK,GG);  
+      TopOpeBRepDS_Kind KK = TopOpeBRepDS_UNKNOWN; Standard_Integer GG = 0; TopOpeBRepDS_ListOfInterference& loi = tki.ChangeValue(KK,GG);
       LII.Append(loi);
     }
   }// i=1..nse
@@ -1782,8 +1782,8 @@ Standard_EXPORT void FUN_ds_completeforSE9(const Handle(TopOpeBRepDS_HDataStruct
       
       TopOpeBRepDS_TKI tki; tki.FillOnGeometry(LISE);  
       for (tki.Init(); tki.More(); tki.Next()) {     
-       TopOpeBRepDS_Kind K;
-        Standard_Integer G;
+       TopOpeBRepDS_Kind K = TopOpeBRepDS_UNKNOWN;
+        Standard_Integer G = 0;
 //        const TopOpeBRepDS_ListOfInterference& loi = 
         tki.Value(K,G); 
        const TopoDS_Vertex& vG = TopoDS::Vertex(BDS.Shape(G));
@@ -1835,14 +1835,14 @@ Standard_EXPORT void FUN_ds_PointToVertex(const Handle(TopOpeBRepDS_HDataStructu
     TopOpeBRepDS_TKI tki;
     tki.FillOnGeometry(LI);      
     for (tki.Init(); tki.More(); tki.Next()) {     
-      TopOpeBRepDS_Kind K; Standard_Integer G; const TopOpeBRepDS_ListOfInterference& loi = tki.Value(K,G);  
+      TopOpeBRepDS_Kind K = TopOpeBRepDS_UNKNOWN; Standard_Integer G = 0; const TopOpeBRepDS_ListOfInterference& loi = tki.Value(K,G);
       if (K == TopOpeBRepDS_VERTEX) continue;
       
       Standard_Integer Scur = 0; Standard_Boolean Gfaulty = Standard_False;
       for (TopOpeBRepDS_ListIteratorOfListOfInterference it(loi); it.More(); it.Next()){
        const Handle(TopOpeBRepDS_Interference)& I = it.Value();
-       TopOpeBRepDS_Kind GT,ST;
-        Standard_Integer G1,S;
+       TopOpeBRepDS_Kind GT = TopOpeBRepDS_UNKNOWN, ST = TopOpeBRepDS_UNKNOWN;
+        Standard_Integer G1 = 0, S = 0;
         FDS_data(I,GT,G1,ST,S);
        if (ST != TopOpeBRepDS_EDGE) continue;
        if (Scur == 0) {
@@ -1882,8 +1882,8 @@ Standard_EXPORT void FUN_ds_PointToVertex(const Handle(TopOpeBRepDS_HDataStructu
     TopOpeBRepDS_TKI tki;
     tki.FillOnGeometry(LI);   
     for (tki.Init(); tki.More(); tki.Next()) {     
-      TopOpeBRepDS_Kind K;
-      Standard_Integer G;
+      TopOpeBRepDS_Kind K = TopOpeBRepDS_UNKNOWN;
+      Standard_Integer G = 0;
       const TopOpeBRepDS_ListOfInterference& loi = tki.Value(K,G);  
       Standard_Boolean Gisbound = iPiV.IsBound(G);
       if (!Gisbound) {
@@ -1902,11 +1902,11 @@ Standard_EXPORT void FUN_ds_PointToVertex(const Handle(TopOpeBRepDS_HDataStructu
        if (CPI.IsNull()) continue;
 
        Standard_Real par = CPI->Parameter(); 
-       TopOpeBRepDS_Kind GT,ST;
-        Standard_Integer G1,S;
+       TopOpeBRepDS_Kind GT = TopOpeBRepDS_UNKNOWN, ST = TopOpeBRepDS_UNKNOWN;
+        Standard_Integer G1 = 0, S = 0;
         FDS_data(I,GT,G1,ST,S);
        const TopOpeBRepDS_Transition& T = I->Transition();
-       Standard_Real parvG; Standard_Boolean ok = FUN_tool_parVonE(vG,TopoDS::Edge(s),parvG);
+       Standard_Real parvG = 0.0; Standard_Boolean ok = FUN_tool_parVonE(vG,TopoDS::Edge(s),parvG);
        // modified by NIZHNY-MKK  Mon Apr  2 15:39:59 2001.BEGIN
        //      if (!ok) par = parvG;
        if (!ok) 
@@ -1932,13 +1932,13 @@ static Standard_Boolean FUN_redusamshaonE(const TopOpeBRepDS_DataStructure& BDS,
 // attached to edge(EIX) : IFOR=(FORWARD(ES),G,ES) + IREV=(REVERSED(ES),G,ES)
 {
   newI.Nullify();
-  TopAbs_ShapeEnum SB,SA;Standard_Integer IB,IA;TopOpeBRepDS_Kind GT,ST;Standard_Integer G,S;
+  TopAbs_ShapeEnum SB = TopAbs_SHAPE, SA = TopAbs_SHAPE;Standard_Integer IB = 0, IA = 0; TopOpeBRepDS_Kind GT = TopOpeBRepDS_UNKNOWN, ST = TopOpeBRepDS_UNKNOWN; Standard_Integer G = 0, S = 0;
   FDS_Idata(I,SB,IB,SA,IA,GT,G,ST,S); 
   const TopoDS_Edge& E = TopoDS::Edge(BDS.Shape(EIX));
   Standard_Real parE = FDS_Parameter(I); Standard_Real f,l; FUN_tool_bounds(E,f,l);
   const TopoDS_Edge& ES = TopoDS::Edge(BDS.Shape(S));
   const TopoDS_Face& FTRA = TopoDS::Face(BDS.Shape(IB));
-  Standard_Real parES; Standard_Boolean ok = FUN_tool_parE(E,parE,ES,parES);
+  Standard_Real parES = 0.0; Standard_Boolean ok = FUN_tool_parE(E,parE,ES,parES);
   if (!ok) return Standard_False;
   gp_Pnt2d uv; ok = FUN_tool_paronEF(ES,parES,FTRA,uv);
   if (!ok) return Standard_False;
@@ -1979,7 +1979,7 @@ Standard_EXPORT void FUN_ds_redusamsha(const Handle(TopOpeBRepDS_HDataStructure)
     const TopOpeBRepDS_ListOfInterference& LI = BDS.ShapeInterferences(i);
     tki.FillOnGeometry(LI);      
     for (tki.Init(); tki.More(); tki.Next()) {     
-      TopOpeBRepDS_Kind K; Standard_Integer G; const TopOpeBRepDS_ListOfInterference& loi = tki.Value(K,G);  
+      TopOpeBRepDS_Kind K = TopOpeBRepDS_UNKNOWN; Standard_Integer G = 0; const TopOpeBRepDS_ListOfInterference& loi = tki.Value(K,G);
       TopOpeBRepDS_ListOfInterference loicopy; FDS_copy(loi,loicopy); // loi -> l1+l2
       TopOpeBRepDS_ListOfInterference l0;
       FUN_selectTRASHAinterference(loicopy,TopAbs_EDGE,l0);//xpu091198(cylcong)
@@ -1991,7 +1991,7 @@ Standard_EXPORT void FUN_ds_redusamsha(const Handle(TopOpeBRepDS_HDataStructure)
       //***    
       TopOpeBRepDS_TKI tkis; tkis.FillOnSupport(l2);    
       for (tkis.Init(); tkis.More(); tkis.Next()) {  
-       TopOpeBRepDS_Kind k; Standard_Integer s; TopOpeBRepDS_ListOfInterference& li = tkis.ChangeValue(k,s);   
+       TopOpeBRepDS_Kind k = TopOpeBRepDS_UNKNOWN; Standard_Integer s = 0; TopOpeBRepDS_ListOfInterference& li = tkis.ChangeValue(k,s);
        Standard_Integer nli = li.Extent();
        if (nli < 2) continue; 
 
@@ -2002,7 +2002,7 @@ Standard_EXPORT void FUN_ds_redusamsha(const Handle(TopOpeBRepDS_HDataStructure)
          const TopOpeBRepDS_Transition& T1 = I1->Transition();
          TopAbs_Orientation O1 = T1.Orientation(TopAbs_IN);
          if (!M_FORWARD(O1) && !M_REVERSED(O1)) {it1.Next(); continue;}
-         TopAbs_ShapeEnum SB1,SA1;Standard_Integer IB1,IA1;TopOpeBRepDS_Kind GT1,ST1;Standard_Integer G1,S1;
+         TopAbs_ShapeEnum SB1 = TopAbs_SHAPE, SA1 = TopAbs_SHAPE; Standard_Integer IB1 = 0, IA1 = 0; TopOpeBRepDS_Kind GT1 = TopOpeBRepDS_UNKNOWN, ST1 = TopOpeBRepDS_UNKNOWN; Standard_Integer G1 = 0, S1 = 0;
          FDS_Idata(I1,SB1,IB1,SA1,IA1,GT1,G1,ST1,S1);
          if (IB1 != IA1) {it1.Next(); continue;}
          
@@ -2012,7 +2012,7 @@ Standard_EXPORT void FUN_ds_redusamsha(const Handle(TopOpeBRepDS_HDataStructure)
            const Handle(TopOpeBRepDS_Interference)& I2 = it2.Value();
            const TopOpeBRepDS_Transition& T2 = I2->Transition();
            TopAbs_Orientation O2 = T2.Orientation(TopAbs_IN);
-           TopAbs_ShapeEnum SB2,SA2;Standard_Integer IB2,IA2;TopOpeBRepDS_Kind GT2,ST2;Standard_Integer G2,S2;
+           TopAbs_ShapeEnum SB2 = TopAbs_SHAPE, SA2 = TopAbs_SHAPE; Standard_Integer IB2 = 0, IA2 = 0; TopOpeBRepDS_Kind GT2 = TopOpeBRepDS_UNKNOWN, ST2 = TopOpeBRepDS_UNKNOWN; Standard_Integer G2 = 0, S2 = 0;
            FDS_Idata(I2,SB2,IB2,SA2,IA2,GT2,G2,ST2,S2);
            if (IB2 != IA2) {it2.Next(); continue;}
            if (IB1 != IB2) {it2.Next(); continue;} // same fTRASHA
@@ -2034,7 +2034,7 @@ Standard_EXPORT void FUN_ds_redusamsha(const Handle(TopOpeBRepDS_HDataStructure)
       
       TopOpeBRepDS_ListOfInterference& newloi = tki.ChangeValue(K,G); newloi.Clear();
       for (tkis.Init(); tkis.More(); tkis.Next()) {  
-       TopOpeBRepDS_Kind k; Standard_Integer g; TopOpeBRepDS_ListOfInterference& li = tkis.ChangeValue(k,g); 
+       TopOpeBRepDS_Kind k = TopOpeBRepDS_UNKNOWN; Standard_Integer g = 0; TopOpeBRepDS_ListOfInterference& li = tkis.ChangeValue(k,g);
        newloi.Append(li);
       }  
       newloi.Append(l0); newloi.Append(l1);
@@ -2043,7 +2043,7 @@ Standard_EXPORT void FUN_ds_redusamsha(const Handle(TopOpeBRepDS_HDataStructure)
     TopOpeBRepDS_ListOfInterference& newLI = BDS.ChangeShapeInterferences(E);
     newLI.Clear();
     for (tki.Init(); tki.More(); tki.Next()) {  
-      TopOpeBRepDS_Kind KK; Standard_Integer GG; TopOpeBRepDS_ListOfInterference& loi = tki.ChangeValue(KK,GG);  
+      TopOpeBRepDS_Kind KK = TopOpeBRepDS_UNKNOWN; Standard_Integer GG = 0; TopOpeBRepDS_ListOfInterference& loi = tki.ChangeValue(KK,GG);
       newLI.Append(loi);
     }
   }// i=1..nse  
@@ -2069,7 +2069,7 @@ Standard_EXPORT Standard_Boolean FUN_ds_ONesd(const TopOpeBRepDS_DataStructure&
 {
   const TopoDS_Shape& E = BDS.Shape(IE);
   TopTools_ListIteratorOfListOfShape it(BDS.ShapeSameDomain(E));
-  Standard_Real f,l; FUN_tool_bounds(TopoDS::Edge(EspON),f,l);
+  Standard_Real f = 0.0, l = 0.0; FUN_tool_bounds(TopoDS::Edge(EspON),f,l);
   Standard_Real x = 0.456789; Standard_Real par = (1-x)*f + x*l;
   gp_Pnt p3d; Standard_Boolean ok = FUN_tool_value(par,TopoDS::Edge(EspON),p3d);
   if (!ok) return Standard_False;
@@ -2179,7 +2179,7 @@ Standard_EXPORT Standard_Boolean FDS_LOIinfsup(
                                     Standard_Real& paft,
                                     Standard_Boolean& isonboundper)
 {
-  Standard_Real f,l; FUN_tool_bounds(E,f,l);
+  Standard_Real f = 0.0, l = 0.0; FUN_tool_bounds(E,f,l);
   pbef = f; paft = l;
   Standard_Integer n = LOI.Extent(); 
   if (n == 0) return Standard_True;
@@ -2280,9 +2280,9 @@ Standard_EXPORT Standard_Boolean FDS_stateEwithF2d(const TopOpeBRepDS_DataStruct
                                      TopOpeBRepDS_Transition& TrmemeS)
 {
   const TopOpeBRepDS_ListOfInterference& LOI = BDS.ShapeInterferences(E);
-  Standard_Real pbef,paft; Standard_Boolean isonper; Standard_Boolean ok = FDS_LOIinfsup(BDS,E,pE,KDS,GDS,LOI,pbef,paft,isonper);
+  Standard_Real pbef = 0.0, paft = 0.0; Standard_Boolean isonper = false; Standard_Boolean ok = FDS_LOIinfsup(BDS,E,pE,KDS,GDS,LOI,pbef,paft,isonper);
   if (!ok) return Standard_False;
-  Standard_Real t1,t2; ok = FDS_parbefaft(BDS,E,pE,pbef,paft,isonper,t1,t2);
+  Standard_Real t1 = 0.0, t2 = 0.0; ok = FDS_parbefaft(BDS,E,pE,pbef,paft,isonper,t1,t2);
   gp_Pnt P1; Standard_Boolean ok1 = FUN_tool_value(t1,E,P1);
   gp_Pnt P2; Standard_Boolean ok2 = FUN_tool_value(t2,E,P2);
   if (!ok1 || !ok2) return Standard_False;
@@ -2363,7 +2363,7 @@ Standard_EXPORT void FUN_ds_FEIGb1TO0(Handle(TopOpeBRepDS_HDataStructure)& HDS,
        // nothing's done
       }
       else {
-       Standard_Integer conf; Standard_Boolean ok = TopOpeBRepDS_TOOL::GetConfig(HDS,MEspON,G,Gsd,conf);
+       Standard_Integer conf = 0; Standard_Boolean ok = TopOpeBRepDS_TOOL::GetConfig(HDS,MEspON,G,Gsd,conf);
        if (!ok) {it.Next(); continue;}
        if (conf == DIFFORIENTED) newO = TopAbs::Complement(newO);
       }
@@ -2422,7 +2422,7 @@ Standard_EXPORT void FUN_ds_complete1dForSESDM(const Handle(TopOpeBRepDS_HDataSt
       if (rkEsd == rkSE) continue;
 
       if (BRep_Tool::Degenerated(Esd)) continue;
-      Standard_Boolean isSO;
+      Standard_Boolean isSO = false;
       Standard_Boolean ok = FUN_tool_curvesSO(Esd,SE,isSO);
       if (!ok) continue;
 
@@ -2475,7 +2475,7 @@ Standard_EXPORT void FUN_ds_complete1dForSESDM(const Handle(TopOpeBRepDS_HDataSt
         }
 
         // make new interference
-        Standard_Real par;
+        Standard_Real par = 0.0;
         Standard_Real tol = Max (BRep_Tool::Tolerance(aV), tolEsd);
         Standard_Real parEsd = BRep_Tool::Parameter(aV,Esd);
         ok = FUN_tool_parE (Esd,parEsd,SE,par,tol);
index 6b1ebdb..dd5b5c9 100644 (file)
@@ -48,9 +48,6 @@ public:
   //! Creates quaternion directly from component values
   gp_Quaternion(const Standard_Real x, const Standard_Real y, const Standard_Real z, const Standard_Real w);
   
-  //! Creates copy of another quaternion
-  gp_Quaternion(const gp_Quaternion& theToCopy);
-  
   //! Creates quaternion representing shortest-arc rotation
   //! operator producing vector theVecTo from vector theVecFrom.
   gp_Quaternion(const gp_Vec& theVecFrom, const gp_Vec& theVecTo);
index 95c42b5..3e6273e 100644 (file)
@@ -37,16 +37,6 @@ inline gp_Quaternion::gp_Quaternion (const Standard_Real theX, const Standard_Re
 //purpose  : 
 //=======================================================================
 
-inline gp_Quaternion::gp_Quaternion (const gp_Quaternion& theToCopy)
-: x(theToCopy.x), y(theToCopy.y), z(theToCopy.z), w(theToCopy.w)
-{
-}
-
-//=======================================================================
-//function : gp_Quaternion
-//purpose  : 
-//=======================================================================
-
 inline gp_Quaternion::gp_Quaternion (const gp_Vec& theVecFrom, const gp_Vec& theVecTo)
 {
   SetRotation (theVecFrom, theVecTo);