Branch data     Line data    Source code

       1                 :            : #ifndef FBIGEOM_MOAB_HPP
       2                 :            : #define FBIGEOM_MOAB_HPP
       3                 :            : 
       4                 :            : #include "FBiGeom.h"
       5                 :            : //#include "moab/Forward.hpp"
       6                 :            : #include "moab/Interface.hpp"
       7                 :            : #include "moab/FBEngine.hpp"
       8                 :            : #include "iMesh.h"
       9                 :            : #include "MBiMesh.hpp"
      10                 :            : 
      11                 :            : /* map from MOAB's MBErrorCode to tstt's */
      12                 :            : extern "C" const iBase_ErrorType iBase_ERROR_MAP[moab::MB_FAILURE + 1];
      13                 :            : 
      14                 :            : // the igeom moab instance should privide easy access to
      15                 :            : // moab::Interface, FBEngine *, and equivalent MBiMesh instance, because a lot
      16                 :            : // of code can be shared among iMesh and iGeom, especially
      17                 :            : // with respect to tags and sets
      18                 :            : // when a moab iGeom is instanced, moab will be instanced, and FBEngine too
      19                 :            : //
      20                 :            : class MBiGeom
      21                 :            : {
      22                 :            :     MBiMesh* _mbimesh;
      23                 :            :     moab::FBEngine* _fbe;
      24                 :            :     bool _mbimeshCreated, _fbeCreated;
      25                 :            : 
      26                 :            :   public:
      27                 :          5 :     MBiGeom()
      28                 :            :     {
      29                 :            :         // this will instance a moab Core, too
      30         [ +  - ]:          5 :         _mbimesh             = new MBiMesh( NULL );
      31                 :          5 :         moab::Interface* mbi = _mbimesh->mbImpl;
      32                 :            :         // pass mbi, so they will point to the same implementation
      33         [ +  - ]:          5 :         _fbe            = new FBEngine( mbi );
      34                 :          5 :         _mbimeshCreated = _fbeCreated = true;
      35                 :          5 :     }
      36                 :          1 :     MBiGeom( MBiMesh* mbi, moab::FBEngine* fbe )
      37                 :            :     {
      38                 :          1 :         _mbimesh        = mbi;
      39                 :          1 :         _fbe            = fbe;
      40                 :          1 :         _mbimeshCreated = _fbeCreated = false;
      41                 :          1 :     }
      42                 :          6 :     ~MBiGeom()
      43                 :            :     {
      44                 :            :         // some cleanup here
      45 [ +  + ][ +  - ]:          6 :         if( _fbeCreated ) delete _fbe;
      46 [ +  + ][ +  - ]:          6 :         if( _mbimeshCreated ) delete _mbimesh;
      47                 :          6 :     }
      48                 :         11 :     moab::Interface* moabItf()
      49                 :            :     {
      50                 :         11 :         return _mbimesh->mbImpl;
      51                 :            :     }
      52                 :        369 :     moab::FBEngine* FBItf()
      53                 :            :     {
      54                 :        369 :         return _fbe;
      55                 :            :     }
      56                 :        547 :     MBiMesh* mbimesh()
      57                 :            :     {
      58                 :        547 :         return _mbimesh;
      59                 :            :     }
      60                 :            : };
      61                 :            : /* Define macro for quick reference to MBInterface instance */
      62                 :         11 : static inline moab::Interface* MBI_cast( FBiGeom_Instance i )
      63                 :            : {
      64                 :         11 :     return reinterpret_cast< MBiGeom* >( i )->moabItf();
      65                 :            : }
      66                 :            : 
      67                 :            : #define MBI MBI_cast( instance )
      68                 :            : 
      69                 :        353 : static inline moab::FBEngine* FBE_cast( FBiGeom_Instance i )
      70                 :            : {
      71                 :        353 :     return reinterpret_cast< MBiGeom* >( i )->FBItf();
      72                 :            : }
      73                 :            : 
      74                 :            : /* Define macro for quick reference to moab::Interface instance */
      75                 :        181 : static inline moab::EntityHandle MBH_cast( iBase_EntityHandle h )
      76                 :            : {
      77                 :        181 :     return reinterpret_cast< moab::EntityHandle >( h );
      78                 :            : }
      79                 :            : 
      80                 :            : #define GETGTT( a ) ( reinterpret_cast< MBiGeom* >( a )->FBItf()->get_gtt() )
      81                 :            : 
      82                 :         48 : static inline bool FBiGeom_isError( int code )
      83                 :            : {
      84                 :         48 :     return ( iBase_SUCCESS != code );
      85                 :            : }
      86                 :        387 : static inline bool FBiGeom_isError( moab::ErrorCode code )
      87                 :            : {
      88                 :        387 :     return ( moab::MB_SUCCESS != code );
      89                 :            : }
      90                 :            : 
      91                 :            : // easy access to imesh instance, used for tags, sets methods
      92                 :            : #define IMESH_INSTANCE( i ) reinterpret_cast< iMesh_Instance >( reinterpret_cast< MBiGeom* >( i )->mbimesh() )
      93                 :            : 
      94                 :            : // this assumes that iGeom instance is always instance
      95                 :            : // uses MBiGeom class which sets the error
      96                 :            : #define MBIM reinterpret_cast< MBiGeom* >( instance )->mbimesh()
      97                 :            : 
      98                 :            : #define RETURN( CODE )                               \
      99                 :            :     do                                               \
     100                 :            :     {                                                \
     101                 :            :         *err = MBIM->set_last_error( ( CODE ), "" ); \
     102                 :            :         return;                                      \
     103                 :            :     } while( false )
     104                 :            : 
     105                 :            : #define ERROR( CODE, MSG )                                \
     106                 :            :     do                                                    \
     107                 :            :     {                                                     \
     108                 :            :         *err = MBIM->set_last_error( ( CODE ), ( MSG ) ); \
     109                 :            :         return;                                           \
     110                 :            :     } while( false )
     111                 :            : 
     112                 :            : #define CHKERR( CODE, MSG )                                           \
     113                 :            :     do                                                                \
     114                 :            :     {                                                                 \
     115                 :            :         if( FBiGeom_isError( ( CODE ) ) ) ERROR( ( CODE ), ( MSG ) ); \
     116                 :            :     } while( false )
     117                 :            : 
     118                 :            : #define FWDERR()                              \
     119                 :            :     do                                        \
     120                 :            :     {                                         \
     121                 :            :         if( FBiGeom_isError( *err ) ) return; \
     122                 :            :     } while( false )
     123                 :            : 
     124                 :            : #define CHECK_SIZE( array, allocated, size, type, retval )                                               \
     125                 :            :     do                                                                                                   \
     126                 :            :     {                                                                                                    \
     127                 :            :         if( 0 != allocated && NULL != array && allocated < ( size ) )                                    \
     128                 :            :         {                                                                                                \
     129                 :            :             ERROR( iBase_MEMORY_ALLOCATION_FAILED, "Allocated array not "                                \
     130                 :            :                                                    "enough to hold returned contents." );                \
     131                 :            :         }                                                                                                \
     132                 :            :         if( ( size ) && ( ( allocated ) == 0 || NULL == ( array ) ) )                                    \
     133                 :            :         {                                                                                                \
     134                 :            :             array     = (type*)malloc( ( size ) * sizeof( type ) );                                      \
     135                 :            :             allocated = ( size );                                                                        \
     136                 :            :             if( NULL == array ) { ERROR( iBase_MEMORY_ALLOCATION_FAILED, "Couldn't allocate array." ); } \
     137                 :            :         }                                                                                                \
     138                 :            :     } while( false )
     139                 :            : 
     140                 :            : #endif  // FBIGEOM_MOAB_HPP