HyperbolaPy.cpp

Go to the documentation of this file.

// This file is generated by src/Tools/generateTemaplates/templateClassPyExport.py out of the .XML file
// Every change you make here get lost at the next full rebuild!
// This File is normaly build as an include in HyperbolaPyImp.cpp! Its not intended to be in a project!

#include <boost/filesystem/path.hpp>
#include <boost/filesystem/operations.hpp>
#include <boost/filesystem/exception.hpp>
#include <Base/PyObjectBase.h>
#include <Base/Console.h>
#include <Base/Exception.h>
#include <CXX/Objects.hxx>

#define new DEBUG_CLIENTBLOCK

using Base::streq;
using namespace Part;

PyTypeObject HyperbolaPy::Type = {
    PyObject_HEAD_INIT(&PyType_Type)
    0,                                                /*ob_size*/
    "Part.GeomHyperbola",     /*tp_name*/
    sizeof(HyperbolaPy),                       /*tp_basicsize*/
    0,                                                /*tp_itemsize*/
    /* methods */
    PyDestructor,                                     /*tp_dealloc*/
    0,                                                /*tp_print*/
    __getattr,                                        /*tp_getattr*/
    __setattr,                                        /*tp_setattr*/
    0,                                                /*tp_compare*/
    __repr,                                           /*tp_repr*/
    0,                                                /*tp_as_number*/
    0,                                                /*tp_as_sequence*/
    0,                                                /*tp_as_mapping*/
    0,                                                /*tp_hash*/
    0,                                                /*tp_call */
    0,                                                /*tp_str  */
    0,                                                /*tp_getattro*/
    0,                                                /*tp_setattro*/
    /* --- Functions to access object as input/output buffer ---------*/
    0,                                                /* tp_as_buffer */
    /* --- Flags to define presence of optional/expanded features */
    Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_CLASS,        /*tp_flags */
    "Describes a hyperbola in 3D space\n"
    "                           To create a hyperbola there are several ways:\n"
    "                           Part.Hyperbola()\n"
    "                                   Creates a hyperbola with major radius 2 and minor radius 1 with the\n"
    "                                   center in (0,0,0)\n"
    "\n"
    "                           Part.Hyperbola(Hyperbola)\n"
    "                                   Create a copy of the given hyperbola\n"
    "\n"
    "                           Part.Hyperbola(S1,S2,Center)\n"
    "                                   Creates a hyperbola centered on the point Center, where\n"
    "                                   the plane of the hyperbola is defined by Center, S1 and S2,\n"
    "                                   its major axis is defined by Center and S1,\n"
    "                                   its major radius is the distance between Center and S1, and\n"
    "                                   its minor radius is the distance between S2 and the major axis.\n"
    "\n"
    "                           Part.Hyperbola(Center,MajorRadius,MinorRadius)\n"
    "                                   Creates a hyperbola with major and minor radii MajorRadius and\n"
    "                                   MinorRadius, and located in the plane defined by Center and\n"
    "                                   the normal (0,0,1)\n"
    "                   ",           /*tp_doc */
    0,                                                /*tp_traverse */
    0,                                                /*tp_clear */
    0,                                                /*tp_richcompare */
    0,                                                /*tp_weaklistoffset */
    0,                                                /*tp_iter */
    0,                                                /*tp_iternext */
    Part::HyperbolaPy::Methods,                     /*tp_methods */
    0,                                                /*tp_members */
    Part::HyperbolaPy::GetterSetter,                     /*tp_getset */
    &Part::GeometryCurvePy::Type,                        /*tp_base */
    0,                                                /*tp_dict */
    0,                                                /*tp_descr_get */
    0,                                                /*tp_descr_set */
    0,                                                /*tp_dictoffset */
    __PyInit,                                         /*tp_init */
    0,                                                /*tp_alloc */
    Part::HyperbolaPy::PyMake,/*tp_new */
    0,                                                /*tp_free   Low-level free-memory routine */
    0,                                                /*tp_is_gc  For PyObject_IS_GC */
    0,                                                /*tp_bases */
    0,                                                /*tp_mro    method resolution order */
    0,                                                /*tp_cache */
    0,                                                /*tp_subclasses */
    0,                                                /*tp_weaklist */
    0                                                 /*tp_del */
};

PyMethodDef HyperbolaPy::Methods[] = {
    {NULL, NULL, 0, NULL}               /* Sentinel */
};



PyGetSetDef HyperbolaPy::GetterSetter[] = {
    {"Eccentricity",
        (getter) staticCallback_getEccentricity,
        (setter) staticCallback_setEccentricity, 
        "Computes the eccentricity of this hyperbola, which is a value greater than 1.\nThe eccentricity is:\ne = f / MajorRadius\nwhere f is the focal distance of this hyperbola.",
        NULL
    },
    {"Focal",
        (getter) staticCallback_getFocal,
        (setter) staticCallback_setFocal, 
        "The focal distance is the distance between\nthe center and a focus of the hyperbola",
        NULL
    },
    {"Focus1",
        (getter) staticCallback_getFocus1,
        (setter) staticCallback_setFocus1, 
        "The first focus is on the positive side of the\n'X Axis' (major axis) of the hyperbola;\nthe second focus is on the negative side.",
        NULL
    },
    {"Focus2",
        (getter) staticCallback_getFocus2,
        (setter) staticCallback_setFocus2, 
        "The first focus is on the positive side of the\n'X Axis' (major axis) of the hyperbola;\nthe second focus is on the negative side.",
        NULL
    },
    {"Parameter",
        (getter) staticCallback_getParameter,
        (setter) staticCallback_setParameter, 
        "Compute the parameter of this hyperbola\nwhich is the distance between its focus\nand its directrix. This distance is twice the focal length.\n                                ",
        NULL
    },
    {"MajorRadius",
        (getter) staticCallback_getMajorRadius,
        (setter) staticCallback_setMajorRadius, 
        "The major radius of the hyperbola.",
        NULL
    },
    {"MinorRadius",
        (getter) staticCallback_getMinorRadius,
        (setter) staticCallback_setMinorRadius, 
        "The minor radius of the hyperbola.",
        NULL
    },
    {"Location",
        (getter) staticCallback_getLocation,
        (setter) staticCallback_setLocation, 
        "Location of the hyperbola",
        NULL
    },
    {"Axis",
        (getter) staticCallback_getAxis,
        (setter) staticCallback_setAxis, 
        "The axis direction of the hyperbola",
        NULL
    },
    {NULL, NULL, NULL, NULL, NULL}              /* Sentinel */
};

// Eccentricity() callback and implementer
// PyObject*  HyperbolaPy::Eccentricity(PyObject *args){};
// has to be implemented in HyperbolaPyImp.cpp
PyObject * HyperbolaPy::staticCallback_getEccentricity (PyObject *self, void * /*closure*/)
{
    if (!((PyObjectBase*) self)->isValid()){
        PyErr_SetString(PyExc_ReferenceError, "This object is already deleted most likely through closing a document. This reference is no longer valid!");
        return NULL;
    }

    try {
        return Py::new_reference_to(((HyperbolaPy*)self)->getEccentricity());
    } catch (const Py::Exception&) {
        // The exception text is already set
        return NULL;
    } catch (...) {
        PyErr_SetString(PyExc_Exception, "Unknown exception while reading attribute 'Eccentricity' of object 'GeomHyperbola'");
        return NULL;
    }
}

int HyperbolaPy::staticCallback_setEccentricity (PyObject *self, PyObject * /*value*/, void * /*closure*/)
{
    if (!((PyObjectBase*) self)->isValid()){
        PyErr_SetString(PyExc_ReferenceError, "This object is already deleted most likely through closing a document. This reference is no longer valid!");
        return -1;
    }

    PyErr_SetString(PyExc_AttributeError, "Attribute 'Eccentricity' of object 'GeomHyperbola' is read-only");
    return -1;
}

// Focal() callback and implementer
// PyObject*  HyperbolaPy::Focal(PyObject *args){};
// has to be implemented in HyperbolaPyImp.cpp
PyObject * HyperbolaPy::staticCallback_getFocal (PyObject *self, void * /*closure*/)
{
    if (!((PyObjectBase*) self)->isValid()){
        PyErr_SetString(PyExc_ReferenceError, "This object is already deleted most likely through closing a document. This reference is no longer valid!");
        return NULL;
    }

    try {
        return Py::new_reference_to(((HyperbolaPy*)self)->getFocal());
    } catch (const Py::Exception&) {
        // The exception text is already set
        return NULL;
    } catch (...) {
        PyErr_SetString(PyExc_Exception, "Unknown exception while reading attribute 'Focal' of object 'GeomHyperbola'");
        return NULL;
    }
}

int HyperbolaPy::staticCallback_setFocal (PyObject *self, PyObject * /*value*/, void * /*closure*/)
{
    if (!((PyObjectBase*) self)->isValid()){
        PyErr_SetString(PyExc_ReferenceError, "This object is already deleted most likely through closing a document. This reference is no longer valid!");
        return -1;
    }

    PyErr_SetString(PyExc_AttributeError, "Attribute 'Focal' of object 'GeomHyperbola' is read-only");
    return -1;
}

// Focus1() callback and implementer
// PyObject*  HyperbolaPy::Focus1(PyObject *args){};
// has to be implemented in HyperbolaPyImp.cpp
PyObject * HyperbolaPy::staticCallback_getFocus1 (PyObject *self, void * /*closure*/)
{
    if (!((PyObjectBase*) self)->isValid()){
        PyErr_SetString(PyExc_ReferenceError, "This object is already deleted most likely through closing a document. This reference is no longer valid!");
        return NULL;
    }

    try {
        return Py::new_reference_to(((HyperbolaPy*)self)->getFocus1());
    } catch (const Py::Exception&) {
        // The exception text is already set
        return NULL;
    } catch (...) {
        PyErr_SetString(PyExc_Exception, "Unknown exception while reading attribute 'Focus1' of object 'GeomHyperbola'");
        return NULL;
    }
}

int HyperbolaPy::staticCallback_setFocus1 (PyObject *self, PyObject * /*value*/, void * /*closure*/)
{
    if (!((PyObjectBase*) self)->isValid()){
        PyErr_SetString(PyExc_ReferenceError, "This object is already deleted most likely through closing a document. This reference is no longer valid!");
        return -1;
    }

    PyErr_SetString(PyExc_AttributeError, "Attribute 'Focus1' of object 'GeomHyperbola' is read-only");
    return -1;
}

// Focus2() callback and implementer
// PyObject*  HyperbolaPy::Focus2(PyObject *args){};
// has to be implemented in HyperbolaPyImp.cpp
PyObject * HyperbolaPy::staticCallback_getFocus2 (PyObject *self, void * /*closure*/)
{
    if (!((PyObjectBase*) self)->isValid()){
        PyErr_SetString(PyExc_ReferenceError, "This object is already deleted most likely through closing a document. This reference is no longer valid!");
        return NULL;
    }

    try {
        return Py::new_reference_to(((HyperbolaPy*)self)->getFocus2());
    } catch (const Py::Exception&) {
        // The exception text is already set
        return NULL;
    } catch (...) {
        PyErr_SetString(PyExc_Exception, "Unknown exception while reading attribute 'Focus2' of object 'GeomHyperbola'");
        return NULL;
    }
}

int HyperbolaPy::staticCallback_setFocus2 (PyObject *self, PyObject * /*value*/, void * /*closure*/)
{
    if (!((PyObjectBase*) self)->isValid()){
        PyErr_SetString(PyExc_ReferenceError, "This object is already deleted most likely through closing a document. This reference is no longer valid!");
        return -1;
    }

    PyErr_SetString(PyExc_AttributeError, "Attribute 'Focus2' of object 'GeomHyperbola' is read-only");
    return -1;
}

// Parameter() callback and implementer
// PyObject*  HyperbolaPy::Parameter(PyObject *args){};
// has to be implemented in HyperbolaPyImp.cpp
PyObject * HyperbolaPy::staticCallback_getParameter (PyObject *self, void * /*closure*/)
{
    if (!((PyObjectBase*) self)->isValid()){
        PyErr_SetString(PyExc_ReferenceError, "This object is already deleted most likely through closing a document. This reference is no longer valid!");
        return NULL;
    }

    try {
        return Py::new_reference_to(((HyperbolaPy*)self)->getParameter());
    } catch (const Py::Exception&) {
        // The exception text is already set
        return NULL;
    } catch (...) {
        PyErr_SetString(PyExc_Exception, "Unknown exception while reading attribute 'Parameter' of object 'GeomHyperbola'");
        return NULL;
    }
}

int HyperbolaPy::staticCallback_setParameter (PyObject *self, PyObject * /*value*/, void * /*closure*/)
{
    if (!((PyObjectBase*) self)->isValid()){
        PyErr_SetString(PyExc_ReferenceError, "This object is already deleted most likely through closing a document. This reference is no longer valid!");
        return -1;
    }

    PyErr_SetString(PyExc_AttributeError, "Attribute 'Parameter' of object 'GeomHyperbola' is read-only");
    return -1;
}

// MajorRadius() callback and implementer
// PyObject*  HyperbolaPy::MajorRadius(PyObject *args){};
// has to be implemented in HyperbolaPyImp.cpp
PyObject * HyperbolaPy::staticCallback_getMajorRadius (PyObject *self, void * /*closure*/)
{
    if (!((PyObjectBase*) self)->isValid()){
        PyErr_SetString(PyExc_ReferenceError, "This object is already deleted most likely through closing a document. This reference is no longer valid!");
        return NULL;
    }

    try {
        return Py::new_reference_to(((HyperbolaPy*)self)->getMajorRadius());
    } catch (const Py::Exception&) {
        // The exception text is already set
        return NULL;
    } catch (...) {
        PyErr_SetString(PyExc_Exception, "Unknown exception while reading attribute 'MajorRadius' of object 'GeomHyperbola'");
        return NULL;
    }
}

int HyperbolaPy::staticCallback_setMajorRadius (PyObject *self, PyObject *value, void * /*closure*/)
{    
    if (!((PyObjectBase*) self)->isValid()){
        PyErr_SetString(PyExc_ReferenceError, "This object is already deleted most likely through closing a document. This reference is no longer valid!");
        return -1;
    }
    if (((PyObjectBase*) self)->isConst()){
        PyErr_SetString(PyExc_ReferenceError, "This object is immutable, you can not set any attribute or call a method");
        return -1;
    }

    try {
        ((HyperbolaPy*)self)->setMajorRadius(Py::Float(value,false));
        return 0;
    } catch (const Py::Exception&) {
        // The exception text is already set
        return -1;
    } catch (...) {
        PyErr_SetString(PyExc_Exception, "Unknown exception while writing attribute 'MajorRadius' of object 'GeomHyperbola'");
        return -1;
    }
}

// MinorRadius() callback and implementer
// PyObject*  HyperbolaPy::MinorRadius(PyObject *args){};
// has to be implemented in HyperbolaPyImp.cpp
PyObject * HyperbolaPy::staticCallback_getMinorRadius (PyObject *self, void * /*closure*/)
{
    if (!((PyObjectBase*) self)->isValid()){
        PyErr_SetString(PyExc_ReferenceError, "This object is already deleted most likely through closing a document. This reference is no longer valid!");
        return NULL;
    }

    try {
        return Py::new_reference_to(((HyperbolaPy*)self)->getMinorRadius());
    } catch (const Py::Exception&) {
        // The exception text is already set
        return NULL;
    } catch (...) {
        PyErr_SetString(PyExc_Exception, "Unknown exception while reading attribute 'MinorRadius' of object 'GeomHyperbola'");
        return NULL;
    }
}

int HyperbolaPy::staticCallback_setMinorRadius (PyObject *self, PyObject *value, void * /*closure*/)
{    
    if (!((PyObjectBase*) self)->isValid()){
        PyErr_SetString(PyExc_ReferenceError, "This object is already deleted most likely through closing a document. This reference is no longer valid!");
        return -1;
    }
    if (((PyObjectBase*) self)->isConst()){
        PyErr_SetString(PyExc_ReferenceError, "This object is immutable, you can not set any attribute or call a method");
        return -1;
    }

    try {
        ((HyperbolaPy*)self)->setMinorRadius(Py::Float(value,false));
        return 0;
    } catch (const Py::Exception&) {
        // The exception text is already set
        return -1;
    } catch (...) {
        PyErr_SetString(PyExc_Exception, "Unknown exception while writing attribute 'MinorRadius' of object 'GeomHyperbola'");
        return -1;
    }
}

// Location() callback and implementer
// PyObject*  HyperbolaPy::Location(PyObject *args){};
// has to be implemented in HyperbolaPyImp.cpp
PyObject * HyperbolaPy::staticCallback_getLocation (PyObject *self, void * /*closure*/)
{
    if (!((PyObjectBase*) self)->isValid()){
        PyErr_SetString(PyExc_ReferenceError, "This object is already deleted most likely through closing a document. This reference is no longer valid!");
        return NULL;
    }

    try {
        return Py::new_reference_to(((HyperbolaPy*)self)->getLocation());
    } catch (const Py::Exception&) {
        // The exception text is already set
        return NULL;
    } catch (...) {
        PyErr_SetString(PyExc_Exception, "Unknown exception while reading attribute 'Location' of object 'GeomHyperbola'");
        return NULL;
    }
}

int HyperbolaPy::staticCallback_setLocation (PyObject *self, PyObject *value, void * /*closure*/)
{    
    if (!((PyObjectBase*) self)->isValid()){
        PyErr_SetString(PyExc_ReferenceError, "This object is already deleted most likely through closing a document. This reference is no longer valid!");
        return -1;
    }
    if (((PyObjectBase*) self)->isConst()){
        PyErr_SetString(PyExc_ReferenceError, "This object is immutable, you can not set any attribute or call a method");
        return -1;
    }

    try {
        ((HyperbolaPy*)self)->setLocation(Py::Object(value,false));
        return 0;
    } catch (const Py::Exception&) {
        // The exception text is already set
        return -1;
    } catch (...) {
        PyErr_SetString(PyExc_Exception, "Unknown exception while writing attribute 'Location' of object 'GeomHyperbola'");
        return -1;
    }
}

// Axis() callback and implementer
// PyObject*  HyperbolaPy::Axis(PyObject *args){};
// has to be implemented in HyperbolaPyImp.cpp
PyObject * HyperbolaPy::staticCallback_getAxis (PyObject *self, void * /*closure*/)
{
    if (!((PyObjectBase*) self)->isValid()){
        PyErr_SetString(PyExc_ReferenceError, "This object is already deleted most likely through closing a document. This reference is no longer valid!");
        return NULL;
    }

    try {
        return Py::new_reference_to(((HyperbolaPy*)self)->getAxis());
    } catch (const Py::Exception&) {
        // The exception text is already set
        return NULL;
    } catch (...) {
        PyErr_SetString(PyExc_Exception, "Unknown exception while reading attribute 'Axis' of object 'GeomHyperbola'");
        return NULL;
    }
}

int HyperbolaPy::staticCallback_setAxis (PyObject *self, PyObject *value, void * /*closure*/)
{    
    if (!((PyObjectBase*) self)->isValid()){
        PyErr_SetString(PyExc_ReferenceError, "This object is already deleted most likely through closing a document. This reference is no longer valid!");
        return -1;
    }
    if (((PyObjectBase*) self)->isConst()){
        PyErr_SetString(PyExc_ReferenceError, "This object is immutable, you can not set any attribute or call a method");
        return -1;
    }

    try {
        ((HyperbolaPy*)self)->setAxis(Py::Object(value,false));
        return 0;
    } catch (const Py::Exception&) {
        // The exception text is already set
        return -1;
    } catch (...) {
        PyErr_SetString(PyExc_Exception, "Unknown exception while writing attribute 'Axis' of object 'GeomHyperbola'");
        return -1;
    }
}



//--------------------------------------------------------------------------
// Parents structure
//--------------------------------------------------------------------------
PyParentObject HyperbolaPy::Parents[] = { PARENTSPartHyperbolaPy };

//--------------------------------------------------------------------------
// Constructor
//--------------------------------------------------------------------------
HyperbolaPy::HyperbolaPy(GeomHyperbola *pcObject, PyTypeObject *T)
    : GeometryCurvePy(reinterpret_cast<GeometryCurvePy::PointerType>(pcObject), T)
{
}


//--------------------------------------------------------------------------
// destructor
//--------------------------------------------------------------------------
HyperbolaPy::~HyperbolaPy()                                // Everything handled in parent
{
}

//--------------------------------------------------------------------------
// HyperbolaPy representation
//--------------------------------------------------------------------------
PyObject *HyperbolaPy::_repr(void)
{
    return Py_BuildValue("s", representation().c_str());
}

//--------------------------------------------------------------------------
// HyperbolaPy Attributes
//--------------------------------------------------------------------------
PyObject *HyperbolaPy::_getattr(char *attr)                             // __getattr__ function: note only need to handle new state
{
    try {
        // getter method for special Attributes (e.g. dynamic ones)
        PyObject *r = getCustomAttributes(attr);
        if(r) return r;
    }
#ifndef DONT_CATCH_CXX_EXCEPTIONS 
    catch(const Base::Exception& e) // catch the FreeCAD exceptions
    {
        std::string str;
        str += "FreeCAD exception thrown (";
        str += e.what();
        str += ")";
        e.ReportException();
        PyErr_SetString(PyExc_Exception,str.c_str());
        return NULL;
    }
    catch(const std::exception& e) // catch other c++ exceptions
    {
        std::string str;
        str += "FC++ exception thrown (";
        str += e.what();
        str += ")";
        Base::Console().Error(str.c_str());
        PyErr_SetString(PyExc_Exception,str.c_str());
        return NULL;
    }
    catch(const Py::Exception&)
    {
        // The exception text is already set
        return NULL;
    }
    catch(...)  // catch the rest!
    {
        PyErr_SetString(PyExc_Exception,"Unknown C++ exception");
        return NULL;
    }
#else  // DONT_CATCH_CXX_EXCEPTIONS  
    catch(const Base::Exception& e) // catch the FreeCAD exceptions
    {
        std::string str;
        str += "FreeCAD exception thrown (";
        str += e.what();
        str += ")";
        e.ReportException();
        PyErr_SetString(PyExc_Exception,str.c_str());
        return NULL;
    }
    catch(const Py::Exception&)
    {
        // The exception text is already set
        return NULL;
    }
#endif  // DONT_CATCH_CXX_EXCEPTIONS

    PyObject *rvalue = Py_FindMethod(Methods, this, attr);
    if (rvalue == NULL)
    {
        PyErr_Clear();
        return GeometryCurvePy::_getattr(attr);
    }
    else
    {
        return rvalue;
    }
}

int HyperbolaPy::_setattr(char *attr, PyObject *value)  // __setattr__ function: note only need to handle new state
{
    try {
        // setter for  special Attributes (e.g. dynamic ones)
        int r = setCustomAttributes(attr, value);
        if(r==1) return 0;
    }
#ifndef DONT_CATCH_CXX_EXCEPTIONS 
    catch(const Base::Exception& e) // catch the FreeCAD exceptions
    {
        std::string str;
        str += "FreeCAD exception thrown (";
        str += e.what();
        str += ")";
        e.ReportException();
        PyErr_SetString(PyExc_Exception,str.c_str());
        return -1;
    }
    catch(const std::exception& e) // catch other c++ exceptions
    {
        std::string str;
        str += "FC++ exception thrown (";
        str += e.what();
        str += ")";
        Base::Console().Error(str.c_str());
        PyErr_SetString(PyExc_Exception,str.c_str());
        return -1;
    }
    catch(const Py::Exception&)
    {
        // The exception text is already set
        return -1;
    }
    catch(...)  // catch the rest!
    {
        PyErr_SetString(PyExc_Exception,"Unknown C++ exception");
        return -1;
    }
#else  // DONT_CATCH_CXX_EXCEPTIONS  
    catch(const Base::Exception& e) // catch the FreeCAD exceptions
    {
        std::string str;
        str += "FreeCAD exception thrown (";
        str += e.what();
        str += ")";
        e.ReportException();
        PyErr_SetString(PyExc_Exception,str.c_str());
        return -1;
    }
    catch(const Py::Exception&)
    {
        // The exception text is already set
        return -1;
    }
#endif  // DONT_CATCH_CXX_EXCEPTIONS

    return GeometryCurvePy::_setattr(attr, value);
}

GeomHyperbola *HyperbolaPy::getGeomHyperbolaPtr(void) const
{
    return static_cast<GeomHyperbola *>(_pcTwinPointer);
}

#if 0
/* From here on come the methods you have to implement, but NOT in this module. Implement in HyperbolaPyImp.cpp! This prototypes 
 * are just for convenience when you add a new method.
 */

PyObject *HyperbolaPy::PyMake(struct _typeobject *, PyObject *, PyObject *)  // Python wrapper
{
    // create a new instance of HyperbolaPy and the Twin object 
    return new HyperbolaPy(new GeomHyperbola);
}

// constructor method
int HyperbolaPy::PyInit(PyObject* /*args*/, PyObject* /*kwd*/)
{
    return 0;
}

// returns a string which represents the object e.g. when printed in python
std::string HyperbolaPy::representation(void) const
{
    return std::string("<GeomHyperbola object>");
}



Py::Float HyperbolaPy::getEccentricity(void) const
{
    //return Py::Float();
    throw Py::AttributeError("Not yet implemented");
}

Py::Float HyperbolaPy::getFocal(void) const
{
    //return Py::Float();
    throw Py::AttributeError("Not yet implemented");
}

Py::Object HyperbolaPy::getFocus1(void) const
{
    //return Py::Object();
    throw Py::AttributeError("Not yet implemented");
}

Py::Object HyperbolaPy::getFocus2(void) const
{
    //return Py::Object();
    throw Py::AttributeError("Not yet implemented");
}

Py::Float HyperbolaPy::getParameter(void) const
{
    //return Py::Float();
    throw Py::AttributeError("Not yet implemented");
}

Py::Float HyperbolaPy::getMajorRadius(void) const
{
    //return Py::Float();
    throw Py::AttributeError("Not yet implemented");
}

void  HyperbolaPy::setMajorRadius(Py::Float arg)
{
    throw Py::AttributeError("Not yet implemented");
}

Py::Float HyperbolaPy::getMinorRadius(void) const
{
    //return Py::Float();
    throw Py::AttributeError("Not yet implemented");
}

void  HyperbolaPy::setMinorRadius(Py::Float arg)
{
    throw Py::AttributeError("Not yet implemented");
}

Py::Object HyperbolaPy::getLocation(void) const
{
    //return Py::Object();
    throw Py::AttributeError("Not yet implemented");
}

void  HyperbolaPy::setLocation(Py::Object arg)
{
    throw Py::AttributeError("Not yet implemented");
}

Py::Object HyperbolaPy::getAxis(void) const
{
    //return Py::Object();
    throw Py::AttributeError("Not yet implemented");
}

void  HyperbolaPy::setAxis(Py::Object arg)
{
    throw Py::AttributeError("Not yet implemented");
}

PyObject *HyperbolaPy::getCustomAttributes(const char* attr) const
{
    return 0;
}

int HyperbolaPy::setCustomAttributes(const char* attr, PyObject *obj)
{
    return 0; 
}
#endif