diff --git a/CMakeLists.txt b/CMakeLists.txt index abfc8de6f41f0a4077ccea44c83b3be8cd72756f..4347a82e59fbace79adc18394bd16db567e404ea 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -11,26 +11,33 @@ if(Boost_FOUND) message(${Boost_INCLUDE_DIRS}) endif(Boost_FOUND) -find_package(PythonLibs REQUIRED) -if(PYTHONLIBS_FOUND) - include_directories(${PYTHON_INCLUDE_DIRS}) -endif(PYTHONLIBS_FOUND) +option(XDMF_WRAP_PYTHON ON) +if(XDMF_WRAP_PYTHON) + find_package(PythonLibs REQUIRED) + if(PYTHONLIBS_FOUND) + include_directories(${PYTHON_INCLUDE_DIRS}) + endif(PYTHONLIBS_FOUND) +endif(XDMF_WRAP_PYTHON) set(XdmfSources XdmfGeometry XdmfGrid + XdmfItem XdmfObject XdmfTopology + XdmfVisitor ) add_library(Xdmf ${XdmfSources}) -add_library(_Xdmf MODULE XdmfPython) -set_target_properties(_Xdmf PROPERTIES PREFIX "") -target_link_libraries(_Xdmf Xdmf) -if(WIN32 OR APPLE) - target_link_libraries(_Xdmf ${PYTHON_LIBRARY}) -endif(WIN32 OR APPLE) +if(XDMF_WRAP_PYTHON) + add_library(_Xdmf MODULE XdmfPython) + set_target_properties(_Xdmf PROPERTIES PREFIX "") + target_link_libraries(_Xdmf Xdmf) + if(WIN32 OR APPLE) + target_link_libraries(_Xdmf ${PYTHON_LIBRARY}) + endif(WIN32 OR APPLE) +endif(XDMF_WRAP_PYTHON) configure_file(Xdmf.py Xdmf.py COPYONLY) diff --git a/Xdmf.i b/Xdmf.i index dba09744021d21014b612282e8259bc02ab289b4..bd467fc158875d323f309e72207cbd19e0bd0cc6 100644 --- a/Xdmf.i +++ b/Xdmf.i @@ -7,28 +7,35 @@ swig -v -c++ -python -o XdmfPython.cpp Xdmf.i %include std_vector.i namespace boost { - template class shared_ptr - { - public: - T * operator-> () const; - }; + template class shared_ptr + { + public: + T * operator-> () const; + }; } %template(XdmfGeometryPtr) boost::shared_ptr; %template(XdmfGridPtr) boost::shared_ptr; +%template(XdmfItemPtr) boost::shared_ptr; %template(XdmfObjPtr) boost::shared_ptr; %template(XdmfTopologyPtr) boost::shared_ptr; +%template(XdmfVisitorPtr) boost::shared_ptr; %module Xdmf %{ - #include - #include - #include - #include + #include + #include + #include + #include + #include + #include %} %include XdmfObject.hpp +%include XdmfItem.hpp +%include XdmfVisitor.hpp + %include XdmfGeometry.hpp %include XdmfGrid.hpp %include XdmfTopology.hpp diff --git a/Xdmf.py b/Xdmf.py index 8b73f66bf66170d90d545fd03e3a9daddbfd36aa..c14bfe2fbfba0b7808a3a343db7e2f16584c021d 100644 --- a/Xdmf.py +++ b/Xdmf.py @@ -109,6 +109,10 @@ class XdmfGeometryPtr(_object): __swig_destroy__ = _Xdmf.delete_XdmfGeometryPtr __del__ = lambda self : None; def New(self): return _Xdmf.XdmfGeometryPtr_New(self) + def getGeometryType(self): return _Xdmf.XdmfGeometryPtr_getGeometryType(self) + def setGeometryType(self, *args): return _Xdmf.XdmfGeometryPtr_setGeometryType(self, *args) + def getGeometryTypeAsString(self): return _Xdmf.XdmfGeometryPtr_getGeometryTypeAsString(self) + def getDimensions(self): return _Xdmf.XdmfGeometryPtr_getDimensions(self) def printSelf(self): return _Xdmf.XdmfGeometryPtr_printSelf(self) XdmfGeometryPtr_swigregister = _Xdmf.XdmfGeometryPtr_swigregister XdmfGeometryPtr_swigregister(XdmfGeometryPtr) @@ -135,6 +139,23 @@ class XdmfGridPtr(_object): XdmfGridPtr_swigregister = _Xdmf.XdmfGridPtr_swigregister XdmfGridPtr_swigregister(XdmfGridPtr) +class XdmfItemPtr(_object): + __swig_setmethods__ = {} + __setattr__ = lambda self, name, value: _swig_setattr(self, XdmfItemPtr, name, value) + __swig_getmethods__ = {} + __getattr__ = lambda self, name: _swig_getattr(self, XdmfItemPtr, name) + __repr__ = _swig_repr + def __deref__(self): return _Xdmf.XdmfItemPtr___deref__(self) + def __init__(self): + this = _Xdmf.new_XdmfItemPtr() + try: self.this.append(this) + except: self.this = this + __swig_destroy__ = _Xdmf.delete_XdmfItemPtr + __del__ = lambda self : None; + def printSelf(self): return _Xdmf.XdmfItemPtr_printSelf(self) +XdmfItemPtr_swigregister = _Xdmf.XdmfItemPtr_swigregister +XdmfItemPtr_swigregister(XdmfItemPtr) + class XdmfObjPtr(_object): __swig_setmethods__ = {} __setattr__ = lambda self, name, value: _swig_setattr(self, XdmfObjPtr, name, value) @@ -148,7 +169,6 @@ class XdmfObjPtr(_object): except: self.this = this __swig_destroy__ = _Xdmf.delete_XdmfObjPtr __del__ = lambda self : None; - def New(self): return _Xdmf.XdmfObjPtr_New(self) def printSelf(self): return _Xdmf.XdmfObjPtr_printSelf(self) XdmfObjPtr_swigregister = _Xdmf.XdmfObjPtr_swigregister XdmfObjPtr_swigregister(XdmfObjPtr) @@ -167,41 +187,117 @@ class XdmfTopologyPtr(_object): __swig_destroy__ = _Xdmf.delete_XdmfTopologyPtr __del__ = lambda self : None; def New(self): return _Xdmf.XdmfTopologyPtr_New(self) - def getXdmfTopologyType(self): return _Xdmf.XdmfTopologyPtr_getXdmfTopologyType(self) + def getTopologyType(self): return _Xdmf.XdmfTopologyPtr_getTopologyType(self) def setTopologyType(self, *args): return _Xdmf.XdmfTopologyPtr_setTopologyType(self, *args) def getTopologyTypeAsString(self): return _Xdmf.XdmfTopologyPtr_getTopologyTypeAsString(self) + def getNodesPerElement(self): return _Xdmf.XdmfTopologyPtr_getNodesPerElement(self) def printSelf(self): return _Xdmf.XdmfTopologyPtr_printSelf(self) XdmfTopologyPtr_swigregister = _Xdmf.XdmfTopologyPtr_swigregister XdmfTopologyPtr_swigregister(XdmfTopologyPtr) +class XdmfVisitorPtr(_object): + __swig_setmethods__ = {} + __setattr__ = lambda self, name, value: _swig_setattr(self, XdmfVisitorPtr, name, value) + __swig_getmethods__ = {} + __getattr__ = lambda self, name: _swig_getattr(self, XdmfVisitorPtr, name) + __repr__ = _swig_repr + def __deref__(self): return _Xdmf.XdmfVisitorPtr___deref__(self) + def __init__(self): + this = _Xdmf.new_XdmfVisitorPtr() + try: self.this.append(this) + except: self.this = this + __swig_destroy__ = _Xdmf.delete_XdmfVisitorPtr + __del__ = lambda self : None; + def New(self): return _Xdmf.XdmfVisitorPtr_New(self) + def printSelf(self): return _Xdmf.XdmfVisitorPtr_printSelf(self) +XdmfVisitorPtr_swigregister = _Xdmf.XdmfVisitorPtr_swigregister +XdmfVisitorPtr_swigregister(XdmfVisitorPtr) + class XdmfObject(_object): __swig_setmethods__ = {} __setattr__ = lambda self, name, value: _swig_setattr(self, XdmfObject, name, value) __swig_getmethods__ = {} __getattr__ = lambda self, name: _swig_getattr(self, XdmfObject, name) - def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined") + def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract") __repr__ = _swig_repr - __swig_getmethods__["New"] = lambda x: _Xdmf.XdmfObject_New - if _newclass:New = staticmethod(_Xdmf.XdmfObject_New) def printSelf(self): return _Xdmf.XdmfObject_printSelf(self) XdmfObject_swigregister = _Xdmf.XdmfObject_swigregister XdmfObject_swigregister(XdmfObject) -def XdmfObject_New(): - return _Xdmf.XdmfObject_New() -XdmfObject_New = _Xdmf.XdmfObject_New +class XdmfItem(XdmfObject): + __swig_setmethods__ = {} + for _s in [XdmfObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{})) + __setattr__ = lambda self, name, value: _swig_setattr(self, XdmfItem, name, value) + __swig_getmethods__ = {} + for _s in [XdmfObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{})) + __getattr__ = lambda self, name: _swig_getattr(self, XdmfItem, name) + def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract") + __repr__ = _swig_repr +XdmfItem_swigregister = _Xdmf.XdmfItem_swigregister +XdmfItem_swigregister(XdmfItem) -class XdmfGeometry(XdmfObject): +class XdmfVisitor(XdmfObject): __swig_setmethods__ = {} for _s in [XdmfObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{})) - __setattr__ = lambda self, name, value: _swig_setattr(self, XdmfGeometry, name, value) + __setattr__ = lambda self, name, value: _swig_setattr(self, XdmfVisitor, name, value) __swig_getmethods__ = {} for _s in [XdmfObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{})) + __getattr__ = lambda self, name: _swig_getattr(self, XdmfVisitor, name) + def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined") + __repr__ = _swig_repr + __swig_getmethods__["New"] = lambda x: _Xdmf.XdmfVisitor_New + if _newclass:New = staticmethod(_Xdmf.XdmfVisitor_New) + def printSelf(self): return _Xdmf.XdmfVisitor_printSelf(self) +XdmfVisitor_swigregister = _Xdmf.XdmfVisitor_swigregister +XdmfVisitor_swigregister(XdmfVisitor) + +def XdmfVisitor_New(): + return _Xdmf.XdmfVisitor_New() +XdmfVisitor_New = _Xdmf.XdmfVisitor_New + +class XdmfGeometryType(_object): + __swig_setmethods__ = {} + __setattr__ = lambda self, name, value: _swig_setattr(self, XdmfGeometryType, name, value) + __swig_getmethods__ = {} + __getattr__ = lambda self, name: _swig_getattr(self, XdmfGeometryType, name) + def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined") + __repr__ = _swig_repr + __swig_getmethods__["dimensions"] = _Xdmf.XdmfGeometryType_dimensions_get + if _newclass:dimensions = _swig_property(_Xdmf.XdmfGeometryType_dimensions_get) + __swig_getmethods__["name"] = _Xdmf.XdmfGeometryType_name_get + if _newclass:name = _swig_property(_Xdmf.XdmfGeometryType_name_get) + def __eq__(self, *args): return _Xdmf.XdmfGeometryType___eq__(self, *args) + def __ne__(self, *args): return _Xdmf.XdmfGeometryType___ne__(self, *args) + __swig_destroy__ = _Xdmf.delete_XdmfGeometryType + __del__ = lambda self : None; +XdmfGeometryType_swigregister = _Xdmf.XdmfGeometryType_swigregister +XdmfGeometryType_swigregister(XdmfGeometryType) +cvar = _Xdmf.cvar +XdmfGeometryType.NoGeometry = _Xdmf.cvar.XdmfGeometryType_NoGeometry +XdmfGeometryType.XYZ = _Xdmf.cvar.XdmfGeometryType_XYZ +XdmfGeometryType.XY = _Xdmf.cvar.XdmfGeometryType_XY +XdmfGeometryType.X_Y_Z = _Xdmf.cvar.XdmfGeometryType_X_Y_Z +XdmfGeometryType.X_Y = _Xdmf.cvar.XdmfGeometryType_X_Y +XdmfGeometryType.VXVYVZ = _Xdmf.cvar.XdmfGeometryType_VXVYVZ +XdmfGeometryType.Origin_DXDYDZ = _Xdmf.cvar.XdmfGeometryType_Origin_DXDYDZ +XdmfGeometryType.VXVY = _Xdmf.cvar.XdmfGeometryType_VXVY +XdmfGeometryType.Origin_DXDY = _Xdmf.cvar.XdmfGeometryType_Origin_DXDY + +class XdmfGeometry(XdmfItem): + __swig_setmethods__ = {} + for _s in [XdmfItem]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{})) + __setattr__ = lambda self, name, value: _swig_setattr(self, XdmfGeometry, name, value) + __swig_getmethods__ = {} + for _s in [XdmfItem]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{})) __getattr__ = lambda self, name: _swig_getattr(self, XdmfGeometry, name) def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined") __repr__ = _swig_repr __swig_getmethods__["New"] = lambda x: _Xdmf.XdmfGeometry_New if _newclass:New = staticmethod(_Xdmf.XdmfGeometry_New) + def getGeometryType(self): return _Xdmf.XdmfGeometry_getGeometryType(self) + def setGeometryType(self, *args): return _Xdmf.XdmfGeometry_setGeometryType(self, *args) + def getGeometryTypeAsString(self): return _Xdmf.XdmfGeometry_getGeometryTypeAsString(self) + def getDimensions(self): return _Xdmf.XdmfGeometry_getDimensions(self) def printSelf(self): return _Xdmf.XdmfGeometry_printSelf(self) XdmfGeometry_swigregister = _Xdmf.XdmfGeometry_swigregister XdmfGeometry_swigregister(XdmfGeometry) @@ -210,12 +306,12 @@ def XdmfGeometry_New(): return _Xdmf.XdmfGeometry_New() XdmfGeometry_New = _Xdmf.XdmfGeometry_New -class XdmfGrid(XdmfObject): +class XdmfGrid(XdmfItem): __swig_setmethods__ = {} - for _s in [XdmfObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{})) + for _s in [XdmfItem]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{})) __setattr__ = lambda self, name, value: _swig_setattr(self, XdmfGrid, name, value) __swig_getmethods__ = {} - for _s in [XdmfObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{})) + for _s in [XdmfItem]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{})) __getattr__ = lambda self, name: _swig_getattr(self, XdmfGrid, name) def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined") __repr__ = _swig_repr @@ -240,17 +336,23 @@ class XdmfTopologyType(_object): __getattr__ = lambda self, name: _swig_getattr(self, XdmfTopologyType, name) def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined") __repr__ = _swig_repr - __swig_getmethods__["numberVertices"] = _Xdmf.XdmfTopologyType_numberVertices_get - if _newclass:numberVertices = _swig_property(_Xdmf.XdmfTopologyType_numberVertices_get) + NoCellType = _Xdmf.XdmfTopologyType_NoCellType + Linear = _Xdmf.XdmfTopologyType_Linear + Quadratic = _Xdmf.XdmfTopologyType_Quadratic + Arbitrary = _Xdmf.XdmfTopologyType_Arbitrary + Structured = _Xdmf.XdmfTopologyType_Structured + __swig_getmethods__["nodesPerElement"] = _Xdmf.XdmfTopologyType_nodesPerElement_get + if _newclass:nodesPerElement = _swig_property(_Xdmf.XdmfTopologyType_nodesPerElement_get) __swig_getmethods__["name"] = _Xdmf.XdmfTopologyType_name_get if _newclass:name = _swig_property(_Xdmf.XdmfTopologyType_name_get) + __swig_getmethods__["cellType"] = _Xdmf.XdmfTopologyType_cellType_get + if _newclass:cellType = _swig_property(_Xdmf.XdmfTopologyType_cellType_get) def __eq__(self, *args): return _Xdmf.XdmfTopologyType___eq__(self, *args) def __ne__(self, *args): return _Xdmf.XdmfTopologyType___ne__(self, *args) __swig_destroy__ = _Xdmf.delete_XdmfTopologyType __del__ = lambda self : None; XdmfTopologyType_swigregister = _Xdmf.XdmfTopologyType_swigregister XdmfTopologyType_swigregister(XdmfTopologyType) -cvar = _Xdmf.cvar XdmfTopologyType.NoTopology = _Xdmf.cvar.XdmfTopologyType_NoTopology XdmfTopologyType.Polyvertex = _Xdmf.cvar.XdmfTopologyType_Polyvertex XdmfTopologyType.Polyline = _Xdmf.cvar.XdmfTopologyType_Polyline @@ -276,20 +378,21 @@ XdmfTopologyType.ThreeDSMesh = _Xdmf.cvar.XdmfTopologyType_ThreeDSMesh XdmfTopologyType.ThreeDRectMesh = _Xdmf.cvar.XdmfTopologyType_ThreeDRectMesh XdmfTopologyType.ThreeDCoRectMesh = _Xdmf.cvar.XdmfTopologyType_ThreeDCoRectMesh -class XdmfTopology(XdmfObject): +class XdmfTopology(XdmfItem): __swig_setmethods__ = {} - for _s in [XdmfObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{})) + for _s in [XdmfItem]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{})) __setattr__ = lambda self, name, value: _swig_setattr(self, XdmfTopology, name, value) __swig_getmethods__ = {} - for _s in [XdmfObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{})) + for _s in [XdmfItem]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{})) __getattr__ = lambda self, name: _swig_getattr(self, XdmfTopology, name) def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined") __repr__ = _swig_repr __swig_getmethods__["New"] = lambda x: _Xdmf.XdmfTopology_New if _newclass:New = staticmethod(_Xdmf.XdmfTopology_New) - def getXdmfTopologyType(self): return _Xdmf.XdmfTopology_getXdmfTopologyType(self) + def getTopologyType(self): return _Xdmf.XdmfTopology_getTopologyType(self) def setTopologyType(self, *args): return _Xdmf.XdmfTopology_setTopologyType(self, *args) def getTopologyTypeAsString(self): return _Xdmf.XdmfTopology_getTopologyTypeAsString(self) + def getNodesPerElement(self): return _Xdmf.XdmfTopology_getNodesPerElement(self) def printSelf(self): return _Xdmf.XdmfTopology_printSelf(self) XdmfTopology_swigregister = _Xdmf.XdmfTopology_swigregister XdmfTopology_swigregister(XdmfTopology) diff --git a/XdmfAttribute.hpp b/XdmfAttribute.hpp index 617dc96fd5f4171ac203e41ad278a07cdc4bfe99..50da921c7d276934d447f78eddb62249dbb07045 100644 --- a/XdmfAttribute.hpp +++ b/XdmfAttribute.hpp @@ -8,9 +8,9 @@ #ifndef XDMFATTRIBUTE_HPP_ #define XDMFATTRIBUTE_HPP_ -#include "XdmfObject.hpp" +#include "XdmfItem.hpp" -class XdmfAttribute : public XdmfObject { +class XdmfAttribute : public XdmfItem { XdmfNewMacro(XdmfAttribute); diff --git a/XdmfGeometry.cpp b/XdmfGeometry.cpp index cec826b62250fd588afc711aac013135269d9b0a..531ae62fcced48f415561e8ca22a60a3d75cf6a5 100644 --- a/XdmfGeometry.cpp +++ b/XdmfGeometry.cpp @@ -7,7 +7,19 @@ #include "XdmfGeometry.hpp" -XdmfGeometry::XdmfGeometry() +// Supported XdmfGeometryTypes +const XdmfGeometryType XdmfGeometryType::NoGeometry("NONE", 0); +const XdmfGeometryType XdmfGeometryType::XYZ("XYZ", 3); +const XdmfGeometryType XdmfGeometryType::XY("XY", 2); +const XdmfGeometryType XdmfGeometryType::X_Y_Z("X_Y_Z", 3); +const XdmfGeometryType XdmfGeometryType::X_Y("X_Y", 2); +const XdmfGeometryType XdmfGeometryType::VXVYVZ("VXVYVZ", 3); +const XdmfGeometryType XdmfGeometryType::Origin_DXDYDZ("ORIGIN_DXDYDZ", 3); +const XdmfGeometryType XdmfGeometryType::VXVY("VXVY", 2); +const XdmfGeometryType XdmfGeometryType::Origin_DXDY("ORIGIN_DXDY", 2); + +XdmfGeometry::XdmfGeometry() : +mGeometryType(&XdmfGeometryType::NoGeometry) { std::cout << "Created Geometry " << this << std::endl; } @@ -17,6 +29,27 @@ XdmfGeometry::~XdmfGeometry() std::cout << "Deleted Geometry " << this << std::endl; } +const XdmfGeometryType& XdmfGeometry::getGeometryType() const +{ + return *mGeometryType; +} + +void XdmfGeometry::setGeometryType(const XdmfGeometryType& geomType) +{ + mGeometryType = &geomType; + return; +} + +const std::string XdmfGeometry::getGeometryTypeAsString() const +{ + return mGeometryType->name; +} + +const int XdmfGeometry::getDimensions() const +{ + return mGeometryType->dimensions; +} + const std::string XdmfGeometry::printSelf() const { return "XdmfGeometry"; diff --git a/XdmfGeometry.hpp b/XdmfGeometry.hpp index a53111ec5963de325349097bacf688e5181611b6..bc8a9ab8d243e13cb2ee19024b13bd8f62293689 100644 --- a/XdmfGeometry.hpp +++ b/XdmfGeometry.hpp @@ -8,13 +8,102 @@ #ifndef XDMFGEOMETRY_HPP_ #define XDMFGEOMETRY_HPP_ -#include "XdmfObject.hpp" +#include "XdmfItem.hpp" -class XdmfGeometry : public XdmfObject { +class XdmfGeometryType { + +public: + + const int dimensions; + const std::string name; + + // Supported Xdmf Geometry Types + static const XdmfGeometryType NoGeometry; + static const XdmfGeometryType XYZ; + static const XdmfGeometryType XY; + static const XdmfGeometryType X_Y_Z; + static const XdmfGeometryType X_Y; + static const XdmfGeometryType VXVYVZ; + static const XdmfGeometryType Origin_DXDYDZ; + static const XdmfGeometryType VXVY; + static const XdmfGeometryType Origin_DXDY; + + /* + * Compare two XdmfGeometry types for equality. Each geometry type has a single static instance meaning that + * equality can be determined by determining if they have the same pointer value. + * + * @param an XdmfGeometryType to compare equality to. + * @return true iff the XdmfGeometryTypes are equal. + */ + bool operator==(const XdmfGeometryType& top) const + { + return (this == &top) ? true : false; + } + + /** + * Compare two XdmfGeometry types for inequality. Each geometry type has a single static instance meaning that + * equality can be determined by determining if they have the same pointer value. + * + * @param XdmfGeometryType to compare inequality to. + * @return true iff the XdmfGeometryTypes are not equal. + */ + bool operator!=(const XdmfGeometryType& top) const + { + return (this != &top) ? true : false; + } + +protected: + + /** + * Protected constructor for XdmfGeometryType. The constructor is protected because all geometry types supported + * by Xdmf should be accessed through static public instances of XdmfGeometryType - i.e. XdmfGeometryType::XYZ. + */ + XdmfGeometryType(const std::string& name, const int& dimensions) : + name(name), + dimensions(dimensions) + {}; + +private: + + //XdmfTopologyType(const XdmfTopologyType&); // Not implemented. + //void operator=(const XdmfTopologyType&); // Not implemented. + +}; + +class XdmfGeometry : public XdmfItem { public: XdmfNewMacro(XdmfGeometry); + + /** + * Get the XdmfGeometryType associated with this Geometry. + * + * @return XdmfGeometryType. + */ + const XdmfGeometryType& getGeometryType() const; + + /** + * Set the XdmfGeometryType associated with this Geometry. + * + * @param XdmfGeometryType to set. + */ + void setGeometryType(const XdmfGeometryType&); + + /** + * Get the name of the GeometryType associated with this Geometry. + * + * @return std::string containing name of the GeometryType. + */ + const std::string getGeometryTypeAsString() const; + + /** + * Get the number of dimensions for this Geometry. + * + * @return int giving number of dimensions: i.e. XY = 2, XYZ = 3. + */ + const int getDimensions() const; + virtual const std::string printSelf() const; protected: @@ -24,15 +113,11 @@ protected: private: - class Delete - { - public: - void operator()(XdmfGeometry * p) { delete p; } - }; - XdmfGeometry(const XdmfGeometry&); // Not implemented. void operator=(const XdmfGeometry&); // Not implemented. + const XdmfGeometryType * mGeometryType; + }; #endif /* XDMFGEOMETRY_HPP_ */ diff --git a/XdmfGrid.cpp b/XdmfGrid.cpp index acfbb997fb541d544d49299cda61e30357a3da3b..becb5e80a667dd52b16fff94ebd894ae2e8e8669 100644 --- a/XdmfGrid.cpp +++ b/XdmfGrid.cpp @@ -9,11 +9,11 @@ #include "XdmfGeometry.hpp" #include "XdmfTopology.hpp" -XdmfGrid::XdmfGrid() +XdmfGrid::XdmfGrid() : +mGeometry(XdmfGeometry::New()), +mTopology(XdmfTopology::New()) { std::cout << "Created Grid " << this << std::endl; - mGeometry = XdmfGeometry::New(); - mTopology = XdmfTopology::New(); } XdmfGrid::~XdmfGrid() diff --git a/XdmfGrid.hpp b/XdmfGrid.hpp index 4277805efd45f66f20502793865697fc06af3f3c..f13e9aac02f5af076fd03855868b4ae33c939c81 100644 --- a/XdmfGrid.hpp +++ b/XdmfGrid.hpp @@ -6,16 +6,15 @@ // Forward Declarations class XdmfAttribute; -class XdmfAttributeVector; class XdmfGeometry; class XdmfTopology; +class XdmfVisitor; // Includes -#include "XdmfObject.hpp" - +#include "XdmfItem.hpp" #include -class XdmfGrid : public XdmfObject { +class XdmfGrid : public XdmfItem { public: @@ -31,6 +30,8 @@ public: // Set the XdmfTopology for this grid XdmfSetValueMacro(Topology, boost::shared_ptr); + //virtual void write(XdmfVisitor&) const; + virtual const std::string printSelf() const; protected: diff --git a/XdmfItem.cpp b/XdmfItem.cpp new file mode 100644 index 0000000000000000000000000000000000000000..d71fce5ee0ca6d8e5c429f53ba92c684449a3c3f --- /dev/null +++ b/XdmfItem.cpp @@ -0,0 +1,10 @@ + +#include "XdmfItem.hpp" + +XdmfItem::XdmfItem() +{ +} + +XdmfItem::~XdmfItem() +{ +} diff --git a/XdmfItem.hpp b/XdmfItem.hpp new file mode 100644 index 0000000000000000000000000000000000000000..3f4fc7cbf7cd524a994006365350208969f740bc --- /dev/null +++ b/XdmfItem.hpp @@ -0,0 +1,36 @@ +/** + * An XdmfItem replaces the XdmfElement class in the previous version of Xdmf. An XdmfElement represents and item that can be + * visited by an XdmfLightDataVisitor and have it's contents added to an XdmfFile. These include XdmfGrids, XdmfSets, + * XdmfTopologies, etc. + * + * This is an abstract base class. + */ + +#ifndef XDMFITEM_HPP_ +#define XDMFITEM_HPP_ + +class XdmfVisitor; + +// Includes +#include "XdmfObject.hpp" + +class XdmfItem : public XdmfObject { + +public: + + //virtual const std::string printSelf() const = 0; + //virtual void write(XdmfVisitor&) const = 0; + +protected: + + XdmfItem(); + virtual ~XdmfItem(); + +private: + + //XdmfItem(const XdmfItem&); // Not implemented. + //void operator=(const XdmfItem&); // Not implemented. + +}; + +#endif /* XDMFITEM_HPP_ */ diff --git a/XdmfObject.hpp b/XdmfObject.hpp index 4d3c28b5f5abd07cb57b12d0983d1c7fbaefa47a..41a2b522136fcc9ed902337e9c58de0416f395c4 100644 --- a/XdmfObject.hpp +++ b/XdmfObject.hpp @@ -36,8 +36,7 @@ class XdmfObject { public: - XdmfNewMacro(XdmfObject); - virtual const std::string printSelf() const; + virtual const std::string printSelf() const = 0; protected: diff --git a/XdmfPython.cpp b/XdmfPython.cpp index 4e241704463190dd3d704a5ba82c3dc9a6e2a3e0..16a1627707fcbd76cdbfa0c415753a45e8e8068d 100644 --- a/XdmfPython.cpp +++ b/XdmfPython.cpp @@ -2686,19 +2686,24 @@ SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) /* -------- TYPES TABLE (BEGIN) -------- */ #define SWIGTYPE_p_XdmfGeometry swig_types[0] -#define SWIGTYPE_p_XdmfGrid swig_types[1] -#define SWIGTYPE_p_XdmfObject swig_types[2] -#define SWIGTYPE_p_XdmfTopology swig_types[3] -#define SWIGTYPE_p_XdmfTopologyType swig_types[4] -#define SWIGTYPE_p_boost__shared_ptrT_XdmfGeometry_t swig_types[5] -#define SWIGTYPE_p_boost__shared_ptrT_XdmfGrid_t swig_types[6] -#define SWIGTYPE_p_boost__shared_ptrT_XdmfObject_t swig_types[7] -#define SWIGTYPE_p_boost__shared_ptrT_XdmfTopology_t swig_types[8] -#define SWIGTYPE_p_char swig_types[9] -#define SWIGTYPE_p_std__invalid_argument swig_types[10] -#define SWIGTYPE_p_swig__SwigPyIterator swig_types[11] -static swig_type_info *swig_types[13]; -static swig_module_info swig_module = {swig_types, 12, 0, 0, 0, 0}; +#define SWIGTYPE_p_XdmfGeometryType swig_types[1] +#define SWIGTYPE_p_XdmfGrid swig_types[2] +#define SWIGTYPE_p_XdmfItem swig_types[3] +#define SWIGTYPE_p_XdmfObject swig_types[4] +#define SWIGTYPE_p_XdmfTopology swig_types[5] +#define SWIGTYPE_p_XdmfTopologyType swig_types[6] +#define SWIGTYPE_p_XdmfVisitor swig_types[7] +#define SWIGTYPE_p_boost__shared_ptrT_XdmfGeometry_t swig_types[8] +#define SWIGTYPE_p_boost__shared_ptrT_XdmfGrid_t swig_types[9] +#define SWIGTYPE_p_boost__shared_ptrT_XdmfItem_t swig_types[10] +#define SWIGTYPE_p_boost__shared_ptrT_XdmfObject_t swig_types[11] +#define SWIGTYPE_p_boost__shared_ptrT_XdmfTopology_t swig_types[12] +#define SWIGTYPE_p_boost__shared_ptrT_XdmfVisitor_t swig_types[13] +#define SWIGTYPE_p_char swig_types[14] +#define SWIGTYPE_p_std__invalid_argument swig_types[15] +#define SWIGTYPE_p_swig__SwigPyIterator swig_types[16] +static swig_type_info *swig_types[18]; +static swig_module_info swig_module = {swig_types, 17, 0, 0, 0, 0}; #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name) #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name) @@ -3188,18 +3193,20 @@ SWIG_From_std_string (const std::string& s) } - #include - #include - #include - #include - - SWIGINTERNINLINE PyObject * SWIG_From_int (int value) { return SWIG_From_long (value); } + + #include + #include + #include + #include + #include + #include + #ifdef __cplusplus extern "C" { #endif @@ -4125,6 +4132,105 @@ fail: } +SWIGINTERN PyObject *_wrap_XdmfGeometryPtr_getGeometryType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfGeometry > *arg1 = (boost::shared_ptr< XdmfGeometry > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + XdmfGeometryType *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfGeometryPtr_getGeometryType",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfGeometry_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfGeometryPtr_getGeometryType" "', argument " "1"" of type '" "boost::shared_ptr< XdmfGeometry > const *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfGeometry > * >(argp1); + result = (XdmfGeometryType *) &(*arg1)->getGeometryType(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XdmfGeometryType, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfGeometryPtr_setGeometryType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfGeometry > *arg1 = (boost::shared_ptr< XdmfGeometry > *) 0 ; + XdmfGeometryType *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:XdmfGeometryPtr_setGeometryType",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfGeometry_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfGeometryPtr_setGeometryType" "', argument " "1"" of type '" "boost::shared_ptr< XdmfGeometry > *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfGeometry > * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_XdmfGeometryType, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XdmfGeometryPtr_setGeometryType" "', argument " "2"" of type '" "XdmfGeometryType const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XdmfGeometryPtr_setGeometryType" "', argument " "2"" of type '" "XdmfGeometryType const &""'"); + } + arg2 = reinterpret_cast< XdmfGeometryType * >(argp2); + (*arg1)->setGeometryType((XdmfGeometryType const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfGeometryPtr_getGeometryTypeAsString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfGeometry > *arg1 = (boost::shared_ptr< XdmfGeometry > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::string result; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfGeometryPtr_getGeometryTypeAsString",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfGeometry_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfGeometryPtr_getGeometryTypeAsString" "', argument " "1"" of type '" "boost::shared_ptr< XdmfGeometry > const *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfGeometry > * >(argp1); + result = (*arg1)->getGeometryTypeAsString(); + resultobj = SWIG_From_std_string(static_cast< std::string >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfGeometryPtr_getDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfGeometry > *arg1 = (boost::shared_ptr< XdmfGeometry > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + int result; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfGeometryPtr_getDimensions",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfGeometry_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfGeometryPtr_getDimensions" "', argument " "1"" of type '" "boost::shared_ptr< XdmfGeometry > const *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfGeometry > * >(argp1); + result = (int)(*arg1)->getDimensions(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + SWIGINTERN PyObject *_wrap_XdmfGeometryPtr_printSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; boost::shared_ptr< XdmfGeometry > *arg1 = (boost::shared_ptr< XdmfGeometry > *) 0 ; @@ -4381,6 +4487,91 @@ SWIGINTERN PyObject *XdmfGridPtr_swigregister(PyObject *SWIGUNUSEDPARM(self), Py return SWIG_Py_Void(); } +SWIGINTERN PyObject *_wrap_XdmfItemPtr___deref__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfItem > *arg1 = (boost::shared_ptr< XdmfItem > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + XdmfItem *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfItemPtr___deref__",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfItem_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfItemPtr___deref__" "', argument " "1"" of type '" "boost::shared_ptr< XdmfItem > const *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfItem > * >(argp1); + result = (XdmfItem *)((boost::shared_ptr< XdmfItem > const *)arg1)->operator ->(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XdmfItem, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_XdmfItemPtr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfItem > *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)":new_XdmfItemPtr")) SWIG_fail; + result = (boost::shared_ptr< XdmfItem > *)new boost::shared_ptr< XdmfItem >(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_boost__shared_ptrT_XdmfItem_t, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_XdmfItemPtr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfItem > *arg1 = (boost::shared_ptr< XdmfItem > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:delete_XdmfItemPtr",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfItem_t, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_XdmfItemPtr" "', argument " "1"" of type '" "boost::shared_ptr< XdmfItem > *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfItem > * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfItemPtr_printSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfItem > *arg1 = (boost::shared_ptr< XdmfItem > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::string result; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfItemPtr_printSelf",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfItem_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfItemPtr_printSelf" "', argument " "1"" of type '" "boost::shared_ptr< XdmfItem > const *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfItem > * >(argp1); + result = (*arg1)->printSelf(); + resultobj = SWIG_From_std_string(static_cast< std::string >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *XdmfItemPtr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_boost__shared_ptrT_XdmfItem_t, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + SWIGINTERN PyObject *_wrap_XdmfObjPtr___deref__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; boost::shared_ptr< XdmfObject > *arg1 = (boost::shared_ptr< XdmfObject > *) 0 ; @@ -4437,28 +4628,6 @@ fail: } -SWIGINTERN PyObject *_wrap_XdmfObjPtr_New(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - boost::shared_ptr< XdmfObject > *arg1 = (boost::shared_ptr< XdmfObject > *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject * obj0 = 0 ; - boost::shared_ptr< XdmfObject > result; - - if (!PyArg_ParseTuple(args,(char *)"O:XdmfObjPtr_New",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfObject_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfObjPtr_New" "', argument " "1"" of type '" "boost::shared_ptr< XdmfObject > *""'"); - } - arg1 = reinterpret_cast< boost::shared_ptr< XdmfObject > * >(argp1); - result = (*arg1)->New(); - resultobj = SWIG_NewPointerObj((new boost::shared_ptr< XdmfObject >(static_cast< const boost::shared_ptr< XdmfObject >& >(result))), SWIGTYPE_p_boost__shared_ptrT_XdmfObject_t, SWIG_POINTER_OWN | 0 ); - return resultobj; -fail: - return NULL; -} - - SWIGINTERN PyObject *_wrap_XdmfObjPtr_printSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; boost::shared_ptr< XdmfObject > *arg1 = (boost::shared_ptr< XdmfObject > *) 0 ; @@ -4566,7 +4735,7 @@ fail: } -SWIGINTERN PyObject *_wrap_XdmfTopologyPtr_getXdmfTopologyType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_XdmfTopologyPtr_getTopologyType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; boost::shared_ptr< XdmfTopology > *arg1 = (boost::shared_ptr< XdmfTopology > *) 0 ; void *argp1 = 0 ; @@ -4574,13 +4743,13 @@ SWIGINTERN PyObject *_wrap_XdmfTopologyPtr_getXdmfTopologyType(PyObject *SWIGUNU PyObject * obj0 = 0 ; XdmfTopologyType *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:XdmfTopologyPtr_getXdmfTopologyType",&obj0)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"O:XdmfTopologyPtr_getTopologyType",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfTopology_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfTopologyPtr_getXdmfTopologyType" "', argument " "1"" of type '" "boost::shared_ptr< XdmfTopology > const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfTopologyPtr_getTopologyType" "', argument " "1"" of type '" "boost::shared_ptr< XdmfTopology > const *""'"); } arg1 = reinterpret_cast< boost::shared_ptr< XdmfTopology > * >(argp1); - result = (XdmfTopologyType *) &(*arg1)->getXdmfTopologyType(); + result = (XdmfTopologyType *) &(*arg1)->getTopologyType(); resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XdmfTopologyType, 0 | 0 ); return resultobj; fail: @@ -4643,6 +4812,28 @@ fail: } +SWIGINTERN PyObject *_wrap_XdmfTopologyPtr_getNodesPerElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfTopology > *arg1 = (boost::shared_ptr< XdmfTopology > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + int result; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfTopologyPtr_getNodesPerElement",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfTopology_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfTopologyPtr_getNodesPerElement" "', argument " "1"" of type '" "boost::shared_ptr< XdmfTopology > const *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfTopology > * >(argp1); + result = (int)(*arg1)->getNodesPerElement(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + SWIGINTERN PyObject *_wrap_XdmfTopologyPtr_printSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; boost::shared_ptr< XdmfTopology > *arg1 = (boost::shared_ptr< XdmfTopology > *) 0 ; @@ -4672,19 +4863,113 @@ SWIGINTERN PyObject *XdmfTopologyPtr_swigregister(PyObject *SWIGUNUSEDPARM(self) return SWIG_Py_Void(); } -SWIGINTERN PyObject *_wrap_XdmfObject_New(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_XdmfVisitorPtr___deref__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfVisitor > *arg1 = (boost::shared_ptr< XdmfVisitor > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + XdmfVisitor *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfVisitorPtr___deref__",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfVisitor_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfVisitorPtr___deref__" "', argument " "1"" of type '" "boost::shared_ptr< XdmfVisitor > const *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfVisitor > * >(argp1); + result = (XdmfVisitor *)((boost::shared_ptr< XdmfVisitor > const *)arg1)->operator ->(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XdmfVisitor, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_XdmfVisitorPtr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfVisitor > *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)":new_XdmfVisitorPtr")) SWIG_fail; + result = (boost::shared_ptr< XdmfVisitor > *)new boost::shared_ptr< XdmfVisitor >(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_boost__shared_ptrT_XdmfVisitor_t, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_XdmfVisitorPtr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfVisitor > *arg1 = (boost::shared_ptr< XdmfVisitor > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:delete_XdmfVisitorPtr",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfVisitor_t, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_XdmfVisitorPtr" "', argument " "1"" of type '" "boost::shared_ptr< XdmfVisitor > *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfVisitor > * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfVisitorPtr_New(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - boost::shared_ptr< XdmfObject > result; + boost::shared_ptr< XdmfVisitor > *arg1 = (boost::shared_ptr< XdmfVisitor > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + boost::shared_ptr< XdmfVisitor > result; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfVisitorPtr_New",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfVisitor_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfVisitorPtr_New" "', argument " "1"" of type '" "boost::shared_ptr< XdmfVisitor > *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfVisitor > * >(argp1); + result = (*arg1)->New(); + resultobj = SWIG_NewPointerObj((new boost::shared_ptr< XdmfVisitor >(static_cast< const boost::shared_ptr< XdmfVisitor >& >(result))), SWIGTYPE_p_boost__shared_ptrT_XdmfVisitor_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfVisitorPtr_printSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfVisitor > *arg1 = (boost::shared_ptr< XdmfVisitor > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::string result; - if (!PyArg_ParseTuple(args,(char *)":XdmfObject_New")) SWIG_fail; - result = XdmfObject::New(); - resultobj = SWIG_NewPointerObj((new boost::shared_ptr< XdmfObject >(static_cast< const boost::shared_ptr< XdmfObject >& >(result))), SWIGTYPE_p_boost__shared_ptrT_XdmfObject_t, SWIG_POINTER_OWN | 0 ); + if (!PyArg_ParseTuple(args,(char *)"O:XdmfVisitorPtr_printSelf",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_XdmfVisitor_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfVisitorPtr_printSelf" "', argument " "1"" of type '" "boost::shared_ptr< XdmfVisitor > const *""'"); + } + arg1 = reinterpret_cast< boost::shared_ptr< XdmfVisitor > * >(argp1); + result = (*arg1)->printSelf(); + resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: return NULL; } +SWIGINTERN PyObject *XdmfVisitorPtr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_boost__shared_ptrT_XdmfVisitor_t, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + SWIGINTERN PyObject *_wrap_XdmfObject_printSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; XdmfObject *arg1 = (XdmfObject *) 0 ; @@ -4714,34 +4999,41 @@ SWIGINTERN PyObject *XdmfObject_swigregister(PyObject *SWIGUNUSEDPARM(self), PyO return SWIG_Py_Void(); } -SWIGINTERN PyObject *_wrap_XdmfGeometry_New(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *XdmfItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_XdmfItem, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *_wrap_XdmfVisitor_New(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - boost::shared_ptr< XdmfGeometry > result; + boost::shared_ptr< XdmfVisitor > result; - if (!PyArg_ParseTuple(args,(char *)":XdmfGeometry_New")) SWIG_fail; - result = XdmfGeometry::New(); - resultobj = SWIG_NewPointerObj((new boost::shared_ptr< XdmfGeometry >(static_cast< const boost::shared_ptr< XdmfGeometry >& >(result))), SWIGTYPE_p_boost__shared_ptrT_XdmfGeometry_t, SWIG_POINTER_OWN | 0 ); + if (!PyArg_ParseTuple(args,(char *)":XdmfVisitor_New")) SWIG_fail; + result = XdmfVisitor::New(); + resultobj = SWIG_NewPointerObj((new boost::shared_ptr< XdmfVisitor >(static_cast< const boost::shared_ptr< XdmfVisitor >& >(result))), SWIGTYPE_p_boost__shared_ptrT_XdmfVisitor_t, SWIG_POINTER_OWN | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_XdmfGeometry_printSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_XdmfVisitor_printSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - XdmfGeometry *arg1 = (XdmfGeometry *) 0 ; + XdmfVisitor *arg1 = (XdmfVisitor *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject * obj0 = 0 ; std::string result; - if (!PyArg_ParseTuple(args,(char *)"O:XdmfGeometry_printSelf",&obj0)) SWIG_fail; - res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfGeometry, 0 | 0 ); + if (!PyArg_ParseTuple(args,(char *)"O:XdmfVisitor_printSelf",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfVisitor, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfGeometry_printSelf" "', argument " "1"" of type '" "XdmfGeometry const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfVisitor_printSelf" "', argument " "1"" of type '" "XdmfVisitor const *""'"); } - arg1 = reinterpret_cast< XdmfGeometry * >(argp1); - result = ((XdmfGeometry const *)arg1)->printSelf(); + arg1 = reinterpret_cast< XdmfVisitor * >(argp1); + result = ((XdmfVisitor const *)arg1)->printSelf(); resultobj = SWIG_From_std_string(static_cast< std::string >(result)); return resultobj; fail: @@ -4749,16 +5041,423 @@ fail: } -SWIGINTERN PyObject *XdmfGeometry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *XdmfVisitor_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_XdmfGeometry, SWIG_NewClientData(obj)); + SWIG_TypeNewClientData(SWIGTYPE_p_XdmfVisitor, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } -SWIGINTERN PyObject *_wrap_XdmfGrid_New(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_XdmfGeometryType_dimensions_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - boost::shared_ptr< XdmfGrid > result; + XdmfGeometryType *arg1 = (XdmfGeometryType *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + int result; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfGeometryType_dimensions_get",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfGeometryType, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfGeometryType_dimensions_get" "', argument " "1"" of type '" "XdmfGeometryType *""'"); + } + arg1 = reinterpret_cast< XdmfGeometryType * >(argp1); + result = (int)(int) ((arg1)->dimensions); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfGeometryType_name_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfGeometryType *arg1 = (XdmfGeometryType *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::string *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfGeometryType_name_get",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfGeometryType, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfGeometryType_name_get" "', argument " "1"" of type '" "XdmfGeometryType *""'"); + } + arg1 = reinterpret_cast< XdmfGeometryType * >(argp1); + result = (std::string *) & ((arg1)->name); + resultobj = SWIG_From_std_string(static_cast< std::string >(*result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN int Swig_var_XdmfGeometryType_NoGeometry_set(PyObject *) { + SWIG_Error(SWIG_AttributeError,"Variable XdmfGeometryType_NoGeometry is read-only."); + return 1; +} + + +SWIGINTERN PyObject *Swig_var_XdmfGeometryType_NoGeometry_get(void) { + PyObject *pyobj = 0; + + pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&XdmfGeometryType::NoGeometry), SWIGTYPE_p_XdmfGeometryType, 0 ); + return pyobj; +} + + +SWIGINTERN int Swig_var_XdmfGeometryType_XYZ_set(PyObject *) { + SWIG_Error(SWIG_AttributeError,"Variable XdmfGeometryType_XYZ is read-only."); + return 1; +} + + +SWIGINTERN PyObject *Swig_var_XdmfGeometryType_XYZ_get(void) { + PyObject *pyobj = 0; + + pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&XdmfGeometryType::XYZ), SWIGTYPE_p_XdmfGeometryType, 0 ); + return pyobj; +} + + +SWIGINTERN int Swig_var_XdmfGeometryType_XY_set(PyObject *) { + SWIG_Error(SWIG_AttributeError,"Variable XdmfGeometryType_XY is read-only."); + return 1; +} + + +SWIGINTERN PyObject *Swig_var_XdmfGeometryType_XY_get(void) { + PyObject *pyobj = 0; + + pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&XdmfGeometryType::XY), SWIGTYPE_p_XdmfGeometryType, 0 ); + return pyobj; +} + + +SWIGINTERN int Swig_var_XdmfGeometryType_X_Y_Z_set(PyObject *) { + SWIG_Error(SWIG_AttributeError,"Variable XdmfGeometryType_X_Y_Z is read-only."); + return 1; +} + + +SWIGINTERN PyObject *Swig_var_XdmfGeometryType_X_Y_Z_get(void) { + PyObject *pyobj = 0; + + pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&XdmfGeometryType::X_Y_Z), SWIGTYPE_p_XdmfGeometryType, 0 ); + return pyobj; +} + + +SWIGINTERN int Swig_var_XdmfGeometryType_X_Y_set(PyObject *) { + SWIG_Error(SWIG_AttributeError,"Variable XdmfGeometryType_X_Y is read-only."); + return 1; +} + + +SWIGINTERN PyObject *Swig_var_XdmfGeometryType_X_Y_get(void) { + PyObject *pyobj = 0; + + pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&XdmfGeometryType::X_Y), SWIGTYPE_p_XdmfGeometryType, 0 ); + return pyobj; +} + + +SWIGINTERN int Swig_var_XdmfGeometryType_VXVYVZ_set(PyObject *) { + SWIG_Error(SWIG_AttributeError,"Variable XdmfGeometryType_VXVYVZ is read-only."); + return 1; +} + + +SWIGINTERN PyObject *Swig_var_XdmfGeometryType_VXVYVZ_get(void) { + PyObject *pyobj = 0; + + pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&XdmfGeometryType::VXVYVZ), SWIGTYPE_p_XdmfGeometryType, 0 ); + return pyobj; +} + + +SWIGINTERN int Swig_var_XdmfGeometryType_Origin_DXDYDZ_set(PyObject *) { + SWIG_Error(SWIG_AttributeError,"Variable XdmfGeometryType_Origin_DXDYDZ is read-only."); + return 1; +} + + +SWIGINTERN PyObject *Swig_var_XdmfGeometryType_Origin_DXDYDZ_get(void) { + PyObject *pyobj = 0; + + pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&XdmfGeometryType::Origin_DXDYDZ), SWIGTYPE_p_XdmfGeometryType, 0 ); + return pyobj; +} + + +SWIGINTERN int Swig_var_XdmfGeometryType_VXVY_set(PyObject *) { + SWIG_Error(SWIG_AttributeError,"Variable XdmfGeometryType_VXVY is read-only."); + return 1; +} + + +SWIGINTERN PyObject *Swig_var_XdmfGeometryType_VXVY_get(void) { + PyObject *pyobj = 0; + + pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&XdmfGeometryType::VXVY), SWIGTYPE_p_XdmfGeometryType, 0 ); + return pyobj; +} + + +SWIGINTERN int Swig_var_XdmfGeometryType_Origin_DXDY_set(PyObject *) { + SWIG_Error(SWIG_AttributeError,"Variable XdmfGeometryType_Origin_DXDY is read-only."); + return 1; +} + + +SWIGINTERN PyObject *Swig_var_XdmfGeometryType_Origin_DXDY_get(void) { + PyObject *pyobj = 0; + + pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&XdmfGeometryType::Origin_DXDY), SWIGTYPE_p_XdmfGeometryType, 0 ); + return pyobj; +} + + +SWIGINTERN PyObject *_wrap_XdmfGeometryType___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfGeometryType *arg1 = (XdmfGeometryType *) 0 ; + XdmfGeometryType *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + bool result; + + if (!PyArg_ParseTuple(args,(char *)"OO:XdmfGeometryType___eq__",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfGeometryType, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfGeometryType___eq__" "', argument " "1"" of type '" "XdmfGeometryType const *""'"); + } + arg1 = reinterpret_cast< XdmfGeometryType * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_XdmfGeometryType, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XdmfGeometryType___eq__" "', argument " "2"" of type '" "XdmfGeometryType const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XdmfGeometryType___eq__" "', argument " "2"" of type '" "XdmfGeometryType const &""'"); + } + arg2 = reinterpret_cast< XdmfGeometryType * >(argp2); + result = (bool)((XdmfGeometryType const *)arg1)->operator ==((XdmfGeometryType const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfGeometryType___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfGeometryType *arg1 = (XdmfGeometryType *) 0 ; + XdmfGeometryType *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + bool result; + + if (!PyArg_ParseTuple(args,(char *)"OO:XdmfGeometryType___ne__",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfGeometryType, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfGeometryType___ne__" "', argument " "1"" of type '" "XdmfGeometryType const *""'"); + } + arg1 = reinterpret_cast< XdmfGeometryType * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_XdmfGeometryType, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XdmfGeometryType___ne__" "', argument " "2"" of type '" "XdmfGeometryType const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XdmfGeometryType___ne__" "', argument " "2"" of type '" "XdmfGeometryType const &""'"); + } + arg2 = reinterpret_cast< XdmfGeometryType * >(argp2); + result = (bool)((XdmfGeometryType const *)arg1)->operator !=((XdmfGeometryType const &)*arg2); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_XdmfGeometryType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfGeometryType *arg1 = (XdmfGeometryType *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:delete_XdmfGeometryType",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfGeometryType, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_XdmfGeometryType" "', argument " "1"" of type '" "XdmfGeometryType *""'"); + } + arg1 = reinterpret_cast< XdmfGeometryType * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *XdmfGeometryType_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_XdmfGeometryType, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *_wrap_XdmfGeometry_New(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfGeometry > result; + + if (!PyArg_ParseTuple(args,(char *)":XdmfGeometry_New")) SWIG_fail; + result = XdmfGeometry::New(); + resultobj = SWIG_NewPointerObj((new boost::shared_ptr< XdmfGeometry >(static_cast< const boost::shared_ptr< XdmfGeometry >& >(result))), SWIGTYPE_p_boost__shared_ptrT_XdmfGeometry_t, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfGeometry_getGeometryType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfGeometry *arg1 = (XdmfGeometry *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + XdmfGeometryType *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfGeometry_getGeometryType",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfGeometry, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfGeometry_getGeometryType" "', argument " "1"" of type '" "XdmfGeometry const *""'"); + } + arg1 = reinterpret_cast< XdmfGeometry * >(argp1); + result = (XdmfGeometryType *) &((XdmfGeometry const *)arg1)->getGeometryType(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XdmfGeometryType, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfGeometry_setGeometryType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfGeometry *arg1 = (XdmfGeometry *) 0 ; + XdmfGeometryType *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:XdmfGeometry_setGeometryType",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfGeometry, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfGeometry_setGeometryType" "', argument " "1"" of type '" "XdmfGeometry *""'"); + } + arg1 = reinterpret_cast< XdmfGeometry * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_XdmfGeometryType, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XdmfGeometry_setGeometryType" "', argument " "2"" of type '" "XdmfGeometryType const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "XdmfGeometry_setGeometryType" "', argument " "2"" of type '" "XdmfGeometryType const &""'"); + } + arg2 = reinterpret_cast< XdmfGeometryType * >(argp2); + (arg1)->setGeometryType((XdmfGeometryType const &)*arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfGeometry_getGeometryTypeAsString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfGeometry *arg1 = (XdmfGeometry *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::string result; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfGeometry_getGeometryTypeAsString",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfGeometry, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfGeometry_getGeometryTypeAsString" "', argument " "1"" of type '" "XdmfGeometry const *""'"); + } + arg1 = reinterpret_cast< XdmfGeometry * >(argp1); + result = ((XdmfGeometry const *)arg1)->getGeometryTypeAsString(); + resultobj = SWIG_From_std_string(static_cast< std::string >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfGeometry_getDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfGeometry *arg1 = (XdmfGeometry *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + int result; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfGeometry_getDimensions",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfGeometry, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfGeometry_getDimensions" "', argument " "1"" of type '" "XdmfGeometry const *""'"); + } + arg1 = reinterpret_cast< XdmfGeometry * >(argp1); + result = (int)((XdmfGeometry const *)arg1)->getDimensions(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_XdmfGeometry_printSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfGeometry *arg1 = (XdmfGeometry *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + std::string result; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfGeometry_printSelf",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfGeometry, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfGeometry_printSelf" "', argument " "1"" of type '" "XdmfGeometry const *""'"); + } + arg1 = reinterpret_cast< XdmfGeometry * >(argp1); + result = ((XdmfGeometry const *)arg1)->printSelf(); + resultobj = SWIG_From_std_string(static_cast< std::string >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *XdmfGeometry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_XdmfGeometry, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *_wrap_XdmfGrid_New(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + boost::shared_ptr< XdmfGrid > result; if (!PyArg_ParseTuple(args,(char *)":XdmfGrid_New")) SWIG_fail; result = XdmfGrid::New(); @@ -4918,7 +5617,7 @@ SWIGINTERN PyObject *XdmfGrid_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObj return SWIG_Py_Void(); } -SWIGINTERN PyObject *_wrap_XdmfTopologyType_numberVertices_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_XdmfTopologyType_nodesPerElement_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; XdmfTopologyType *arg1 = (XdmfTopologyType *) 0 ; void *argp1 = 0 ; @@ -4926,13 +5625,13 @@ SWIGINTERN PyObject *_wrap_XdmfTopologyType_numberVertices_get(PyObject *SWIGUNU PyObject * obj0 = 0 ; int result; - if (!PyArg_ParseTuple(args,(char *)"O:XdmfTopologyType_numberVertices_get",&obj0)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"O:XdmfTopologyType_nodesPerElement_get",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfTopologyType, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfTopologyType_numberVertices_get" "', argument " "1"" of type '" "XdmfTopologyType *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfTopologyType_nodesPerElement_get" "', argument " "1"" of type '" "XdmfTopologyType *""'"); } arg1 = reinterpret_cast< XdmfTopologyType * >(argp1); - result = (int)(int) ((arg1)->numberVertices); + result = (int)(int) ((arg1)->nodesPerElement); resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: @@ -4962,6 +5661,28 @@ fail: } +SWIGINTERN PyObject *_wrap_XdmfTopologyType_cellType_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfTopologyType *arg1 = (XdmfTopologyType *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + XdmfTopologyType::CellType result; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfTopologyType_cellType_get",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfTopologyType, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfTopologyType_cellType_get" "', argument " "1"" of type '" "XdmfTopologyType *""'"); + } + arg1 = reinterpret_cast< XdmfTopologyType * >(argp1); + result = (XdmfTopologyType::CellType)(XdmfTopologyType::CellType) ((arg1)->cellType); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + SWIGINTERN int Swig_var_XdmfTopologyType_NoTopology_set(PyObject *) { SWIG_Error(SWIG_AttributeError,"Variable XdmfTopologyType_NoTopology is read-only."); return 1; @@ -5407,7 +6128,7 @@ fail: } -SWIGINTERN PyObject *_wrap_XdmfTopology_getXdmfTopologyType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_XdmfTopology_getTopologyType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; XdmfTopology *arg1 = (XdmfTopology *) 0 ; void *argp1 = 0 ; @@ -5415,13 +6136,13 @@ SWIGINTERN PyObject *_wrap_XdmfTopology_getXdmfTopologyType(PyObject *SWIGUNUSED PyObject * obj0 = 0 ; XdmfTopologyType *result = 0 ; - if (!PyArg_ParseTuple(args,(char *)"O:XdmfTopology_getXdmfTopologyType",&obj0)) SWIG_fail; + if (!PyArg_ParseTuple(args,(char *)"O:XdmfTopology_getTopologyType",&obj0)) SWIG_fail; res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfTopology, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfTopology_getXdmfTopologyType" "', argument " "1"" of type '" "XdmfTopology const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfTopology_getTopologyType" "', argument " "1"" of type '" "XdmfTopology const *""'"); } arg1 = reinterpret_cast< XdmfTopology * >(argp1); - result = (XdmfTopologyType *) &((XdmfTopology const *)arg1)->getXdmfTopologyType(); + result = (XdmfTopologyType *) &((XdmfTopology const *)arg1)->getTopologyType(); resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_XdmfTopologyType, 0 | 0 ); return resultobj; fail: @@ -5484,6 +6205,28 @@ fail: } +SWIGINTERN PyObject *_wrap_XdmfTopology_getNodesPerElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + XdmfTopology *arg1 = (XdmfTopology *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + int result; + + if (!PyArg_ParseTuple(args,(char *)"O:XdmfTopology_getNodesPerElement",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_XdmfTopology, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XdmfTopology_getNodesPerElement" "', argument " "1"" of type '" "XdmfTopology const *""'"); + } + arg1 = reinterpret_cast< XdmfTopology * >(argp1); + result = (int)((XdmfTopology const *)arg1)->getNodesPerElement(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + SWIGINTERN PyObject *_wrap_XdmfTopology_printSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; XdmfTopology *arg1 = (XdmfTopology *) 0 ; @@ -5537,6 +6280,10 @@ static PyMethodDef SwigMethods[] = { { (char *)"new_XdmfGeometryPtr", _wrap_new_XdmfGeometryPtr, METH_VARARGS, NULL}, { (char *)"delete_XdmfGeometryPtr", _wrap_delete_XdmfGeometryPtr, METH_VARARGS, NULL}, { (char *)"XdmfGeometryPtr_New", _wrap_XdmfGeometryPtr_New, METH_VARARGS, NULL}, + { (char *)"XdmfGeometryPtr_getGeometryType", _wrap_XdmfGeometryPtr_getGeometryType, METH_VARARGS, NULL}, + { (char *)"XdmfGeometryPtr_setGeometryType", _wrap_XdmfGeometryPtr_setGeometryType, METH_VARARGS, NULL}, + { (char *)"XdmfGeometryPtr_getGeometryTypeAsString", _wrap_XdmfGeometryPtr_getGeometryTypeAsString, METH_VARARGS, NULL}, + { (char *)"XdmfGeometryPtr_getDimensions", _wrap_XdmfGeometryPtr_getDimensions, METH_VARARGS, NULL}, { (char *)"XdmfGeometryPtr_printSelf", _wrap_XdmfGeometryPtr_printSelf, METH_VARARGS, NULL}, { (char *)"XdmfGeometryPtr_swigregister", XdmfGeometryPtr_swigregister, METH_VARARGS, NULL}, { (char *)"XdmfGridPtr___deref__", _wrap_XdmfGridPtr___deref__, METH_VARARGS, NULL}, @@ -5549,25 +6296,49 @@ static PyMethodDef SwigMethods[] = { { (char *)"XdmfGridPtr_setTopology", _wrap_XdmfGridPtr_setTopology, METH_VARARGS, NULL}, { (char *)"XdmfGridPtr_printSelf", _wrap_XdmfGridPtr_printSelf, METH_VARARGS, NULL}, { (char *)"XdmfGridPtr_swigregister", XdmfGridPtr_swigregister, METH_VARARGS, NULL}, + { (char *)"XdmfItemPtr___deref__", _wrap_XdmfItemPtr___deref__, METH_VARARGS, NULL}, + { (char *)"new_XdmfItemPtr", _wrap_new_XdmfItemPtr, METH_VARARGS, NULL}, + { (char *)"delete_XdmfItemPtr", _wrap_delete_XdmfItemPtr, METH_VARARGS, NULL}, + { (char *)"XdmfItemPtr_printSelf", _wrap_XdmfItemPtr_printSelf, METH_VARARGS, NULL}, + { (char *)"XdmfItemPtr_swigregister", XdmfItemPtr_swigregister, METH_VARARGS, NULL}, { (char *)"XdmfObjPtr___deref__", _wrap_XdmfObjPtr___deref__, METH_VARARGS, NULL}, { (char *)"new_XdmfObjPtr", _wrap_new_XdmfObjPtr, METH_VARARGS, NULL}, { (char *)"delete_XdmfObjPtr", _wrap_delete_XdmfObjPtr, METH_VARARGS, NULL}, - { (char *)"XdmfObjPtr_New", _wrap_XdmfObjPtr_New, METH_VARARGS, NULL}, { (char *)"XdmfObjPtr_printSelf", _wrap_XdmfObjPtr_printSelf, METH_VARARGS, NULL}, { (char *)"XdmfObjPtr_swigregister", XdmfObjPtr_swigregister, METH_VARARGS, NULL}, { (char *)"XdmfTopologyPtr___deref__", _wrap_XdmfTopologyPtr___deref__, METH_VARARGS, NULL}, { (char *)"new_XdmfTopologyPtr", _wrap_new_XdmfTopologyPtr, METH_VARARGS, NULL}, { (char *)"delete_XdmfTopologyPtr", _wrap_delete_XdmfTopologyPtr, METH_VARARGS, NULL}, { (char *)"XdmfTopologyPtr_New", _wrap_XdmfTopologyPtr_New, METH_VARARGS, NULL}, - { (char *)"XdmfTopologyPtr_getXdmfTopologyType", _wrap_XdmfTopologyPtr_getXdmfTopologyType, METH_VARARGS, NULL}, + { (char *)"XdmfTopologyPtr_getTopologyType", _wrap_XdmfTopologyPtr_getTopologyType, METH_VARARGS, NULL}, { (char *)"XdmfTopologyPtr_setTopologyType", _wrap_XdmfTopologyPtr_setTopologyType, METH_VARARGS, NULL}, { (char *)"XdmfTopologyPtr_getTopologyTypeAsString", _wrap_XdmfTopologyPtr_getTopologyTypeAsString, METH_VARARGS, NULL}, + { (char *)"XdmfTopologyPtr_getNodesPerElement", _wrap_XdmfTopologyPtr_getNodesPerElement, METH_VARARGS, NULL}, { (char *)"XdmfTopologyPtr_printSelf", _wrap_XdmfTopologyPtr_printSelf, METH_VARARGS, NULL}, { (char *)"XdmfTopologyPtr_swigregister", XdmfTopologyPtr_swigregister, METH_VARARGS, NULL}, - { (char *)"XdmfObject_New", _wrap_XdmfObject_New, METH_VARARGS, NULL}, + { (char *)"XdmfVisitorPtr___deref__", _wrap_XdmfVisitorPtr___deref__, METH_VARARGS, NULL}, + { (char *)"new_XdmfVisitorPtr", _wrap_new_XdmfVisitorPtr, METH_VARARGS, NULL}, + { (char *)"delete_XdmfVisitorPtr", _wrap_delete_XdmfVisitorPtr, METH_VARARGS, NULL}, + { (char *)"XdmfVisitorPtr_New", _wrap_XdmfVisitorPtr_New, METH_VARARGS, NULL}, + { (char *)"XdmfVisitorPtr_printSelf", _wrap_XdmfVisitorPtr_printSelf, METH_VARARGS, NULL}, + { (char *)"XdmfVisitorPtr_swigregister", XdmfVisitorPtr_swigregister, METH_VARARGS, NULL}, { (char *)"XdmfObject_printSelf", _wrap_XdmfObject_printSelf, METH_VARARGS, NULL}, { (char *)"XdmfObject_swigregister", XdmfObject_swigregister, METH_VARARGS, NULL}, + { (char *)"XdmfItem_swigregister", XdmfItem_swigregister, METH_VARARGS, NULL}, + { (char *)"XdmfVisitor_New", _wrap_XdmfVisitor_New, METH_VARARGS, NULL}, + { (char *)"XdmfVisitor_printSelf", _wrap_XdmfVisitor_printSelf, METH_VARARGS, NULL}, + { (char *)"XdmfVisitor_swigregister", XdmfVisitor_swigregister, METH_VARARGS, NULL}, + { (char *)"XdmfGeometryType_dimensions_get", _wrap_XdmfGeometryType_dimensions_get, METH_VARARGS, NULL}, + { (char *)"XdmfGeometryType_name_get", _wrap_XdmfGeometryType_name_get, METH_VARARGS, NULL}, + { (char *)"XdmfGeometryType___eq__", _wrap_XdmfGeometryType___eq__, METH_VARARGS, NULL}, + { (char *)"XdmfGeometryType___ne__", _wrap_XdmfGeometryType___ne__, METH_VARARGS, NULL}, + { (char *)"delete_XdmfGeometryType", _wrap_delete_XdmfGeometryType, METH_VARARGS, NULL}, + { (char *)"XdmfGeometryType_swigregister", XdmfGeometryType_swigregister, METH_VARARGS, NULL}, { (char *)"XdmfGeometry_New", _wrap_XdmfGeometry_New, METH_VARARGS, NULL}, + { (char *)"XdmfGeometry_getGeometryType", _wrap_XdmfGeometry_getGeometryType, METH_VARARGS, NULL}, + { (char *)"XdmfGeometry_setGeometryType", _wrap_XdmfGeometry_setGeometryType, METH_VARARGS, NULL}, + { (char *)"XdmfGeometry_getGeometryTypeAsString", _wrap_XdmfGeometry_getGeometryTypeAsString, METH_VARARGS, NULL}, + { (char *)"XdmfGeometry_getDimensions", _wrap_XdmfGeometry_getDimensions, METH_VARARGS, NULL}, { (char *)"XdmfGeometry_printSelf", _wrap_XdmfGeometry_printSelf, METH_VARARGS, NULL}, { (char *)"XdmfGeometry_swigregister", XdmfGeometry_swigregister, METH_VARARGS, NULL}, { (char *)"XdmfGrid_New", _wrap_XdmfGrid_New, METH_VARARGS, NULL}, @@ -5577,16 +6348,18 @@ static PyMethodDef SwigMethods[] = { { (char *)"XdmfGrid_setTopology", _wrap_XdmfGrid_setTopology, METH_VARARGS, NULL}, { (char *)"XdmfGrid_printSelf", _wrap_XdmfGrid_printSelf, METH_VARARGS, NULL}, { (char *)"XdmfGrid_swigregister", XdmfGrid_swigregister, METH_VARARGS, NULL}, - { (char *)"XdmfTopologyType_numberVertices_get", _wrap_XdmfTopologyType_numberVertices_get, METH_VARARGS, NULL}, + { (char *)"XdmfTopologyType_nodesPerElement_get", _wrap_XdmfTopologyType_nodesPerElement_get, METH_VARARGS, NULL}, { (char *)"XdmfTopologyType_name_get", _wrap_XdmfTopologyType_name_get, METH_VARARGS, NULL}, + { (char *)"XdmfTopologyType_cellType_get", _wrap_XdmfTopologyType_cellType_get, METH_VARARGS, NULL}, { (char *)"XdmfTopologyType___eq__", _wrap_XdmfTopologyType___eq__, METH_VARARGS, NULL}, { (char *)"XdmfTopologyType___ne__", _wrap_XdmfTopologyType___ne__, METH_VARARGS, NULL}, { (char *)"delete_XdmfTopologyType", _wrap_delete_XdmfTopologyType, METH_VARARGS, NULL}, { (char *)"XdmfTopologyType_swigregister", XdmfTopologyType_swigregister, METH_VARARGS, NULL}, { (char *)"XdmfTopology_New", _wrap_XdmfTopology_New, METH_VARARGS, NULL}, - { (char *)"XdmfTopology_getXdmfTopologyType", _wrap_XdmfTopology_getXdmfTopologyType, METH_VARARGS, NULL}, + { (char *)"XdmfTopology_getTopologyType", _wrap_XdmfTopology_getTopologyType, METH_VARARGS, NULL}, { (char *)"XdmfTopology_setTopologyType", _wrap_XdmfTopology_setTopologyType, METH_VARARGS, NULL}, { (char *)"XdmfTopology_getTopologyTypeAsString", _wrap_XdmfTopology_getTopologyTypeAsString, METH_VARARGS, NULL}, + { (char *)"XdmfTopology_getNodesPerElement", _wrap_XdmfTopology_getNodesPerElement, METH_VARARGS, NULL}, { (char *)"XdmfTopology_printSelf", _wrap_XdmfTopology_printSelf, METH_VARARGS, NULL}, { (char *)"XdmfTopology_swigregister", XdmfTopology_swigregister, METH_VARARGS, NULL}, { NULL, NULL, 0, NULL } @@ -5595,66 +6368,101 @@ static PyMethodDef SwigMethods[] = { /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */ +static void *_p_XdmfItemTo_p_XdmfObject(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((XdmfObject *) ((XdmfItem *) x)); +} static void *_p_XdmfGridTo_p_XdmfObject(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((XdmfObject *) ((XdmfGrid *) x)); + return (void *)((XdmfObject *) (XdmfItem *) ((XdmfGrid *) x)); +} +static void *_p_XdmfVisitorTo_p_XdmfObject(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((XdmfObject *) ((XdmfVisitor *) x)); } static void *_p_XdmfTopologyTo_p_XdmfObject(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((XdmfObject *) ((XdmfTopology *) x)); + return (void *)((XdmfObject *) (XdmfItem *) ((XdmfTopology *) x)); } static void *_p_XdmfGeometryTo_p_XdmfObject(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((XdmfObject *) ((XdmfGeometry *) x)); + return (void *)((XdmfObject *) (XdmfItem *) ((XdmfGeometry *) x)); +} +static void *_p_XdmfGridTo_p_XdmfItem(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((XdmfItem *) ((XdmfGrid *) x)); +} +static void *_p_XdmfTopologyTo_p_XdmfItem(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((XdmfItem *) ((XdmfTopology *) x)); +} +static void *_p_XdmfGeometryTo_p_XdmfItem(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((XdmfItem *) ((XdmfGeometry *) x)); } static swig_type_info _swigt__p_XdmfGeometry = {"_p_XdmfGeometry", "XdmfGeometry *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_XdmfGeometryType = {"_p_XdmfGeometryType", "XdmfGeometryType *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_XdmfGrid = {"_p_XdmfGrid", "XdmfGrid *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_XdmfItem = {"_p_XdmfItem", "XdmfItem *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_XdmfObject = {"_p_XdmfObject", "XdmfObject *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_XdmfTopology = {"_p_XdmfTopology", "XdmfTopology *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_XdmfTopologyType = {"_p_XdmfTopologyType", "XdmfTopologyType *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_XdmfVisitor = {"_p_XdmfVisitor", "XdmfVisitor *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_boost__shared_ptrT_XdmfGeometry_t = {"_p_boost__shared_ptrT_XdmfGeometry_t", "boost::shared_ptr< XdmfGeometry > *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_boost__shared_ptrT_XdmfGrid_t = {"_p_boost__shared_ptrT_XdmfGrid_t", "boost::shared_ptr< XdmfGrid > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_boost__shared_ptrT_XdmfItem_t = {"_p_boost__shared_ptrT_XdmfItem_t", "boost::shared_ptr< XdmfItem > *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_boost__shared_ptrT_XdmfObject_t = {"_p_boost__shared_ptrT_XdmfObject_t", "boost::shared_ptr< XdmfObject > *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_boost__shared_ptrT_XdmfTopology_t = {"_p_boost__shared_ptrT_XdmfTopology_t", "boost::shared_ptr< XdmfTopology > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_boost__shared_ptrT_XdmfVisitor_t = {"_p_boost__shared_ptrT_XdmfVisitor_t", "boost::shared_ptr< XdmfVisitor > *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_std__invalid_argument = {"_p_std__invalid_argument", "std::invalid_argument *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_swig__SwigPyIterator = {"_p_swig__SwigPyIterator", "swig::SwigPyIterator *", 0, 0, (void*)0, 0}; static swig_type_info *swig_type_initial[] = { &_swigt__p_XdmfGeometry, + &_swigt__p_XdmfGeometryType, &_swigt__p_XdmfGrid, + &_swigt__p_XdmfItem, &_swigt__p_XdmfObject, &_swigt__p_XdmfTopology, &_swigt__p_XdmfTopologyType, + &_swigt__p_XdmfVisitor, &_swigt__p_boost__shared_ptrT_XdmfGeometry_t, &_swigt__p_boost__shared_ptrT_XdmfGrid_t, + &_swigt__p_boost__shared_ptrT_XdmfItem_t, &_swigt__p_boost__shared_ptrT_XdmfObject_t, &_swigt__p_boost__shared_ptrT_XdmfTopology_t, + &_swigt__p_boost__shared_ptrT_XdmfVisitor_t, &_swigt__p_char, &_swigt__p_std__invalid_argument, &_swigt__p_swig__SwigPyIterator, }; static swig_cast_info _swigc__p_XdmfGeometry[] = { {&_swigt__p_XdmfGeometry, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_XdmfGeometryType[] = { {&_swigt__p_XdmfGeometryType, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_XdmfGrid[] = { {&_swigt__p_XdmfGrid, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_XdmfObject[] = { {&_swigt__p_XdmfGrid, _p_XdmfGridTo_p_XdmfObject, 0, 0}, {&_swigt__p_XdmfTopology, _p_XdmfTopologyTo_p_XdmfObject, 0, 0}, {&_swigt__p_XdmfObject, 0, 0, 0}, {&_swigt__p_XdmfGeometry, _p_XdmfGeometryTo_p_XdmfObject, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_XdmfItem[] = { {&_swigt__p_XdmfItem, 0, 0, 0}, {&_swigt__p_XdmfGrid, _p_XdmfGridTo_p_XdmfItem, 0, 0}, {&_swigt__p_XdmfTopology, _p_XdmfTopologyTo_p_XdmfItem, 0, 0}, {&_swigt__p_XdmfGeometry, _p_XdmfGeometryTo_p_XdmfItem, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_XdmfObject[] = { {&_swigt__p_XdmfItem, _p_XdmfItemTo_p_XdmfObject, 0, 0}, {&_swigt__p_XdmfGrid, _p_XdmfGridTo_p_XdmfObject, 0, 0}, {&_swigt__p_XdmfTopology, _p_XdmfTopologyTo_p_XdmfObject, 0, 0}, {&_swigt__p_XdmfVisitor, _p_XdmfVisitorTo_p_XdmfObject, 0, 0}, {&_swigt__p_XdmfObject, 0, 0, 0}, {&_swigt__p_XdmfGeometry, _p_XdmfGeometryTo_p_XdmfObject, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_XdmfTopology[] = { {&_swigt__p_XdmfTopology, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_XdmfTopologyType[] = { {&_swigt__p_XdmfTopologyType, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_XdmfVisitor[] = { {&_swigt__p_XdmfVisitor, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_boost__shared_ptrT_XdmfGeometry_t[] = { {&_swigt__p_boost__shared_ptrT_XdmfGeometry_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_boost__shared_ptrT_XdmfGrid_t[] = { {&_swigt__p_boost__shared_ptrT_XdmfGrid_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_boost__shared_ptrT_XdmfItem_t[] = { {&_swigt__p_boost__shared_ptrT_XdmfItem_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_boost__shared_ptrT_XdmfObject_t[] = { {&_swigt__p_boost__shared_ptrT_XdmfObject_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_boost__shared_ptrT_XdmfTopology_t[] = { {&_swigt__p_boost__shared_ptrT_XdmfTopology_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_boost__shared_ptrT_XdmfVisitor_t[] = { {&_swigt__p_boost__shared_ptrT_XdmfVisitor_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_std__invalid_argument[] = { {&_swigt__p_std__invalid_argument, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_swig__SwigPyIterator[] = { {&_swigt__p_swig__SwigPyIterator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info *swig_cast_initial[] = { _swigc__p_XdmfGeometry, + _swigc__p_XdmfGeometryType, _swigc__p_XdmfGrid, + _swigc__p_XdmfItem, _swigc__p_XdmfObject, _swigc__p_XdmfTopology, _swigc__p_XdmfTopologyType, + _swigc__p_XdmfVisitor, _swigc__p_boost__shared_ptrT_XdmfGeometry_t, _swigc__p_boost__shared_ptrT_XdmfGrid_t, + _swigc__p_boost__shared_ptrT_XdmfItem_t, _swigc__p_boost__shared_ptrT_XdmfObject_t, _swigc__p_boost__shared_ptrT_XdmfTopology_t, + _swigc__p_boost__shared_ptrT_XdmfVisitor_t, _swigc__p_char, _swigc__p_std__invalid_argument, _swigc__p_swig__SwigPyIterator, @@ -6252,6 +7060,20 @@ SWIG_init(void) { PyDict_SetItemString(d,(char*)"cvar", SWIG_globals()); + SWIG_addvarlink(SWIG_globals(),(char*)"XdmfGeometryType_NoGeometry",Swig_var_XdmfGeometryType_NoGeometry_get, Swig_var_XdmfGeometryType_NoGeometry_set); + SWIG_addvarlink(SWIG_globals(),(char*)"XdmfGeometryType_XYZ",Swig_var_XdmfGeometryType_XYZ_get, Swig_var_XdmfGeometryType_XYZ_set); + SWIG_addvarlink(SWIG_globals(),(char*)"XdmfGeometryType_XY",Swig_var_XdmfGeometryType_XY_get, Swig_var_XdmfGeometryType_XY_set); + SWIG_addvarlink(SWIG_globals(),(char*)"XdmfGeometryType_X_Y_Z",Swig_var_XdmfGeometryType_X_Y_Z_get, Swig_var_XdmfGeometryType_X_Y_Z_set); + SWIG_addvarlink(SWIG_globals(),(char*)"XdmfGeometryType_X_Y",Swig_var_XdmfGeometryType_X_Y_get, Swig_var_XdmfGeometryType_X_Y_set); + SWIG_addvarlink(SWIG_globals(),(char*)"XdmfGeometryType_VXVYVZ",Swig_var_XdmfGeometryType_VXVYVZ_get, Swig_var_XdmfGeometryType_VXVYVZ_set); + SWIG_addvarlink(SWIG_globals(),(char*)"XdmfGeometryType_Origin_DXDYDZ",Swig_var_XdmfGeometryType_Origin_DXDYDZ_get, Swig_var_XdmfGeometryType_Origin_DXDYDZ_set); + SWIG_addvarlink(SWIG_globals(),(char*)"XdmfGeometryType_VXVY",Swig_var_XdmfGeometryType_VXVY_get, Swig_var_XdmfGeometryType_VXVY_set); + SWIG_addvarlink(SWIG_globals(),(char*)"XdmfGeometryType_Origin_DXDY",Swig_var_XdmfGeometryType_Origin_DXDY_get, Swig_var_XdmfGeometryType_Origin_DXDY_set); + SWIG_Python_SetConstant(d, "XdmfTopologyType_NoCellType",SWIG_From_int(static_cast< int >(XdmfTopologyType::NoCellType))); + SWIG_Python_SetConstant(d, "XdmfTopologyType_Linear",SWIG_From_int(static_cast< int >(XdmfTopologyType::Linear))); + SWIG_Python_SetConstant(d, "XdmfTopologyType_Quadratic",SWIG_From_int(static_cast< int >(XdmfTopologyType::Quadratic))); + SWIG_Python_SetConstant(d, "XdmfTopologyType_Arbitrary",SWIG_From_int(static_cast< int >(XdmfTopologyType::Arbitrary))); + SWIG_Python_SetConstant(d, "XdmfTopologyType_Structured",SWIG_From_int(static_cast< int >(XdmfTopologyType::Structured))); SWIG_addvarlink(SWIG_globals(),(char*)"XdmfTopologyType_NoTopology",Swig_var_XdmfTopologyType_NoTopology_get, Swig_var_XdmfTopologyType_NoTopology_set); SWIG_addvarlink(SWIG_globals(),(char*)"XdmfTopologyType_Polyvertex",Swig_var_XdmfTopologyType_Polyvertex_get, Swig_var_XdmfTopologyType_Polyvertex_set); SWIG_addvarlink(SWIG_globals(),(char*)"XdmfTopologyType_Polyline",Swig_var_XdmfTopologyType_Polyline_get, Swig_var_XdmfTopologyType_Polyline_set); diff --git a/XdmfTopology.cpp b/XdmfTopology.cpp index eac129aa64fb9aeac2841fd6a45a68661e3b1e12..725eab2a60c41dfe584a0920a6829f774bb8cbd2 100644 --- a/XdmfTopology.cpp +++ b/XdmfTopology.cpp @@ -7,33 +7,33 @@ #include "XdmfTopology.hpp" -const XdmfTopologyType XdmfTopologyType::NoTopology(0, "NoTopology"); -const XdmfTopologyType XdmfTopologyType::Polyvertex(1, "Polyvertex"); -const XdmfTopologyType XdmfTopologyType::Polyline(1, "Polyline"); -const XdmfTopologyType XdmfTopologyType::Polygon(1, "Polygon"); -const XdmfTopologyType XdmfTopologyType::Triangle(3, "Triangle"); -const XdmfTopologyType XdmfTopologyType::Quadrilateral(4, "Quadrilateral"); -const XdmfTopologyType XdmfTopologyType::Tetrahedron(4, "Tetrahedron"); -const XdmfTopologyType XdmfTopologyType::Pyramid(5, "Pyramid"); -const XdmfTopologyType XdmfTopologyType::Wedge(6, "Wedge"); -const XdmfTopologyType XdmfTopologyType::Hexahedron(8, "Hexahedron"); -const XdmfTopologyType XdmfTopologyType::Edge_3(3, "Edge_3"); -const XdmfTopologyType XdmfTopologyType::Triangle_6(6, "Triangle_6"); -const XdmfTopologyType XdmfTopologyType::Quadrilateral_8(8, "Quadrilateral_8"); -const XdmfTopologyType XdmfTopologyType::Tetrahedron_10(10, "Tetrahedron_10"); -const XdmfTopologyType XdmfTopologyType::Pyramid_13(13, "Pyramid_13"); -const XdmfTopologyType XdmfTopologyType::Wedge_15(15, "Wedge_15"); -const XdmfTopologyType XdmfTopologyType::Hexahedron_20(20, "Hexahedron_20"); -const XdmfTopologyType XdmfTopologyType::Mixed(0, "Mixed"); -const XdmfTopologyType XdmfTopologyType::TwoDSMesh(1, "2DSMesh"); -const XdmfTopologyType XdmfTopologyType::TwoDRectMesh(1, "2DRectMesh"); -const XdmfTopologyType XdmfTopologyType::TwoDCoRectMesh(1, "2DCoRectMesh"); -const XdmfTopologyType XdmfTopologyType::ThreeDSMesh(1, "3DSMesh"); -const XdmfTopologyType XdmfTopologyType::ThreeDRectMesh(1, "3DRectMesh"); -const XdmfTopologyType XdmfTopologyType::ThreeDCoRectMesh(1, "3DCoRectMesh"); - -XdmfTopology::XdmfTopology(): -mTopologyType(&XdmfTopologyType::Tetrahedron) +const XdmfTopologyType XdmfTopologyType::NoTopology(0, "NoTopology", NoCellType); +const XdmfTopologyType XdmfTopologyType::Polyvertex(1, "Polyvertex", Linear); +const XdmfTopologyType XdmfTopologyType::Polyline(1, "Polyline", Linear); +const XdmfTopologyType XdmfTopologyType::Polygon(1, "Polygon", Linear); +const XdmfTopologyType XdmfTopologyType::Triangle(3, "Triangle", Linear); +const XdmfTopologyType XdmfTopologyType::Quadrilateral(4, "Quadrilateral", Linear); +const XdmfTopologyType XdmfTopologyType::Tetrahedron(4, "Tetrahedron", Linear); +const XdmfTopologyType XdmfTopologyType::Pyramid(5, "Pyramid", Linear); +const XdmfTopologyType XdmfTopologyType::Wedge(6, "Wedge", Linear); +const XdmfTopologyType XdmfTopologyType::Hexahedron(8, "Hexahedron", Linear); +const XdmfTopologyType XdmfTopologyType::Edge_3(3, "Edge_3", Quadratic); +const XdmfTopologyType XdmfTopologyType::Triangle_6(6, "Triangle_6", Quadratic); +const XdmfTopologyType XdmfTopologyType::Quadrilateral_8(8, "Quadrilateral_8", Quadratic); +const XdmfTopologyType XdmfTopologyType::Tetrahedron_10(10, "Tetrahedron_10", Quadratic); +const XdmfTopologyType XdmfTopologyType::Pyramid_13(13, "Pyramid_13", Quadratic); +const XdmfTopologyType XdmfTopologyType::Wedge_15(15, "Wedge_15", Quadratic); +const XdmfTopologyType XdmfTopologyType::Hexahedron_20(20, "Hexahedron_20", Quadratic); +const XdmfTopologyType XdmfTopologyType::Mixed(0, "Mixed", Arbitrary); +const XdmfTopologyType XdmfTopologyType::TwoDSMesh(1, "2DSMesh", Structured); +const XdmfTopologyType XdmfTopologyType::TwoDRectMesh(1, "2DRectMesh", Structured); +const XdmfTopologyType XdmfTopologyType::TwoDCoRectMesh(1, "2DCoRectMesh", Structured); +const XdmfTopologyType XdmfTopologyType::ThreeDSMesh(1, "3DSMesh", Structured); +const XdmfTopologyType XdmfTopologyType::ThreeDRectMesh(1, "3DRectMesh", Structured); +const XdmfTopologyType XdmfTopologyType::ThreeDCoRectMesh(1, "3DCoRectMesh", Structured); + +XdmfTopology::XdmfTopology() : +mTopologyType(&XdmfTopologyType::NoTopology) { std::cout << "Created Topology " << this << std::endl; } @@ -43,6 +43,22 @@ XdmfTopology::~XdmfTopology() std::cout << "Deleted Topology " << this << std::endl; } +const XdmfTopologyType & XdmfTopology::getTopologyType() const +{ + return *mTopologyType; +} + +void XdmfTopology::setTopologyType(const XdmfTopologyType& topType) +{ + mTopologyType = &topType; + return; +} + +const int XdmfTopology::getNodesPerElement() const +{ + return mTopologyType->nodesPerElement; +} + const std::string XdmfTopology::getTopologyTypeAsString() const { return mTopologyType->name; diff --git a/XdmfTopology.hpp b/XdmfTopology.hpp index 19ddc6626f637575478dfe53e2a427099f9c6293..329479fff2e4b5a61600f03562dd2d6ebb669398 100644 --- a/XdmfTopology.hpp +++ b/XdmfTopology.hpp @@ -8,16 +8,22 @@ #ifndef XDMFTOPOLOGY_HPP_ #define XDMFTOPOLOGY_HPP_ -#include "XdmfObject.hpp" +#include "XdmfItem.hpp" class XdmfTopologyType { public: - const int numberVertices; + enum CellType { + NoCellType, Linear, Quadratic, Arbitrary, Structured + }; + + const int nodesPerElement; const std::string name; + const CellType cellType; // Supported Xdmf Topology Type + // TODO: How do we deal with Polygon datatypes and others that can have variable nodesPerElement? static const XdmfTopologyType NoTopology; static const XdmfTopologyType Polyvertex; static const XdmfTopologyType Polyline; @@ -43,11 +49,25 @@ public: static const XdmfTopologyType ThreeDRectMesh; static const XdmfTopologyType ThreeDCoRectMesh; + /* + * Compare two XdmfTopology types for equality. Each topology type has a single static instance meaning that + * equality can be determined by determining if they have the same pointer value. + * + * @param an XdmfTopologyType to compare equality to. + * @return true iff the XdmfTopologyTypes are equal. + */ bool operator==(const XdmfTopologyType& top) const { return (this == &top) ? true : false; } + /** + * Compare two XdmfTopology types for inequality. Each topology type has a single static instance meaning that + * equality can be determined by determining if they have the same pointer value. + * + * @param XdmfTopologyType to compare inequality to. + * @return true iff the XdmfTopologyTypes are not equal. + */ bool operator!=(const XdmfTopologyType& top) const { return (this != &top) ? true : false; @@ -55,9 +75,14 @@ public: protected: - XdmfTopologyType(const int & numberVertices, const std::string & name) : - numberVertices(numberVertices), - name(name) + /** + * Protected constructor for XdmfTopologyType. The constructor is protected because all topology types supported + * by Xdmf should be accessed through static public instances of XdmfTopologyType - i.e. XdmfTopologyType::Tetrahedron. + */ + XdmfTopologyType(const int& nodesPerElement, const std::string& name, const CellType& cellType) : + nodesPerElement(nodesPerElement), + name(name), + cellType(cellType) {}; private: @@ -67,25 +92,43 @@ private: }; -class XdmfTopology : public XdmfObject { +class XdmfTopology : public XdmfItem { public: XdmfNewMacro(XdmfTopology); - // Get the topology type for this topology - const XdmfTopologyType & getXdmfTopologyType() const - { - return *mTopologyType; - } - // Set the topology type for this topology - void setTopologyType(const XdmfTopologyType & topType) - { - mTopologyType = &topType; - } - + /** + * Get the XdmfTopologyType associated with this Topology. + * + * @return XdmfTopologyType. + */ + const XdmfTopologyType& getTopologyType() const; + + /** + * Set the XdmfTopologyType associated with this Topology. + * + * @param XdmfTopologyType to set. + */ + void setTopologyType(const XdmfTopologyType&); + + /** + * Get the name of the TopologyType associated with this Topology. + * + * @return std::string containing name of the TopologyType. + */ const std::string getTopologyTypeAsString() const; + /** + * Get the number of nodes per element for this Topology. + * + * @return int of number of nodes per element. + */ + const int getNodesPerElement() const; + + /** + * + */ virtual const std::string printSelf() const; protected: diff --git a/XdmfVisitor.cpp b/XdmfVisitor.cpp new file mode 100644 index 0000000000000000000000000000000000000000..0cc9341986136bc07c756c99ad1a3685659d8d81 --- /dev/null +++ b/XdmfVisitor.cpp @@ -0,0 +1,17 @@ +// Kenneth Leiter +// Xdmf Smart Pointer Test + +#include "XdmfVisitor.hpp" + +XdmfVisitor::XdmfVisitor() +{ +} + +XdmfVisitor::~XdmfVisitor() +{ +} + +const std::string XdmfVisitor::printSelf() const +{ + return "XdmfVisitor"; +} diff --git a/XdmfVisitor.hpp b/XdmfVisitor.hpp new file mode 100644 index 0000000000000000000000000000000000000000..78034e5cbb0dfc717c0d8203637b9dd183b3bdbd --- /dev/null +++ b/XdmfVisitor.hpp @@ -0,0 +1,34 @@ +// Kenneth Leiter +// Xdmf Smart Pointer Test + +#ifndef XDMFVISITOR_HPP_ +#define XDMFVISITOR_HPP_ + +// Forward Declarations + +// Includes +#include "XdmfObject.hpp" + + +class XdmfVisitor : public XdmfObject { + +public: + + XdmfNewMacro(XdmfVisitor); + //virtual void visit(boost::shared_ptr); + + const std::string printSelf() const; + +protected: + + XdmfVisitor(); + virtual ~XdmfVisitor(); + +private: + + XdmfVisitor(const XdmfVisitor&); // Not implemented. + void operator=(const XdmfVisitor&); // Not implemented. + +}; + +#endif /* XDMFVISITOR_HPP_ */ diff --git a/test.cpp b/test.cpp index e5cc404466df24abfdbf78e045b88523e204b9e2..4d0593ffca390d30b794acd3794febc628e9466e 100644 --- a/test.cpp +++ b/test.cpp @@ -25,9 +25,9 @@ int main(int argc, char* argv[]) top->setTopologyType(XdmfTopologyType::Hexahedron); std::cout << top->getTopologyTypeAsString() << std::endl; - if (top->getXdmfTopologyType() != XdmfTopologyType::Polygon) + if (top->getTopologyType() != XdmfTopologyType::Polygon) { top->setTopologyType(XdmfTopologyType::Polygon); } - std::cout << top->getXdmfTopologyType().name << std::endl; + std::cout << top->getTopologyType().name << std::endl; } diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt index 10d837fb378eb7b8fc3e81ae090980e93469df63..9adc4cbe7f6903161495749b33d36d63cb5e1c09 100644 --- a/tests/CMakeLists.txt +++ b/tests/CMakeLists.txt @@ -1,2 +1,5 @@ -add_executable(TestXdmfTopologyType TestXdmfTopologyType) -target_link_libraries(TestXdmfTopologyType Xdmf) \ No newline at end of file +add_executable(TestXdmfTopology TestXdmfTopology) +target_link_libraries(TestXdmfTopology Xdmf) + +add_executable(TestXdmfGeometry TestXdmfGeometry) +target_link_libraries(TestXdmfGeometry Xdmf) \ No newline at end of file diff --git a/tests/TestXdmfGeometry.cpp b/tests/TestXdmfGeometry.cpp new file mode 100644 index 0000000000000000000000000000000000000000..db217e013f7e7b0e0f0b8b9b8e63be8fc48261cb --- /dev/null +++ b/tests/TestXdmfGeometry.cpp @@ -0,0 +1,21 @@ +#include "XdmfGeometry.hpp" + +int main(int argc, char* argv[]) +{ + // Test != and == operators + assert(XdmfGeometryType::XYZ == XdmfGeometryType::XYZ); + assert(XdmfGeometryType::XYZ == XdmfGeometryType::XY == false); + assert(XdmfGeometryType::XYZ != XdmfGeometryType::XYZ == false); + assert(XdmfGeometryType::XYZ != XdmfGeometryType::XY); + + boost::shared_ptr geom = XdmfGeometry::New(); + assert(geom->getGeometryType() == XdmfGeometryType::NoGeometry); + assert(geom->getGeometryType().name.compare("NONE") == 0); + assert(geom->getGeometryType().dimensions == 0); + geom->setGeometryType(XdmfGeometryType::XYZ); + assert(geom->getGeometryType() == XdmfGeometryType::XYZ); + assert(geom->getGeometryTypeAsString().compare("XYZ") == 0); + assert(geom->getDimensions() == 3); + + return 0; +} diff --git a/tests/TestXdmfTopology.cpp b/tests/TestXdmfTopology.cpp new file mode 100644 index 0000000000000000000000000000000000000000..9bde52ffa4990fc4a7ed25f6e15deab693ec3875 --- /dev/null +++ b/tests/TestXdmfTopology.cpp @@ -0,0 +1,21 @@ +#include "XdmfTopology.hpp" + +int main(int argc, char* argv[]) +{ + // Test != and == operators + assert(XdmfTopologyType::Hexahedron == XdmfTopologyType::Hexahedron); + assert(XdmfTopologyType::Hexahedron == XdmfTopologyType::Tetrahedron == false); + assert(XdmfTopologyType::Hexahedron != XdmfTopologyType::Hexahedron == false); + assert(XdmfTopologyType::Hexahedron != XdmfTopologyType::Tetrahedron); + + boost::shared_ptr top = XdmfTopology::New(); + assert(top->getTopologyType() == XdmfTopologyType::NoTopology); + assert(top->getTopologyType().name.compare("NoTopology") == 0); + assert(top->getTopologyType().nodesPerElement == 0); + top->setTopologyType(XdmfTopologyType::Hexahedron); + assert(top->getTopologyType() == XdmfTopologyType::Hexahedron); + assert(top->getTopologyTypeAsString().compare("Hexahedron") == 0); + assert(top->getNodesPerElement() == 8); + + return 0; +}