// Copyright (c) 1999-2012 OPEN CASCADE SAS
//
// The content of this file is subject to the Open CASCADE Technology Public
// License Version 6.5 (the "License"). You may not use the content of this file
// except in compliance with the License. Please obtain a copy of the License
// at http://www.opencascade.org and read it completely before using this file.
//
// The Initial Developer of the Original Code is Open CASCADE S.A.S., having its
// main offices at: 1, place des Freres Montgolfier, 78280 Guyancourt, France.
//
// The Original Code and all software distributed under the License is
// distributed on an "AS IS" basis, without warranty of any kind, and the
// Initial Developer hereby disclaims all such warranties, including without
// limitation, any warranties of merchantability, fitness for a particular
// purpose or non-infringement. Please see the License for the specific terms
// and conditions governing the rights and limitations under the License.


#include <Adaptor2d_Curve2d.hxx>

//=======================================================================
//function : FirstParameter
//purpose  : 
//=======================================================================

inline Standard_Real Adaptor2d_HCurve2d::FirstParameter() const 
{
  return Curve2d().FirstParameter();
}

//=======================================================================
//function : LastParameter
//purpose  : 
//=======================================================================

 inline Standard_Real Adaptor2d_HCurve2d::LastParameter() const 
{
  return Curve2d().LastParameter();
}

//=======================================================================
//function : Continuity
//purpose  : 
//=======================================================================

 inline GeomAbs_Shape Adaptor2d_HCurve2d::Continuity() const 
{
  return Curve2d().Continuity();
}

//=======================================================================
//function : NbIntervals
//purpose  : 
//=======================================================================

 inline Standard_Integer Adaptor2d_HCurve2d::NbIntervals(const GeomAbs_Shape S) const 
{
  return Curve2d().NbIntervals(S);
}

//=======================================================================
//function : Intervals
//purpose  : 
//=======================================================================

 inline void Adaptor2d_HCurve2d::Intervals(TColStd_Array1OfReal& T,
					 const GeomAbs_Shape S) const 
{
  Curve2d().Intervals(T,S);
}

//=======================================================================
//function : Trim
//purpose  : 
//=======================================================================

 inline Handle(Adaptor2d_HCurve2d) Adaptor2d_HCurve2d::Trim
 (const Standard_Real First,
  const Standard_Real Last,
  const Standard_Real Tol) const 
{
  return Curve2d().Trim(First,Last,Tol);
}

//=======================================================================
//function : IsClosed
//purpose  : 
//=======================================================================

 inline Standard_Boolean Adaptor2d_HCurve2d::IsClosed() const 
{
  return Curve2d().IsClosed();
}

//=======================================================================
//function : IsPeriodic
//purpose  : 
//=======================================================================

 inline Standard_Boolean Adaptor2d_HCurve2d::IsPeriodic() const 
{
  return Curve2d().IsPeriodic();
}

//=======================================================================
//function : Period
//purpose  : 
//=======================================================================

 inline Standard_Real Adaptor2d_HCurve2d::Period() const 
{
  return Curve2d().Period();
}

//=======================================================================
//function : Value
//purpose  : 
//=======================================================================

 inline gp_Pnt2d Adaptor2d_HCurve2d::Value(const Standard_Real U) const 
{
  return Curve2d().Value(U);
}

//=======================================================================
//function : D0
//purpose  : 
//=======================================================================

 inline void Adaptor2d_HCurve2d::D0(const Standard_Real U, gp_Pnt2d& P) const 
{
  Curve2d().D0(U,P);
}

//=======================================================================
//function : D1
//purpose  : 
//=======================================================================

 inline void Adaptor2d_HCurve2d::D1(const Standard_Real U, gp_Pnt2d& P, gp_Vec2d& V) const 
{
  Curve2d().D1(U,P,V);
}

//=======================================================================
//function : D2
//purpose  : 
//=======================================================================

 inline void Adaptor2d_HCurve2d::D2(const Standard_Real U, gp_Pnt2d& P, gp_Vec2d& V1, gp_Vec2d& V2) const 
{
  Curve2d().D2(U,P,V1,V2);
}

//=======================================================================
//function : D3
//purpose  : 
//=======================================================================

 inline void Adaptor2d_HCurve2d::D3(const Standard_Real U, gp_Pnt2d& P, gp_Vec2d& V1, gp_Vec2d& V2, gp_Vec2d& V3) const 
{
  Curve2d().D3(U,P,V1,V2,V3);
}

//=======================================================================
//function : DN
//purpose  : 
//=======================================================================

 inline gp_Vec2d Adaptor2d_HCurve2d::DN(const Standard_Real U, const Standard_Integer N) const 
{
  return Curve2d().DN(U,N);
}

//=======================================================================
//function : Resolution
//purpose  : 
//=======================================================================

 inline Standard_Real Adaptor2d_HCurve2d::Resolution(const Standard_Real R3d) const 
{
  return Curve2d().Resolution(R3d);
}

//=======================================================================
//function : GetType
//purpose  : 
//=======================================================================

 inline GeomAbs_CurveType Adaptor2d_HCurve2d::GetType() const 
{
  return Curve2d().GetType();
}

//=======================================================================
//function : Line
//purpose  : 
//=======================================================================

 inline gp_Lin2d Adaptor2d_HCurve2d::Line() const 
{
  return Curve2d().Line();
}

//=======================================================================
//function : Circle
//purpose  : 
//=======================================================================

 inline gp_Circ2d Adaptor2d_HCurve2d::Circle() const 
{
  return Curve2d().Circle();
}

//=======================================================================
//function : Ellipse
//purpose  : 
//=======================================================================

 inline gp_Elips2d Adaptor2d_HCurve2d::Ellipse() const 
{
  return Curve2d().Ellipse();
}

//=======================================================================
//function : Hyperbola
//purpose  : 
//=======================================================================

 inline gp_Hypr2d Adaptor2d_HCurve2d::Hyperbola() const 
{
  return Curve2d().Hyperbola();
}

//=======================================================================
//function : Parabola
//purpose  : 
//=======================================================================

 inline gp_Parab2d Adaptor2d_HCurve2d::Parabola() const 
{
  return Curve2d().Parabola();
}

//=======================================================================
//function : Degree
//purpose  : 
//=======================================================================

inline  Standard_Integer  Adaptor2d_HCurve2d::Degree() const 
{
   return Curve2d().Degree() ;
 }
//=======================================================================
//function : IsRational
//purpose  : 
//=======================================================================

inline  Standard_Boolean  Adaptor2d_HCurve2d::IsRational() const
{
 return  Curve2d().IsRational() ;
} 
//=======================================================================
//function : NbPoles
//purpose  : 
//=======================================================================
inline Standard_Integer  Adaptor2d_HCurve2d::NbPoles() const
{
 return Curve2d().NbPoles() ;
}
//=======================================================================
//function : NbKnots
//purpose  : 
//=======================================================================

inline Standard_Integer  Adaptor2d_HCurve2d::NbKnots() const
{
 return Curve2d().NbKnots() ;
}


//=======================================================================
//function : Bezier
//purpose  : 
//=======================================================================

 inline Handle(Geom2d_BezierCurve) Adaptor2d_HCurve2d::Bezier() const 
{
  return Curve2d().Bezier();
}

//=======================================================================
//function : BSpline
//purpose  : 
//=======================================================================

 inline Handle(Geom2d_BSplineCurve) Adaptor2d_HCurve2d::BSpline() const 
{
  return Curve2d().BSpline();
}