// Created on: 1992-10-22
// Created by: Laurent BUCHARD
// Copyright (c) 1992-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 <GeomAbs_CurveType.hxx>
#include <GeomAbs_Shape.hxx>
#include <gp_Vec.hxx>
#include <gp_Lin.hxx>
#include <gp_Circ.hxx>
#include <gp_Elips.hxx>
#include <gp_Parab.hxx>
#include <gp_Hypr.hxx>
#include <BRepAdaptor_Curve.hxx>

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

inline Standard_Real
HLRBRep_BCurveTool::FirstParameter (const BRepAdaptor_Curve& C)
{ return(C.FirstParameter()); }

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

inline Standard_Real
HLRBRep_BCurveTool::LastParameter (const BRepAdaptor_Curve& C)
{ return(C.LastParameter()); }

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

inline GeomAbs_Shape
HLRBRep_BCurveTool::Continuity (const BRepAdaptor_Curve& C)
{ return(C.Continuity()); }

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

inline Standard_Integer
HLRBRep_BCurveTool::NbIntervals(const BRepAdaptor_Curve& C,
                                const GeomAbs_Shape Sh)
{ return(C.NbIntervals(Sh)); }

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

inline void
HLRBRep_BCurveTool::Intervals(const BRepAdaptor_Curve& C,
                              TColStd_Array1OfReal& Tab,
                              const GeomAbs_Shape Sh)
{ C.Intervals(Tab,Sh); }

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

inline Standard_Boolean
HLRBRep_BCurveTool::IsClosed(const BRepAdaptor_Curve& C)
{ return(C.IsClosed()); }

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

inline Standard_Boolean
HLRBRep_BCurveTool::IsPeriodic(const BRepAdaptor_Curve& C)
{ return(C.IsPeriodic()); }

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

inline Standard_Real
HLRBRep_BCurveTool::Period(const BRepAdaptor_Curve& C)
{ return(C.Period()); }

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

inline gp_Pnt
HLRBRep_BCurveTool::Value (const BRepAdaptor_Curve& C,
			   const Standard_Real U)
{ return(C.Value(U)); }

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

inline void
HLRBRep_BCurveTool::D0(const BRepAdaptor_Curve& C,
		       const Standard_Real U,
		       gp_Pnt& P)
{ C.D0(U,P); }

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

inline void
HLRBRep_BCurveTool::D1 (const BRepAdaptor_Curve& C,
			const Standard_Real U,
			gp_Pnt& P,
			gp_Vec& T)
{ C.D1(U,P,T); }

inline void
HLRBRep_BCurveTool::D2 (const BRepAdaptor_Curve& C,
			const Standard_Real U,
			gp_Pnt& P,
			gp_Vec& T,
			gp_Vec& N)
{ C.D2(U,P,T,N); }

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

inline void
HLRBRep_BCurveTool::D3 (const BRepAdaptor_Curve& C,
			const Standard_Real U,
			gp_Pnt& P,
			gp_Vec& V1,
			gp_Vec& V2,
			gp_Vec& V3)
{ C.D3(U,P,V1,V2,V3); }

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

inline gp_Vec
HLRBRep_BCurveTool::DN (const BRepAdaptor_Curve& C,
			const Standard_Real U,
			const Standard_Integer N)
{ return(C.DN(U,N)); }

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

inline Standard_Real
HLRBRep_BCurveTool::Resolution(const BRepAdaptor_Curve& C,
			       const Standard_Real R3d)
{ return(C.Resolution(R3d)); }

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

inline GeomAbs_CurveType
 HLRBRep_BCurveTool::GetType(const BRepAdaptor_Curve& C)
{ return(C.GetType()); }

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

inline gp_Lin
HLRBRep_BCurveTool::Line (const BRepAdaptor_Curve& C)
{ return(C.Line()); }

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

inline gp_Circ
HLRBRep_BCurveTool::Circle (const BRepAdaptor_Curve& C)
{ return(C.Circle()); }

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

inline gp_Elips
HLRBRep_BCurveTool::Ellipse (const BRepAdaptor_Curve& C)
{ return(C.Ellipse()); }

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

inline gp_Parab
HLRBRep_BCurveTool::Parabola (const BRepAdaptor_Curve& C)
{ return(C.Parabola()); }

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

inline gp_Hypr
HLRBRep_BCurveTool::Hyperbola (const BRepAdaptor_Curve& C)
{ return(C.Hyperbola()); }

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

inline Standard_Integer
HLRBRep_BCurveTool::Degree (const BRepAdaptor_Curve& C)
{ return(C.Degree()); }

//=======================================================================
//function : IsRational
//purpose  : 
//=======================================================================

inline Standard_Boolean
HLRBRep_BCurveTool::IsRational (const BRepAdaptor_Curve& C)
{ return(C.IsRational()); }

//=======================================================================
//function : NbPoles
//purpose  : 
//=======================================================================

inline Standard_Integer
HLRBRep_BCurveTool::NbPoles (const BRepAdaptor_Curve& C)
{ return(C.NbPoles()); }

//=======================================================================
//function : NbKnots
//purpose  : 
//=======================================================================

inline Standard_Integer
HLRBRep_BCurveTool::NbKnots(const BRepAdaptor_Curve& C)
{ return(C.NbKnots()); }