MeshSet.hpp

Go to the documentation of this file.

#ifndef MB_MESHSET_HPP
#define MB_MESHSET_HPP
 
#ifndef IS_BUILDING_MB
#error "MB_MeshSet.hpp isn't supposed to be included into an application"
#endif
 
#include "moab/Interface.hpp"
#include "Internals.hpp"
#include "moab/Range.hpp"
#include "moab/CN.hpp"
 
#include <cassert>
#include <vector>
#include <algorithm>
#include <iterator>
 
namespace moab
{
 
class AEntityFactory;
 
/** \brief Class to implement entity set functionality
 * \author Jason Kraftcheck <[email protected]>
 */
class MeshSet
{
 public:
 //! create an empty meshset
 inline MeshSet();
 inline MeshSet( unsigned flags );
 
 //! destructor
 inline ~MeshSet();
 
 inline ErrorCode set_flags( unsigned flags, EntityHandle my_handle, AEntityFactory* adjacencies );
 
 //! get all children pointed to by this meshset
 inline const EntityHandle* get_children( int& count_out ) const;
 
 //! get all parents pointed to by this meshset
 inline const EntityHandle* get_parents( int& count_out ) const;
 
 //! return the number of children pointed to by this meshset
 inline int num_children() const;
 
 //! return the number of parents pointed to by this meshset
 inline int num_parents() const;
 
 //! add a parent to this meshset; returns true if parent was added, 0 if it was
 //! already a parent of this meshset
 int add_parent( EntityHandle parent );
 
 //! add a child to this meshset; returns true if child was added, 0 if it was
 //! already a child of this meshset
 int add_child( EntityHandle child );
 
 //! remove a parent from this meshset; returns true if parent was removed, 0 if it was
 //! not a parent of this meshset
 int remove_parent( EntityHandle parent );
 
 //! remove a child from this meshset; returns true if child was removed, 0 if it was
 //! not a child of this meshset
 int remove_child( EntityHandle child );
 
 unsigned flags() const
 {
 return mFlags;
 }
 //! returns whether entities of meshsets know this meshset
 int tracking() const
 {
 return mFlags & MESHSET_TRACK_OWNER;
 }
 int set() const
 {
 return mFlags & MESHSET_SET;
 }
 int ordered() const
 {
 return mFlags & MESHSET_ORDERED;
 }
 int vector_based() const
 {
 return ordered();
 }
 
 //! replace one entity with another in the set (contents and parent/child
 //! lists); returns whether it was replaced or not
 ErrorCode replace_entities( EntityHandle my_handle,
 const EntityHandle* old_entities,
 const EntityHandle* new_entities,
 size_t num_entities,
 AEntityFactory* mAdjFact );
 
 /** Clear *contents* of set (not parents or children) */
 inline ErrorCode clear( EntityHandle myhandle, AEntityFactory* adjacencies );
 
 /** Clear all set lists (contents, parents, and children) */
 inline ErrorCode clear_all( EntityHandle myhandle, AEntityFactory* adjacencies );
 
 /** Get contents data array. NOTE: this may not contain what you expect if not vector_based */
 inline const EntityHandle* get_contents( size_t& count_out ) const;
 /** Get contents data array. NOTE: this may not contain what you expect if not vector_based */
 inline EntityHandle* get_contents( size_t& count_out );
 
 /** Get entities contained in set */
 inline ErrorCode get_entities( std::vector< EntityHandle >& entities ) const;
 
 /** Get entities contained in set */
 inline ErrorCode get_entities( Range& entities ) const;
 
 //! get all entities in this MeshSet with the specified type
 inline ErrorCode get_entities_by_type( EntityType entity_type, std::vector< EntityHandle >& entity_list ) const;
 
 inline ErrorCode get_entities_by_type( EntityType type, Range& entity_list ) const;
 
 //! return the number of entities with the given type contained in this meshset
 inline unsigned int num_entities_by_type( EntityType type ) const;
 
 inline ErrorCode get_entities_by_dimension( int dimension, std::vector< EntityHandle >& entity_list ) const;
 
 inline ErrorCode get_entities_by_dimension( int dimension, Range& entity_list ) const;
 
 //! return the number of entities with the given type contained in this meshset
 inline unsigned int num_entities_by_dimension( int dimension ) const;
 
 inline ErrorCode get_non_set_entities( Range& range ) const;
 
 /** Test of meshset contains some or all of passed entities
 *
 *\param entities Array of entities
 *\param num_entities Length of array of entities.
 *\param op - Interface::UNION : Test if set contains any of the input entities
 * - Interface::INTERSECT : Test if set contains all of the input entities
 */
 inline bool contains_entities( const EntityHandle* entities, int num_entities, const int op ) const;
 
 //! subtract/intersect/unite meshset_2 from/with/into meshset_1; modifies meshset_1
 inline ErrorCode subtract( const MeshSet* meshset_2, EntityHandle my_handle, AEntityFactory* adjacencies );
 
 ErrorCode intersect( const MeshSet* meshset_2, EntityHandle my_handle, AEntityFactory* adjacencies );
 
 inline ErrorCode unite( const MeshSet* meshset_2, EntityHandle my_handle, AEntityFactory* adjacencies );
 
 //! add these entities to this meshset
 inline ErrorCode add_entities( const EntityHandle* entity_handles,
 const int num_entities,
 EntityHandle my_handle,
 AEntityFactory* adjacencies );
 
 //! add these entities to this meshset
 inline ErrorCode add_entities( const Range& entities, EntityHandle my_handle, AEntityFactory* adjacencies );
 
 //! add these entities to this meshset
 inline ErrorCode remove_entities( const Range& entities, EntityHandle my_handle, AEntityFactory* adjacencies );
 
 //! remove these entities from this meshset
 inline ErrorCode remove_entities( const EntityHandle* entities,
 const int num_entities,
 EntityHandle my_handle,
 AEntityFactory* adjacencies );
 
 //! return the number of entities contained in this meshset
 inline unsigned int num_entities() const;
 
 inline bool empty() const
 {
 return mContentCount == ZERO;
 }
 
 unsigned long get_memory_use() const;
 
 protected:
 /** Convert for changing flag values */
 ErrorCode convert( unsigned flags, EntityHandle my_handle, AEntityFactory* adj );
 
 /** Add explicit adjacencies from all contained entities to this (i.e. convert to tracking) */
 ErrorCode create_adjacencies( EntityHandle myhandle, AEntityFactory* adjacencies );
 
 /** Remvoe explicit adjacencies from all contained entities to this (i.e. convert from tracking)
 */
 ErrorCode remove_adjacencies( EntityHandle myhandle, AEntityFactory* adjacencies );
 
 /** Insert vector of handles into MeshSet */
 ErrorCode insert_entity_vector( const EntityHandle* vect, size_t len, EntityHandle my_h, AEntityFactory* adj );
 
 /** Insert vector of handle range pairs into MeshSet */
 ErrorCode insert_entity_ranges( const EntityHandle* range_vect,
 size_t len,
 EntityHandle my_h,
 AEntityFactory* adj );
 
 /** Insert Range of handles into MeshSet */
 ErrorCode insert_entity_ranges( const Range& range, EntityHandle my_h, AEntityFactory* adj );
 
 /** Remove vector of handles from MeshSet */
 ErrorCode remove_entity_vector( const EntityHandle* vect, size_t len, EntityHandle my_h, AEntityFactory* adj );
 
 /** Remove vector of handle range pairs from MeshSet */
 ErrorCode remove_entity_ranges( const EntityHandle* range_vect,
 size_t len,
 EntityHandle my_h,
 AEntityFactory* adj );
 
 /** Remove Range of handles from MeshSet */
 ErrorCode remove_entity_ranges( const Range& range, EntityHandle my_h, AEntityFactory* adj );
 
 public:
 //! Possible values of mParentCount and mChildCount
 enum Count
 {
 ZERO = 0,
 ONE = 1,
 TWO = 2,
 MANY = 3
 };
 //! If the number of entities is less than 3, store
 //! the handles directly in the hnd member. Otherwise
 //! use the ptr member to hold the beginning and end
 //! of a dynamically allocated array.
 union CompactList
 {
 EntityHandle hnd[2]; //!< Two handles
 EntityHandle* ptr[2]; //!< begin and end pointers for array
 };
 
 private:
 //! Meshset propery flags
 unsigned char mFlags;
 //! If less than MANY, the number of parents stored inline in
 //! parentMeshSets.hnd. If MANY, then parentMeshSets.ptr contains
 //! array begin and end pointers for a dynamically allocated array
 //! of parent handles.
 unsigned mParentCount : 2;
 //! If less than MANY, the number of children stored inline in
 //! childMeshSets.hnd. If MANY, then childMeshSets.ptr contains
 //! array begin and end pointers for a dynamically allocated array
 //! of child handles.
 unsigned mChildCount : 2;
 //! If less than MANY, the number of children stored inline in
 //! contentList.hnd. If MANY, then contentList.ptr contains
 //! array begin and end pointers for a dynamically allocated array..
 unsigned mContentCount : 2;
 //! Storage for data lists
 CompactList parentMeshSets, childMeshSets, contentList;
 
 public:
 /** get dimension of enity */
 static inline int DIM_FROM_HANDLE( EntityHandle h )
 {
 return CN::Dimension( TYPE_FROM_HANDLE( h ) );
 }
 
 /** Get smallest possible handle with specified dimension (first handle for first type of
 * dimension) */
 static inline EntityHandle FIRST_OF_DIM( int dim )
 {
 return FIRST_HANDLE( CN::TypeDimensionMap[dim].first );
 }
 
 /** Get largest possible handle with specified dimension (largest handle for last type of
 * dimension) */
 static inline EntityHandle LAST_OF_DIM( int dim )
 {
 return LAST_HANDLE( CN::TypeDimensionMap[dim].second );
 }
 
 /** functor: test if handle is not of type */
 struct not_type_test
 {
 inline not_type_test( EntityType type ) : mType( type ) {}
 inline bool operator()( EntityHandle handle )
 {
 return TYPE_FROM_HANDLE( handle ) != mType;
 }
 EntityType mType;
 };
 
 /** functor: test if handle is of type */
 struct type_test
 {
 inline type_test( EntityType type ) : mType( type ) {}
 inline bool operator()( EntityHandle handle )
 {
 return TYPE_FROM_HANDLE( handle ) == mType;
 }
 EntityType mType;
 };
 
 /** functor: test if handle is not of dimension */
 struct not_dim_test
 {
 inline not_dim_test( int dimension ) : mDim( dimension ) {}
 inline bool operator()( EntityHandle handle ) const
 {
 return DIM_FROM_HANDLE( handle ) != mDim;
 }
 int mDim;
 };
 
 /** functor: test if handle is of dimension */
 struct dim_test
 {
 inline dim_test( int dimension ) : mDim( dimension ) {}
 inline bool operator()( EntityHandle handle ) const
 {
 return DIM_FROM_HANDLE( handle ) == mDim;
 }
 int mDim;
 };
 
 /** Iterate over range of handles. That is, given [first_handle,last_handle],
 * step through all contained values.
 */
 struct hdl_iter
 {
 EntityHandle h;
 hdl_iter( EntityHandle val ) : h( val ) {}
 hdl_iter& operator++()
 {
 ++h;
 return *this;
 }
 hdl_iter& operator--()
 {
 --h;
 return *this;
 }
 hdl_iter operator++( int )
 {
 return hdl_iter( h++ );
 }
 hdl_iter operator--( int )
 {
 return hdl_iter( h-- );
 }
 hdl_iter& operator+=( size_t s )
 {
 h += s;
 return *this;
 }
 hdl_iter& operator-=( size_t s )
 {
 h -= s;
 return *this;
 }
 EntityHandle operator*() const
 {
 return h;
 }
 bool operator==( hdl_iter other ) const
 {
 return h == other.h;
 }
 bool operator!=( hdl_iter other ) const
 {
 return h != other.h;
 }
 bool operator<( hdl_iter other ) const
 {
 return h < other.h;
 }
 bool operator>( hdl_iter other ) const
 {
 return h > other.h;
 }
 bool operator<=( hdl_iter other ) const
 {
 return h <= other.h;
 }
 bool operator>=( hdl_iter other ) const
 {
 return h >= other.h;
 }
 
 struct iterator_category : public std::random_access_iterator_tag
 {
 };
 typedef EntityID difference_type;
 typedef EntityHandle value_type;
 typedef EntityHandle* pointer;
 typedef EntityHandle& reference;
 };
};
 
inline MeshSet::hdl_iter::difference_type operator-( const MeshSet::hdl_iter& a, const MeshSet::hdl_iter& b )
{
 return (MeshSet::hdl_iter::difference_type)a.h - (MeshSet::hdl_iter::difference_type)b.h;
}
 
//! create an empty meshset
MeshSet::MeshSet() : mFlags( 0 ), mParentCount( ZERO ), mChildCount( ZERO ), mContentCount( ZERO ) {}
 
//! create an empty meshset
MeshSet::MeshSet( unsigned flg )
 : mFlags( (unsigned char)flg ), mParentCount( ZERO ), mChildCount( ZERO ), mContentCount( ZERO )
{
}
 
//! destructor
MeshSet::~MeshSet()
{
 if( mChildCount == MANY ) free( childMeshSets.ptr[0] );
 if( mParentCount == MANY ) free( parentMeshSets.ptr[0] );
 if( mContentCount == MANY ) free( contentList.ptr[0] );
 mChildCount = mParentCount = mContentCount = ZERO;
}
 
ErrorCode MeshSet::set_flags( unsigned flg, EntityHandle my_handle, AEntityFactory* adjacencies )
{
 if( ZERO != mContentCount )
 {
 ErrorCode result = convert( flg, my_handle, adjacencies );
 if( MB_SUCCESS != result ) return result;
 }
 mFlags = (unsigned char)flg;
 return MB_SUCCESS;
}
 
//! get all children pointed to by this meshset
const EntityHandle* MeshSet::get_children( int& count_out ) const
{
 count_out = mChildCount;
 if( count_out < MANY ) return childMeshSets.hnd;
 
 count_out = childMeshSets.ptr[1] - childMeshSets.ptr[0];
 return childMeshSets.ptr[0];
}
 
//! get all parents pointed to by this meshset
const EntityHandle* MeshSet::get_parents( int& count_out ) const
{
 count_out = mParentCount;
 if( count_out < MANY ) return parentMeshSets.hnd;
 
 count_out = parentMeshSets.ptr[1] - parentMeshSets.ptr[0];
 return parentMeshSets.ptr[0];
}
 
//! return the number of children pointed to by this meshset
int MeshSet::num_children() const
{
 if( mChildCount < MANY )
 return mChildCount;
 else
 return childMeshSets.ptr[1] - childMeshSets.ptr[0];
}
 
//! return the number of parents pointed to by this meshset
int MeshSet::num_parents() const
{
 if( mParentCount < MANY )
 return mParentCount;
 else
 return parentMeshSets.ptr[1] - parentMeshSets.ptr[0];
}
 
inline ErrorCode MeshSet::clear( EntityHandle myhandle, AEntityFactory* adjacencies )
{
 if( tracking() ) remove_adjacencies( myhandle, adjacencies );
 if( mContentCount == MANY ) free( contentList.ptr[0] );
 mContentCount = ZERO;
 return MB_SUCCESS;
}
 
inline ErrorCode MeshSet::clear_all( EntityHandle myhandle, AEntityFactory* adjacencies )
{
 ErrorCode rval = clear( myhandle, adjacencies );
 if( mChildCount == MANY ) free( childMeshSets.ptr[0] );
 mChildCount = ZERO;
 if( mParentCount == MANY ) free( parentMeshSets.ptr[0] );
 mParentCount = ZERO;
 return rval;
}
 
inline const EntityHandle* MeshSet::get_contents( size_t& count_out ) const
{
 if( mContentCount == MANY )
 {
 count_out = contentList.ptr[1] - contentList.ptr[0];
 return contentList.ptr[0];
 }
 else
 {
 count_out = mContentCount;
 return contentList.hnd;
 }
}
 
inline EntityHandle* MeshSet::get_contents( size_t& count_out )
{
 if( mContentCount == MANY )
 {
 count_out = contentList.ptr[1] - contentList.ptr[0];
 return contentList.ptr[0];
 }
 else
 {
 count_out = mContentCount;
 return contentList.hnd;
 }
}
 
inline ErrorCode MeshSet::get_entities( std::vector< EntityHandle >& entities ) const
{
 size_t count;
 const EntityHandle* ptr = get_contents( count );
 if( vector_based() )
 {
 size_t old_size = entities.size();
 entities.resize( count + old_size );
 std::copy( ptr, ptr + count, entities.begin() + old_size );
 }
 else
 {
 assert( count % 2 == 0 );
 for( size_t i = 0; i < count; i += 2 )
 std::copy( hdl_iter( ptr[i] ), hdl_iter( ptr[i + 1] + 1 ), std::back_inserter( entities ) );
 }
 return MB_SUCCESS;
}
 
inline ErrorCode MeshSet::get_entities( Range& entities ) const
{
 size_t count;
 const EntityHandle* ptr = get_contents( count );
 if( vector_based() )
 {
 std::copy( ptr, ptr + count, range_inserter( entities ) );
 }
 else
 {
 assert( count % 2 == 0 );
 Range::iterator in = entities.begin();
 for( size_t i = 0; i < count; i += 2 )
 in = entities.insert( in, ptr[i], ptr[i + 1] );
 }
 return MB_SUCCESS;
}
 
//! get all entities in this MeshSet with the specified type
inline ErrorCode MeshSet::get_entities_by_type( EntityType type, std::vector< EntityHandle >& entity_list ) const
{
 size_t count;
 const EntityHandle* ptr = get_contents( count );
 if( MBMAXTYPE == type )
 {
 return get_entities( entity_list );
 }
 else if( vector_based() )
 {
 std::remove_copy_if( ptr, ptr + count, std::back_inserter( entity_list ), not_type_test( type ) );
 }
 else
 {
 size_t idx = std::lower_bound( ptr, ptr + count, FIRST_HANDLE( type ) ) - ptr;
 if( idx < count && TYPE_FROM_HANDLE( ptr[idx] ) == type )
 {
 if( idx % 2 )
 { // only part of first block is of type
 std::copy( hdl_iter( FIRST_HANDLE( type ) ), hdl_iter( ptr[idx] + 1 ),
 std::back_inserter( entity_list ) );
 ++idx;
 }
 for( ; idx < count; idx += 2 )
 {
 if( TYPE_FROM_HANDLE( ptr[idx + 1] ) == type ) // whole block is of type
 std::copy( hdl_iter( ptr[idx] ), hdl_iter( ptr[idx + 1] + 1 ), std::back_inserter( entity_list ) );
 else
 {
 if( TYPE_FROM_HANDLE( ptr[idx] ) == type ) // part of last block is of type
 std::copy( hdl_iter( ptr[idx] ), hdl_iter( LAST_HANDLE( type ) ),
 std::back_inserter( entity_list ) );
 break;
 }
 }
 }
 }
 
 return MB_SUCCESS;
}
 
inline ErrorCode MeshSet::get_entities_by_type( EntityType type, Range& entity_list ) const
{
 size_t count;
 const EntityHandle* ptr = get_contents( count );
 if( MBMAXTYPE == type )
 {
 return get_entities( entity_list );
 }
 else if( vector_based() )
 {
 std::remove_copy_if( ptr, ptr + count, range_inserter( entity_list ), not_type_test( type ) );
 }
 else
 {
 size_t idx = std::lower_bound( ptr, ptr + count, FIRST_HANDLE( type ) ) - ptr;
 Range::iterator in = entity_list.begin();
 if( idx < count && TYPE_FROM_HANDLE( ptr[idx] ) == type )
 {
 if( idx % 2 )
 { // only part of first block is of type
 in = entity_list.insert( in, FIRST_HANDLE( type ), ptr[idx] );
 ++idx;
 }
 for( ; idx < count; idx += 2 )
 {
 if( TYPE_FROM_HANDLE( ptr[idx + 1] ) == type ) // whole block is of type
 in = entity_list.insert( in, ptr[idx], ptr[idx + 1] );
 else
 {
 if( TYPE_FROM_HANDLE( ptr[idx] ) == type ) // part of last block is of type
 entity_list.insert( in, ptr[idx], LAST_HANDLE( type ) );
 break;
 }
 }
 }
 }
 
 return MB_SUCCESS;
}
 
//! return the number of entities with the given type contained in this meshset
inline unsigned int MeshSet::num_entities_by_type( EntityType type ) const
{
 unsigned int result;
 size_t count;
 const EntityHandle* ptr = get_contents( count );
 if( MBMAXTYPE == type )
 {
 return num_entities();
 }
 else if( vector_based() )
 {
#ifndef __SUNPRO_CC
 result = std::count_if( ptr, ptr + count, type_test( type ) );
#else
 std::count_if( ptr, ptr + count, type_test( type ), result );
#endif
 }
 else
 {
 result = 0;
 size_t idx = std::lower_bound( ptr, ptr + count, FIRST_HANDLE( type ) ) - ptr;
 if( idx < count && TYPE_FROM_HANDLE( ptr[idx] ) == type )
 {
 if( idx % 2 )
 { // only part of first block is of type
 result += ptr[idx] - FIRST_HANDLE( type ) + 1;
 ++idx;
 }
 for( ; idx < count; idx += 2 )
 {
 if( TYPE_FROM_HANDLE( ptr[idx + 1] ) == type ) // whole block is of type
 result += ptr[idx + 1] - ptr[idx] + 1;
 else
 {
 if( TYPE_FROM_HANDLE( ptr[idx] ) == type ) // part of last block is of type
 result += LAST_HANDLE( type ) - ptr[idx] + 1;
 break;
 }
 }
 }
 }
 
 return result;
}
 
inline ErrorCode MeshSet::get_entities_by_dimension( int dimension, std::vector< EntityHandle >& entity_list ) const
{
 size_t count;
 const EntityHandle* ptr = get_contents( count );
 if( vector_based() )
 {
 std::remove_copy_if( ptr, ptr + count, std::back_inserter( entity_list ), not_dim_test( dimension ) );
 }
 else
 {
 size_t idx = std::lower_bound( ptr, ptr + count, FIRST_OF_DIM( dimension ) ) - ptr;
 if( idx < count && DIM_FROM_HANDLE( ptr[idx] ) == dimension )
 {
 if( idx % 2 )
 { // only part of first block is of type
 std::copy( hdl_iter( FIRST_OF_DIM( dimension ) ), hdl_iter( ptr[idx] + 1 ),
 std::back_inserter( entity_list ) );
 ++idx;
 }
 for( ; idx < count; idx += 2 )
 {
 if( DIM_FROM_HANDLE( ptr[idx + 1] ) == dimension ) // whole block is of type
 std::copy( hdl_iter( ptr[idx] ), hdl_iter( ptr[idx + 1] + 1 ), std::back_inserter( entity_list ) );
 else
 {
 if( DIM_FROM_HANDLE( ptr[idx] ) == dimension ) // part of last block is of type
 std::copy( hdl_iter( ptr[idx] ), hdl_iter( LAST_OF_DIM( dimension ) ),
 std::back_inserter( entity_list ) );
 break;
 }
 }
 }
 }
 
 return MB_SUCCESS;
}
 
inline ErrorCode MeshSet::get_entities_by_dimension( int dimension, Range& entity_list ) const
{
 size_t count;
 const EntityHandle* ptr = get_contents( count );
 if( vector_based() )
 {
 std::remove_copy_if( ptr, ptr + count, range_inserter( entity_list ), not_dim_test( dimension ) );
 }
 else
 {
 size_t idx = std::lower_bound( ptr, ptr + count, FIRST_OF_DIM( dimension ) ) - ptr;
 Range::iterator in = entity_list.begin();
 if( idx < count && DIM_FROM_HANDLE( ptr[idx] ) == dimension )
 {
 if( idx % 2 )
 { // only part of first block is of type
 in = entity_list.insert( in, FIRST_OF_DIM( dimension ), ptr[idx] );
 ++idx;
 }
 for( ; idx < count; idx += 2 )
 {
 if( DIM_FROM_HANDLE( ptr[idx + 1] ) == dimension ) // whole block is of type
 in = entity_list.insert( in, ptr[idx], ptr[idx + 1] );
 else
 {
 if( DIM_FROM_HANDLE( ptr[idx] ) == dimension ) // part of last block is of type
 entity_list.insert( in, ptr[idx], LAST_OF_DIM( dimension ) );
 break;
 }
 }
 }
 }
 
 return MB_SUCCESS;
}
 
//! return the number of entities with the given type contained in this meshset
inline unsigned int MeshSet::num_entities_by_dimension( int dimension ) const
{
 unsigned int result;
 size_t count;
 const EntityHandle* ptr = get_contents( count );
 if( vector_based() )
 {
#ifndef __SUNPRO_CC
 result = std::count_if( ptr, ptr + count, dim_test( dimension ) );
#else
 std::count_if( ptr, ptr + count, dim_test( dimension ), result );
#endif
 }
 else
 {
 result = 0;
 size_t idx = std::lower_bound( ptr, ptr + count, FIRST_OF_DIM( dimension ) ) - ptr;
 if( idx < count && DIM_FROM_HANDLE( ptr[idx] ) == dimension )
 {
 if( idx % 2 )
 { // only part of first block is of type
 result += ptr[idx] - FIRST_OF_DIM( dimension ) + 1;
 ++idx;
 }
 for( ; idx < count; idx += 2 )
 {
 if( DIM_FROM_HANDLE( ptr[idx + 1] ) == dimension ) // whole block is of type
 result += ptr[idx + 1] - ptr[idx] + 1;
 else
 {
 if( DIM_FROM_HANDLE( ptr[idx] ) == dimension ) // part of last block is of type
 result += LAST_OF_DIM( dimension ) - ptr[idx] + 1;
 break;
 }
 }
 }
 }
 
 return result;
}
 
inline ErrorCode MeshSet::get_non_set_entities( Range& range ) const
{
 size_t count;
 const EntityHandle* ptr = get_contents( count );
 if( vector_based() )
 {
 std::remove_copy_if( ptr, ptr + count, range_inserter( range ), type_test( MBENTITYSET ) );
 }
 else
 {
 Range::iterator in = range.begin();
 for( size_t idx = 0; idx < count; idx += 2 )
 {
 if( TYPE_FROM_HANDLE( ptr[idx + 1] ) != MBENTITYSET )
 in = range.insert( in, ptr[idx], ptr[idx + 1] );
 else
 {
 if( TYPE_FROM_HANDLE( ptr[idx] ) != MBENTITYSET )
 in = range.insert( in, ptr[idx], LAST_HANDLE( MBENTITYSET - 1 ) );
 break;
 }
 }
 }
 
 return MB_SUCCESS;
}
 
inline bool MeshSet::contains_entities( const EntityHandle* entities, int num_ents, const int op ) const
{
 size_t count;
 const EntityHandle* const ptr = get_contents( count );
 const EntityHandle* const end = ptr + count;
 size_t found_count = 0;
 if( vector_based() )
 {
 for( int i = 0; i < num_ents; ++i )
 if( std::find( ptr, end, entities[i] ) < end ) ++found_count;
 }
 else
 {
 assert( 0 == count % 2 );
 for( int i = 0; i < num_ents; ++i )
 {
 const unsigned long idx = std::lower_bound( ptr, end, entities[i] ) - ptr;
 if( idx < count && ( idx % 2 != 0 || ptr[idx] == entities[i] ) ) ++found_count;
 }
 }
 
 return found_count >= ( ( Interface::INTERSECT == op ) ? (unsigned)num_ents : 1u );
}
 
//! subtract/intersect/unite meshset_2 from/with/into meshset_1; modifies meshset_1
inline ErrorCode MeshSet::subtract( const MeshSet* meshset_2, EntityHandle my_handle, AEntityFactory* adjacencies )
{
 size_t count;
 const EntityHandle* const ptr = meshset_2->get_contents( count );
 if( meshset_2->vector_based() )
 return remove_entity_vector( ptr, count, my_handle, adjacencies );
 else
 return remove_entity_ranges( ptr, count, my_handle, adjacencies );
}
 
inline ErrorCode MeshSet::unite( const MeshSet* meshset_2, EntityHandle my_handle, AEntityFactory* adjacencies )
{
 size_t count;
 const EntityHandle* const ptr = meshset_2->get_contents( count );
 if( meshset_2->vector_based() )
 return insert_entity_vector( ptr, count, my_handle, adjacencies );
 else
 return insert_entity_ranges( ptr, count, my_handle, adjacencies );
}
 
//! add these entities to this meshset
inline ErrorCode MeshSet::add_entities( const EntityHandle* entity_handles,
 const int num_ents,
 EntityHandle my_handle,
 AEntityFactory* adjacencies )
{
 return insert_entity_vector( entity_handles, num_ents, my_handle, adjacencies );
}
 
//! add these entities to this meshset
inline ErrorCode MeshSet::add_entities( const Range& entities, EntityHandle my_handle, AEntityFactory* adjacencies )
{
 return insert_entity_ranges( entities, my_handle, adjacencies );
}
 
//! add these entities to this meshset
inline ErrorCode MeshSet::remove_entities( const Range& entities, EntityHandle my_handle, AEntityFactory* adjacencies )
{
 return remove_entity_ranges( entities, my_handle, adjacencies );
}
 
//! remove these entities from this meshset
inline ErrorCode MeshSet::remove_entities( const EntityHandle* entities,
 const int num_ents,
 EntityHandle my_handle,
 AEntityFactory* adjacencies )
{
 return remove_entity_vector( entities, num_ents, my_handle, adjacencies );
}
 
//! return the number of entities contained in this meshset
unsigned int MeshSet::num_entities() const
{
 size_t count;
 const EntityHandle* list = get_contents( count );
 if( vector_based() ) return count;
 
 int result = 0;
 const EntityHandle* const end = list + count;
 for( ; list < end; list += 2 )
 result += list[1] - list[0] + 1;
 return result;
}
 
} // namespace moab
 
#endif