MOAB: Mesh Oriented datABase  (version 5.2.1)
DenseTag.cpp
Go to the documentation of this file.
00001 /** \file   DenseTag.cpp
00002  *  \author Jason Kraftcheck
00003  *  \date   2010-12-14
00004  */
00005 
00006 #include "DenseTag.hpp"
00007 #include "moab/Range.hpp"
00008 #include "TagCompare.hpp"
00009 #include "SysUtil.hpp"
00010 #include "SequenceManager.hpp"
00011 #include "SequenceData.hpp"
00012 #include "moab/Error.hpp"
00013 #include "moab/ErrorHandler.hpp"
00014 #include "moab/CN.hpp"
00015 #include <utility>
00016 
00017 namespace moab
00018 {
00019 
00020 inline static ErrorCode not_found( const std::string& /*name*/, EntityHandle /*h*/ )
00021 {
00022     // MB_TAG_NOT_FOUND could be a non-error condition, do not call MB_SET_ERR on it
00023 #if 0
00024   if (h)
00025     fprintf(stderr, "[Warning]: No dense tag %s value for %s %ld\n",
00026         name.c_str(),
00027         CN::EntityTypeName(TYPE_FROM_HANDLE(h)),
00028         (unsigned long)ID_FROM_HANDLE(h));
00029   else
00030     fprintf(stderr, "[Warning]: No dense tag %s value for root set\n", name.c_str());
00031 #endif
00032 
00033     return MB_TAG_NOT_FOUND;
00034 }
00035 
00036 inline static ErrorCode ent_not_found( const std::string& /*name*/, EntityHandle /*h*/ )
00037 {
00038     // MB_ENTITY_NOT_FOUND could be a non-error condition, do not call MB_SET_ERR on it
00039 #if 0
00040   fprintf(
00041       stderr,
00042       "[Warning]: Invalid entity handle setting tag %s: %s %ld\n",
00043       name.c_str(),
00044       CN::EntityTypeName(TYPE_FROM_HANDLE(h)),
00045       (unsigned long)ID_FROM_HANDLE(h)
00046       );
00047 #endif
00048 
00049     return MB_ENTITY_NOT_FOUND;
00050 }
00051 
00052 DenseTag::DenseTag( int index, const char* name, int size, DataType type, const void* default_value )
00053     : TagInfo( name, size, type, default_value, size ), mySequenceArray( index ), meshValue( 0 )
00054 {
00055 }
00056 
00057 TagType DenseTag::get_storage_type() const
00058 {
00059     return MB_TAG_DENSE;
00060 }
00061 
00062 DenseTag* DenseTag::create_tag( SequenceManager* seqman, Error* /* error */, const char* name, int bytes, DataType type,
00063                                 const void* default_value )
00064 {
00065     if( bytes < 1 ) return 0;
00066 
00067     int index;
00068     if( MB_SUCCESS != seqman->reserve_tag_array( NULL, bytes, index ) ) return 0;
00069 
00070     return new DenseTag( index, name, bytes, type, default_value );
00071 }
00072 
00073 DenseTag::~DenseTag()
00074 {
00075     assert( mySequenceArray < 0 );
00076     delete[] meshValue;
00077 }
00078 
00079 ErrorCode DenseTag::release_all_data( SequenceManager* seqman, Error* /* error */, bool delete_pending )
00080 {
00081     ErrorCode result = seqman->release_tag_array( NULL, mySequenceArray, delete_pending );
00082     if( MB_SUCCESS == result && delete_pending ) mySequenceArray = -1;
00083     return result;
00084 }
00085 
00086 ErrorCode DenseTag::get_array( const SequenceManager* seqman, Error* /* error */, EntityHandle h,
00087                                const unsigned char* const& ptr, size_t& count ) const
00088 {
00089     //  cast away the const-ness; do we really want to do this?
00090     // probably we are not calling this anywhere;
00091     // clang compiler found this
00092     return get_array_private( seqman, NULL, h, const_cast< const unsigned char*& >( ptr ), count );
00093 }
00094 
00095 ErrorCode DenseTag::get_array_private( const SequenceManager* seqman, Error* /* error */, EntityHandle h,
00096                                        const unsigned char*& ptr, size_t& count ) const
00097 {
00098     const EntitySequence* seq = 0;
00099     ErrorCode rval            = seqman->find( h, seq );
00100     if( MB_SUCCESS != rval )
00101     {
00102         if( !h )
00103         {  // Root set
00104             ptr   = meshValue;
00105             count = 1;
00106             return MB_SUCCESS;
00107         }
00108         else
00109         {  // Not root set
00110             ptr   = 0;
00111             count = 0;
00112             return ent_not_found( get_name(), h );
00113         }
00114     }
00115 
00116     const void* mem = seq->data()->get_tag_data( mySequenceArray );
00117     ptr             = reinterpret_cast< const unsigned char* >( mem );
00118     count           = seq->data()->end_handle() - h + 1;
00119     if( ptr ) ptr += get_size() * ( h - seq->data()->start_handle() );
00120 
00121     return MB_SUCCESS;
00122 }
00123 
00124 ErrorCode DenseTag::get_array( const EntitySequence* seq, const unsigned char* const& ptr ) const
00125 {
00126     // cast away the constness; otherwise it would be infinite recursion
00127     // probably we are not calling this anywhere
00128     return get_array_private( seq, const_cast< const unsigned char*& >( ptr ) );
00129 }
00130 
00131 ErrorCode DenseTag::get_array_private( const EntitySequence* seq, const unsigned char*& ptr ) const
00132 {
00133     ptr = reinterpret_cast< const unsigned char* >( seq->data()->get_tag_data( mySequenceArray ) );
00134     if( ptr ) ptr += get_size() * ( seq->start_handle() - seq->data()->start_handle() );
00135 
00136     return MB_SUCCESS;
00137 }
00138 
00139 ErrorCode DenseTag::get_array_private( SequenceManager* seqman, Error* /* error */, EntityHandle h, unsigned char*& ptr,
00140                                        size_t& count, bool allocate )
00141 {
00142     EntitySequence* seq = 0;
00143     ErrorCode rval      = seqman->find( h, seq );
00144     if( MB_SUCCESS != rval )
00145     {
00146         if( !h )
00147         {  // Root set
00148             if( !meshValue && allocate ) meshValue = new unsigned char[get_size()];
00149             ptr   = meshValue;
00150             count = 1;
00151             return MB_SUCCESS;
00152         }
00153         else
00154         {  // Not root set
00155             ptr   = 0;
00156             count = 0;
00157             return ent_not_found( get_name(), h );
00158         }
00159     }
00160 
00161     void* mem = seq->data()->get_tag_data( mySequenceArray );
00162     if( !mem && allocate )
00163     {
00164         mem = seq->data()->allocate_tag_array( mySequenceArray, get_size(), get_default_value() );
00165         if( !mem ) { MB_SET_ERR( MB_MEMORY_ALLOCATION_FAILED, "Memory allocation for dense tag data failed" ); }
00166 
00167         if( !get_default_value() ) memset( mem, 0, get_size() * seq->data()->size() );
00168     }
00169 
00170     ptr   = reinterpret_cast< unsigned char* >( mem );
00171     count = seq->data()->end_handle() - h + 1;
00172     if( ptr ) ptr += get_size() * ( h - seq->data()->start_handle() );
00173     return MB_SUCCESS;
00174 }
00175 
00176 ErrorCode DenseTag::get_data( const SequenceManager* seqman, Error* /* error */, const EntityHandle* entities,
00177                               size_t num_entities, void* adata ) const
00178 {
00179     size_t junk                   = 0;
00180     unsigned char* ptr            = reinterpret_cast< unsigned char* >( adata );
00181     const EntityHandle* const end = entities + num_entities;
00182     for( const EntityHandle* i = entities; i != end; ++i, ptr += get_size() )
00183     {
00184         const unsigned char* data = 0;
00185         ErrorCode rval            = get_array( seqman, NULL, *i, data, junk );MB_CHK_ERR( rval );
00186 
00187         if( data )
00188             memcpy( ptr, data, get_size() );
00189         else if( get_default_value() )
00190             memcpy( ptr, get_default_value(), get_size() );
00191         else
00192             return not_found( get_name(), *i );
00193     }
00194 
00195     return MB_SUCCESS;
00196 }
00197 
00198 ErrorCode DenseTag::get_data( const SequenceManager* seqman, Error* /* error */, const Range& entities,
00199                               void* values ) const
00200 {
00201     ErrorCode rval;
00202     size_t avail               = 0;
00203     const unsigned char* array = NULL;  // Initialize to get rid of warning
00204     unsigned char* data        = reinterpret_cast< unsigned char* >( values );
00205 
00206     for( Range::const_pair_iterator p = entities.const_pair_begin(); p != entities.const_pair_end(); ++p )
00207     {
00208         EntityHandle start = p->first;
00209         while( start <= p->second )
00210         {
00211             rval = get_array( seqman, NULL, start, array, avail );MB_CHK_ERR( rval );
00212 
00213             const size_t count = std::min< size_t >( p->second - start + 1, avail );
00214             if( array )
00215                 memcpy( data, array, get_size() * count );
00216             else if( get_default_value() )
00217                 SysUtil::setmem( data, get_default_value(), get_size(), count );
00218             else
00219                 return not_found( get_name(), start );
00220 
00221             data += get_size() * count;
00222             start += count;
00223         }
00224     }
00225 
00226     return MB_SUCCESS;
00227 }
00228 
00229 ErrorCode DenseTag::get_data( const SequenceManager* seqman, Error* /* error */, const EntityHandle* entities,
00230                               size_t num_entities, const void** pointers, int* data_lengths ) const
00231 {
00232     ErrorCode result;
00233     const EntityHandle* const end = entities + num_entities;
00234     size_t junk                   = 0;
00235     const unsigned char* ptr      = NULL;  // Initialize to get rid of warning
00236 
00237     if( data_lengths )
00238     {
00239         const int len = get_size();
00240         SysUtil::setmem( data_lengths, &len, sizeof( int ), num_entities );
00241     }
00242 
00243     for( const EntityHandle* i = entities; i != end; ++i, ++pointers )
00244     {
00245         result = get_array( seqman, NULL, *i, ptr, junk );MB_CHK_ERR( result );
00246 
00247         if( ptr )
00248             *pointers = ptr;
00249         else if( get_default_value() )
00250             *pointers = get_default_value();
00251         else
00252             return not_found( get_name(), *i );
00253     }
00254 
00255     return MB_SUCCESS;
00256 }
00257 
00258 ErrorCode DenseTag::get_data( const SequenceManager* seqman, Error* /* error */, const Range& entities,
00259                               const void** pointers, int* data_lengths ) const
00260 {
00261     ErrorCode rval;
00262     size_t avail               = 0;
00263     const unsigned char* array = NULL;
00264 
00265     if( data_lengths )
00266     {
00267         int len = get_size();
00268         SysUtil::setmem( data_lengths, &len, sizeof( int ), entities.size() );
00269     }
00270 
00271     for( Range::const_pair_iterator p = entities.const_pair_begin(); p != entities.const_pair_end(); ++p )
00272     {
00273         EntityHandle start = p->first;
00274         while( start <= p->second )
00275         {
00276             rval = get_array( seqman, NULL, start, array, avail );MB_CHK_ERR( rval );
00277 
00278             const size_t count = std::min< size_t >( p->second - start + 1, avail );
00279             if( array )
00280             {
00281                 for( EntityHandle end = start + count; start != end; ++start )
00282                 {
00283                     *pointers = array;
00284                     array += get_size();
00285                     ++pointers;
00286                 }
00287             }
00288             else if( const void* val = get_default_value() )
00289             {
00290                 SysUtil::setmem( pointers, &val, sizeof( void* ), count );
00291                 pointers += count;
00292                 start += count;
00293             }
00294             else
00295             {
00296                 return not_found( get_name(), start );
00297             }
00298         }
00299     }
00300 
00301     return MB_SUCCESS;
00302 }
00303 
00304 ErrorCode DenseTag::set_data( SequenceManager* seqman, Error* /* error */, const EntityHandle* entities,
00305                               size_t num_entities, const void* data )
00306 {
00307     ErrorCode rval;
00308     const unsigned char* ptr      = reinterpret_cast< const unsigned char* >( data );
00309     const EntityHandle* const end = entities + num_entities;
00310     unsigned char* array          = NULL;
00311     size_t junk                   = 0;
00312 
00313     for( const EntityHandle* i = entities; i != end; ++i, ptr += get_size() )
00314     {
00315         rval = get_array_private( seqman, NULL, *i, array, junk, true );MB_CHK_ERR( rval );
00316 
00317         memcpy( array, ptr, get_size() );
00318     }
00319 
00320     return MB_SUCCESS;
00321 }
00322 
00323 ErrorCode DenseTag::set_data( SequenceManager* seqman, Error* /* error */, const Range& entities, const void* values )
00324 {
00325     ErrorCode rval;
00326     const char* data     = reinterpret_cast< const char* >( values );
00327     unsigned char* array = NULL;
00328     size_t avail         = 0;
00329 
00330     for( Range::const_pair_iterator p = entities.const_pair_begin(); p != entities.const_pair_end(); ++p )
00331     {
00332         EntityHandle start = p->first;
00333         while( start <= p->second )
00334         {
00335             rval = get_array_private( seqman, NULL, start, array, avail, true );MB_CHK_ERR( rval );
00336 
00337             const size_t count = std::min< size_t >( p->second - start + 1, avail );
00338             memcpy( array, data, get_size() * count );
00339             data += get_size() * count;
00340             start += count;
00341         }
00342     }
00343 
00344     return MB_SUCCESS;
00345 }
00346 
00347 ErrorCode DenseTag::set_data( SequenceManager* seqman, Error* /* error */, const EntityHandle* entities,
00348                               size_t num_entities, void const* const* pointers, const int* data_lengths )
00349 {
00350     ErrorCode rval = validate_lengths( NULL, data_lengths, num_entities );MB_CHK_ERR( rval );
00351 
00352     const EntityHandle* const end = entities + num_entities;
00353     unsigned char* array          = NULL;
00354     size_t junk                   = 0;
00355 
00356     for( const EntityHandle* i = entities; i != end; ++i, ++pointers )
00357     {
00358         rval = get_array_private( seqman, NULL, *i, array, junk, true );MB_CHK_ERR( rval );
00359 
00360         memcpy( array, *pointers, get_size() );
00361     }
00362 
00363     return MB_SUCCESS;
00364 }
00365 
00366 ErrorCode DenseTag::set_data( SequenceManager* seqman, Error* /* error */, const Range& entities,
00367                               void const* const* pointers, const int* /* data_lengths */ )
00368 {
00369     ErrorCode rval;
00370     unsigned char* array = NULL;
00371     size_t avail         = 0;
00372 
00373     for( Range::const_pair_iterator p = entities.const_pair_begin(); p != entities.const_pair_end(); ++p )
00374     {
00375         EntityHandle start = p->first;
00376         while( start <= p->second )
00377         {
00378             rval = get_array_private( seqman, NULL, start, array, avail, true );MB_CHK_ERR( rval );
00379 
00380             const EntityHandle end = std::min< EntityHandle >( p->second + 1, start + avail );
00381             while( start != end )
00382             {
00383                 memcpy( array, *pointers, get_size() );
00384                 ++start;
00385                 ++pointers;
00386                 array += get_size();
00387             }
00388         }
00389     }
00390 
00391     return MB_SUCCESS;
00392 }
00393 
00394 ErrorCode DenseTag::clear_data( bool allocate, SequenceManager* seqman, Error* /* error */,
00395                                 const EntityHandle* entities, size_t num_entities, const void* value_ptr )
00396 {
00397     ErrorCode rval;
00398     const EntityHandle* const end = entities + num_entities;
00399     unsigned char* array          = NULL;
00400     size_t junk                   = 0;
00401 
00402     for( const EntityHandle* i = entities; i != end; ++i )
00403     {
00404         rval = get_array_private( seqman, NULL, *i, array, junk, allocate );MB_CHK_ERR( rval );
00405 
00406         if( array )  // Array should never be null if allocate == true
00407             memcpy( array, value_ptr, get_size() );
00408     }
00409 
00410     return MB_SUCCESS;
00411 }
00412 
00413 ErrorCode DenseTag::clear_data( bool allocate, SequenceManager* seqman, Error* /* error */, const Range& entities,
00414                                 const void* value_ptr )
00415 {
00416     ErrorCode rval;
00417     unsigned char* array = NULL;
00418     size_t avail         = 0;
00419 
00420     for( Range::const_pair_iterator p = entities.const_pair_begin(); p != entities.const_pair_end(); ++p )
00421     {
00422         EntityHandle start = p->first;
00423         while( start <= p->second )
00424         {
00425             rval = get_array_private( seqman, NULL, start, array, avail, allocate );MB_CHK_ERR( rval );
00426 
00427             const size_t count = std::min< size_t >( p->second - start + 1, avail );
00428             if( array )  // Array should never be null if allocate == true
00429                 SysUtil::setmem( array, value_ptr, get_size(), count );
00430             start += count;
00431         }
00432     }
00433 
00434     return MB_SUCCESS;
00435 }
00436 
00437 ErrorCode DenseTag::clear_data( SequenceManager* seqman, Error* /* error */, const EntityHandle* entities,
00438                                 size_t num_entities, const void* value_ptr, int value_len )
00439 {
00440     if( value_len && value_len != get_size() ) return MB_INVALID_SIZE;
00441 
00442     return clear_data( true, seqman, NULL, entities, num_entities, value_ptr );
00443 }
00444 
00445 ErrorCode DenseTag::clear_data( SequenceManager* seqman, Error* /* error */, const Range& entities,
00446                                 const void* value_ptr, int value_len )
00447 {
00448     if( value_len && value_len != get_size() ) return MB_INVALID_SIZE;
00449 
00450     return clear_data( true, seqman, NULL, entities, value_ptr );
00451 }
00452 
00453 ErrorCode DenseTag::remove_data( SequenceManager* seqman, Error* /* error */, const EntityHandle* entities,
00454                                  size_t num_entities )
00455 {
00456     std::vector< unsigned char > zeros;
00457     const void* value = get_default_value();
00458     if( !value )
00459     {
00460         zeros.resize( get_size(), 0 );
00461         value = &zeros[0];
00462     }
00463 
00464     return clear_data( false, seqman, NULL, entities, num_entities, value );
00465 }
00466 
00467 ErrorCode DenseTag::remove_data( SequenceManager* seqman, Error* /* error */, const Range& entities )
00468 {
00469     std::vector< unsigned char > zeros;
00470     const void* value = get_default_value();
00471     if( !value )
00472     {
00473         zeros.resize( get_size(), 0 );
00474         value = &zeros[0];
00475     }
00476 
00477     return clear_data( false, seqman, NULL, entities, value );
00478 }
00479 
00480 ErrorCode DenseTag::tag_iterate( SequenceManager* seqman, Error* /* error */, Range::iterator& iter,
00481                                  const Range::iterator& end, void*& data_ptr, bool allocate )
00482 {
00483     // If asked for nothing, successfully return nothing.
00484     if( iter == end ) return MB_SUCCESS;
00485 
00486     unsigned char* array = NULL;
00487     size_t avail         = 0;
00488     ErrorCode rval       = get_array_private( seqman, NULL, *iter, array, avail, allocate );MB_CHK_ERR( rval );
00489     data_ptr = array;
00490 
00491     size_t count = std::min< size_t >( avail, *( iter.end_of_block() ) - *iter + 1 );
00492     if( 0 != *end && *end <= *( iter.end_of_block() ) )
00493         iter = end;
00494     else
00495         iter += count;
00496 
00497     return MB_SUCCESS;
00498 }
00499 
00500 ErrorCode DenseTag::get_tagged_entities( const SequenceManager* seqman, Range& entities_in, EntityType type,
00501                                          const Range* intersect_list ) const
00502 {
00503     Range tmp;
00504     Range* entities                           = intersect_list ? &tmp : &entities_in;
00505     Range::iterator hint                      = entities->begin();
00506     std::pair< EntityType, EntityType > range = type_range( type );
00507     TypeSequenceManager::const_iterator i;
00508     for( EntityType t = range.first; t != range.second; ++t )
00509     {
00510         const TypeSequenceManager& map = seqman->entity_map( t );
00511         for( i = map.begin(); i != map.end(); ++i )
00512             if( ( *i )->data()->get_tag_data( mySequenceArray ) )
00513                 hint = entities->insert( hint, ( *i )->start_handle(), ( *i )->end_handle() );
00514     }
00515 
00516     if( intersect_list ) entities_in = intersect( *entities, *intersect_list );
00517 
00518     return MB_SUCCESS;
00519 }
00520 
00521 ErrorCode DenseTag::num_tagged_entities( const SequenceManager* seqman, size_t& output_count, EntityType type,
00522                                          const Range* intersect ) const
00523 {
00524     Range tmp;
00525     ErrorCode rval = get_tagged_entities( seqman, tmp, type, intersect );
00526     output_count += tmp.size();
00527 
00528     return rval;
00529 }
00530 
00531 ErrorCode DenseTag::find_entities_with_value( const SequenceManager* seqman, Error* /* error */, Range& output_entities,
00532                                               const void* value, int value_bytes, EntityType type,
00533                                               const Range* intersect_entities ) const
00534 {
00535     if( value_bytes && value_bytes != get_size() )
00536     {
00537         MB_SET_ERR( MB_INVALID_SIZE,
00538                     "Cannot compare data of size " << value_bytes << " with tag of size " << get_size() );
00539     }
00540 
00541     if( !intersect_entities )
00542     {
00543         std::pair< EntityType, EntityType > range = type_range( type );
00544         TypeSequenceManager::const_iterator i;
00545         for( EntityType t = range.first; t != range.second; ++t )
00546         {
00547             const TypeSequenceManager& map = seqman->entity_map( t );
00548             for( i = map.begin(); i != map.end(); ++i )
00549             {
00550                 const void* data = ( *i )->data()->get_tag_data( mySequenceArray );
00551                 if( data )
00552                 {
00553                     ByteArrayIterator start( ( *i )->data()->start_handle(), data, *this );
00554                     ByteArrayIterator end( ( *i )->end_handle() + 1, 0, 0 );
00555                     start += ( *i )->start_handle() - ( *i )->data()->start_handle();
00556                     find_tag_values_equal( *this, value, get_size(), start, end, output_entities );
00557                 }
00558             }
00559         }
00560     }
00561     else
00562     {
00563         const unsigned char* array = NULL;  // Initialize to get rid of warning
00564         size_t count;
00565         ErrorCode rval;
00566 
00567         Range::const_pair_iterator p = intersect_entities->begin();
00568         if( type != MBMAXTYPE )
00569         {
00570             p = intersect_entities->lower_bound( type );
00571             assert( TYPE_FROM_HANDLE( p->first ) == type );
00572         }
00573         for( ;
00574              p != intersect_entities->const_pair_end() && ( MBMAXTYPE == type || TYPE_FROM_HANDLE( p->first ) == type );
00575              ++p )
00576         {
00577             EntityHandle start = p->first;
00578             while( start <= p->second )
00579             {
00580                 rval = get_array( seqman, NULL, start, array, count );MB_CHK_ERR( rval );
00581 
00582                 if( p->second - start < count - 1 ) count = p->second - start + 1;
00583 
00584                 if( array )
00585                 {
00586                     ByteArrayIterator istart( start, array, *this );
00587                     ByteArrayIterator iend( start + count, 0, 0 );
00588                     find_tag_values_equal( *this, value, get_size(), istart, iend, output_entities );
00589                 }
00590                 start += count;
00591             }
00592         }
00593     }
00594 
00595     return MB_SUCCESS;
00596 }
00597 
00598 bool DenseTag::is_tagged( const SequenceManager* seqman, EntityHandle h ) const
00599 {
00600     const unsigned char* ptr = NULL;  // Initialize to get rid of warning
00601     size_t count;
00602     return ( MB_SUCCESS == get_array( seqman, 0, h, ptr, count ) ) && ( NULL != ptr );
00603 }
00604 
00605 ErrorCode DenseTag::get_memory_use( const SequenceManager* seqman, unsigned long& total,
00606                                     unsigned long& per_entity ) const
00607 {
00608     per_entity = get_size();
00609     total      = TagInfo::get_memory_use() + sizeof( *this );
00610     for( EntityType t = MBVERTEX; t <= MBENTITYSET; ++t )
00611     {
00612         const TypeSequenceManager& map = seqman->entity_map( t );
00613         const SequenceData* prev_data  = 0;
00614         for( TypeSequenceManager::const_iterator i = map.begin(); i != map.end(); ++i )
00615         {
00616             if( ( *i )->data() != prev_data && ( *i )->data()->get_tag_data( mySequenceArray ) )
00617             {
00618                 prev_data = ( *i )->data();
00619                 total += get_size() * ( *i )->data()->size();
00620             }
00621         }
00622     }
00623 
00624     return MB_SUCCESS;
00625 }
00626 
00627 }  // namespace moab
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines