OCCT

// Created on: 1997-02-19
// Created by: Laurent BUCHARD
// Copyright (c) 1997-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.

#define CONSTRUCTOR IntCurve_IntConicConic::IntCurve_IntConicConic
#define PERFORM void IntCurve_IntConicConic::Perform

inline CONSTRUCTOR() {}

//----------------------------------------------------------------------  L  P
inline CONSTRUCTOR(const gp_Lin2d&        L,
                   const IntRes2d_Domain& DL,
                   const gp_Parab2d&      P,
                   const IntRes2d_Domain& DP,
                   const double           TolConf,
                   const double           Tol)
{
  Perform(L, DL, P, DP, TolConf, Tol);
}

//----------------------------------------------------------------------  L  E
inline CONSTRUCTOR(const gp_Lin2d&        L,
                   const IntRes2d_Domain& DL,
                   const gp_Elips2d&      E,
                   const IntRes2d_Domain& DE,
                   const double           TolConf,
                   const double           Tol)
{

  Perform(L, DL, E, DE, TolConf, Tol);
}

//----------------------------------------------------------------------  L H
inline CONSTRUCTOR(const gp_Lin2d&        L,
                   const IntRes2d_Domain& DL,
                   const gp_Hypr2d&       H,
                   const IntRes2d_Domain& DH,
                   const double           TolConf,
                   const double           Tol)
{

  Perform(L, DL, H, DH, TolConf, Tol);
}

//---------------------------------------------------------------------- C P
inline CONSTRUCTOR(const gp_Circ2d&       C,
                   const IntRes2d_Domain& DC,
                   const gp_Parab2d&      P,
                   const IntRes2d_Domain& DP,
                   const double           TolConf,
                   const double           Tol)
{

  Perform(C, DC, P, DP, TolConf, Tol);
}

//----------------------------------------------------------------------  C E
inline CONSTRUCTOR(const gp_Circ2d&       C,
                   const IntRes2d_Domain& DC,
                   const gp_Elips2d&      E,
                   const IntRes2d_Domain& DE,
                   const double           TolConf,
                   const double           Tol)
{

  Perform(C, DC, E, DE, TolConf, Tol);
}

//---------------------------------------------------------------------- C H
inline CONSTRUCTOR(const gp_Circ2d&       C,
                   const IntRes2d_Domain& DC,
                   const gp_Hypr2d&       H,
                   const IntRes2d_Domain& DH,
                   const double           TolConf,
                   const double           Tol)
{

  Perform(C, DC, H, DH, TolConf, Tol);
}

//---------------------------------------------------------------------- P P
inline CONSTRUCTOR(const gp_Parab2d&      P1,
                   const IntRes2d_Domain& D1,
                   const gp_Parab2d&      P2,
                   const IntRes2d_Domain& D2,
                   const double           TolConf,
                   const double           Tol)
{

  Perform(P1, D1, P2, D2, TolConf, Tol);
}

//---------------------------------------------------------------------- E P
inline CONSTRUCTOR(const gp_Elips2d&      E,
                   const IntRes2d_Domain& DE,
                   const gp_Parab2d&      P,
                   const IntRes2d_Domain& DP,
                   const double           TolConf,
                   const double           Tol)
{
  Perform(E, DE, P, DP, TolConf, Tol);
}

//---------------------------------------------------------------------- P H
inline CONSTRUCTOR(const gp_Parab2d&      P,
                   const IntRes2d_Domain& DP,
                   const gp_Hypr2d&       H,
                   const IntRes2d_Domain& DH,
                   const double           TolConf,
                   const double           Tol)
{

  Perform(P, DP, H, DH, TolConf, Tol);
}

//---------------------------------------------------------------------- E E
inline CONSTRUCTOR(const gp_Elips2d&      E1,
                   const IntRes2d_Domain& D1,
                   const gp_Elips2d&      E2,
                   const IntRes2d_Domain& D2,
                   const double           TolConf,
                   const double           Tol)
{

  Perform(E1, D1, E2, D2, TolConf, Tol);
}

//----------------------------------------------------------------------  E H
inline CONSTRUCTOR(const gp_Elips2d&      E,
                   const IntRes2d_Domain& DE,
                   const gp_Hypr2d&       H,
                   const IntRes2d_Domain& DH,
                   const double           TolConf,
                   const double           Tol)
{

  Perform(E, DE, H, DH, TolConf, Tol);
}

//---------------------------------------------------------------------- H H
inline CONSTRUCTOR(const gp_Hypr2d&       H1,
                   const IntRes2d_Domain& DH1,
                   const gp_Hypr2d&       H2,
                   const IntRes2d_Domain& DH2,
                   const double           TolConf,
                   const double           Tol)
{

  Perform(H1, DH1, H2, DH2, TolConf, Tol);
}

//---------------------------------------------------------------------- L L
inline CONSTRUCTOR(const gp_Lin2d&        L1,
                   const IntRes2d_Domain& D1,
                   const gp_Lin2d&        L2,
                   const IntRes2d_Domain& D2,
                   const double           TolConf,
                   const double           Tol)
{
  Perform(L1, D1, L2, D2, TolConf, Tol);
}

//---------------------------------------------------------------------- L C
inline CONSTRUCTOR(const gp_Lin2d&        L1,
                   const IntRes2d_Domain& D1,
                   const gp_Circ2d&       C2,
                   const IntRes2d_Domain& D2,
                   const double           TolConf,
                   const double           Tol)
{

  Perform(L1, D1, C2, D2, TolConf, Tol);
}

//---------------------------------------------------------------------- C C

inline CONSTRUCTOR(const gp_Circ2d&       C1,
                   const IntRes2d_Domain& D1,
                   const gp_Circ2d&       C2,
                   const IntRes2d_Domain& D2,
                   const double           TolConf,
                   const double           Tol)
{
  SetReversedParameters(false);
  Perform(C1, D1, C2, D2, TolConf, Tol);
}