SetIterator.cpp

Go to the documentation of this file.

#ifndef IS_BUILDING_MB
#error "SetIterator.hpp isn't supposed to be included into an application"
#endif
 
#include "moab/SetIterator.hpp"
#include "moab/Core.hpp"
#include "moab/WriteUtilIface.hpp"
#include "MeshSet.hpp"
#include "Internals.hpp"
#include "moab/CN.hpp"
#include "moab/Error.hpp"
 
namespace moab
{
 
SetIterator::~SetIterator()
{
 myCore->remove_set_iterator( this );
}
 
RangeSetIterator::RangeSetIterator( Core* core,
 EntityHandle eset,
 int chunk_sz,
 EntityType ent_tp,
 int ent_dim,
 bool check_valid )
 : SetIterator( core, eset, chunk_sz, ent_tp, ent_dim, check_valid ), iterPos( 0 ), pairPtr( NULL ), numPairs( 0 )
{
 if( !eset )
 {
 // special case for the root set, have to keep a local array
 ErrorCode rval = build_pair_vec();
 assert( MB_SUCCESS == rval );
 
 // empty statement to avoid warning
 (void)( rval );
 }
}
 
RangeSetIterator::~RangeSetIterator()
{
 if( pairPtr ) delete[] pairPtr;
 numPairs = 0;
}
 
ErrorCode RangeSetIterator::build_pair_vec()
{
 // shouldn't be here unless we're iterating the root set
 assert( !entSet );
 
 Range all_ents;
 ErrorCode rval = myCore->get_entities_by_handle( 0, all_ents );
 if( MB_SUCCESS != rval ) return rval;
 
 if( pairPtr ) delete[] pairPtr;
 pairPtr = new EntityHandle[2 * all_ents.psize()];
 Range::const_pair_iterator pi;
 int i;
 for( pi = all_ents.const_pair_begin(), i = 0; pi != all_ents.const_pair_end(); ++pi, i += 2 )
 {
 pairPtr[i] = ( *pi ).first;
 pairPtr[i + 1] = ( *pi ).second;
 }
 numPairs = all_ents.psize();
 
 return MB_SUCCESS;
}
 
ErrorCode RangeSetIterator::get_next_arr( std::vector< EntityHandle >& arr, bool& atend )
{
 atend = false;
 
 int count;
 const EntityHandle* ptr;
 WriteUtilIface* iface;
 std::vector< EntityHandle > tmp_arr;
 std::vector< EntityHandle >* tmp_ptr = &arr;
 if( checkValid ) tmp_ptr = &tmp_arr;
 ErrorCode rval;
 if( !pairPtr )
 {
 Interface* mbImpl = dynamic_cast< Interface* >( myCore );
 rval = mbImpl->query_interface( iface );
 if( MB_SUCCESS != rval ) return rval;
 
 rval = iface->get_entity_list_pointers( &entSet, 1, &ptr, WriteUtilIface::CONTENTS, &count );
 if( MB_SUCCESS != rval ) return rval;
 mbImpl->release_interface( iface );
 }
 else
 {
 if( checkValid )
 {
 rval = build_pair_vec();
 if( MB_SUCCESS != rval ) return rval;
 }
 ptr = pairPtr;
 count = 2 * numPairs;
 }
 assert( !( count % 2 ) );
 if( !count )
 {
 atend = true;
 return MB_SUCCESS;
 }
 
 if( -1 == entDimension )
 rval = get_next_by_type( ptr, count, *tmp_ptr, atend );
 else
 rval = get_next_by_dimension( ptr, count, *tmp_ptr, atend );
 if( MB_SUCCESS != rval ) return rval;
 
 if( checkValid )
 {
 for( std::vector< EntityHandle >::iterator vit = tmp_ptr->begin(); vit != tmp_ptr->end(); ++vit )
 {
 if( myCore->is_valid( *vit ) ) arr.push_back( *vit );
 }
 }
 
 return MB_SUCCESS;
}
 
ErrorCode RangeSetIterator::get_next_by_type( const EntityHandle*& ptr,
 int count,
 std::vector< EntityHandle >& arr,
 bool& atend )
{
 unsigned int num_ret = 0;
 bool max_type = ( entType == MBMAXTYPE );
 size_t idx = 0;
 // initialize to first relevant handle
 while( (int)idx < count &&
 ( iterPos > ptr[idx + 1] ||
 ( !max_type && !iterPos && CREATE_HANDLE( entType, ID_FROM_HANDLE( iterPos ) ) > ptr[idx + 1] ) ) )
 idx += 2;
 if( (int)idx == count || TYPE_FROM_HANDLE( ptr[idx] ) > entType )
 {
 atend = true;
 return MB_SUCCESS;
 }
 if( !iterPos && max_type )
 iterPos = ptr[idx];
 else if( !iterPos && TYPE_FROM_HANDLE( ptr[idx] ) <= entType && TYPE_FROM_HANDLE( ptr[idx + 1] ) >= entType )
 {
 iterPos = std::max( CREATE_HANDLE( entType, 1 ), ptr[idx] );
 }
 
 // idx points to start of subrange, iterPos in that subrange
 do
 {
 EntityHandle next = ptr[idx + 1];
 if( TYPE_FROM_HANDLE( next ) != entType && !max_type ) next = LAST_HANDLE( entType );
 unsigned int this_ret = chunkSize - num_ret;
 unsigned int to_end = next - iterPos + 1;
 if( to_end < this_ret ) this_ret = to_end;
 std::copy( MeshSet::hdl_iter( iterPos ), MeshSet::hdl_iter( iterPos + this_ret ), std::back_inserter( arr ) );
 if( this_ret == to_end )
 {
 idx += 2;
 iterPos = ( (int)idx < count ? ptr[idx] : 0 );
 }
 else
 iterPos += this_ret;
 
 num_ret += this_ret;
 } while( (int)idx < count && num_ret < chunkSize && iterPos &&
 ( max_type || TYPE_FROM_HANDLE( iterPos ) == entType ) );
 
 if( !iterPos || ( !max_type && TYPE_FROM_HANDLE( iterPos ) != entType ) ) atend = true;
 
 return MB_SUCCESS;
}
 
ErrorCode RangeSetIterator::get_next_by_dimension( const EntityHandle*& ptr,
 int count,
 std::vector< EntityHandle >& arr,
 bool& atend )
{
 // iterating by dimension - type should be maxtype
 if( entType != MBMAXTYPE )
 {
 MB_SET_ERR( MB_FAILURE, "Both dimension and type should not be set on an iterator" );
 }
 
 unsigned int num_ret = 0;
 size_t idx = 0;
 // initialize to first relevant handle
 while( (int)idx < count && ( iterPos > ptr[idx + 1] ||
 ( !iterPos && entDimension > CN::Dimension( TYPE_FROM_HANDLE( ptr[idx + 1] ) ) ) ) )
 idx += 2;
 if( (int)idx == count || CN::Dimension( TYPE_FROM_HANDLE( ptr[idx] ) ) > entDimension )
 {
 atend = true;
 return MB_SUCCESS;
 }
 if( !iterPos )
 iterPos = ptr[idx];
 else if( CN::Dimension( TYPE_FROM_HANDLE( ptr[idx] ) ) < entDimension )
 iterPos = CREATE_HANDLE( CN::TypeDimensionMap[entDimension].first, 1 );
 
 // idx points to start of subrange, iterPos in that subrange
 do
 {
 EntityHandle next = ptr[idx + 1];
 if( CN::Dimension( TYPE_FROM_HANDLE( next ) ) != entDimension )
 next = LAST_HANDLE( CN::TypeDimensionMap[entDimension].second );
 unsigned int this_ret = chunkSize - num_ret;
 unsigned int to_end = next - iterPos + 1;
 if( to_end < this_ret ) this_ret = to_end;
 std::copy( MeshSet::hdl_iter( iterPos ), MeshSet::hdl_iter( iterPos + this_ret ), std::back_inserter( arr ) );
 if( this_ret == to_end )
 {
 idx += 2;
 iterPos = ( (int)idx < count ? ptr[idx] : 0 );
 }
 else
 iterPos += this_ret;
 
 num_ret += this_ret;
 } while( (int)idx < count && num_ret < chunkSize && iterPos &&
 CN::Dimension( TYPE_FROM_HANDLE( iterPos ) ) == entDimension );
 
 if( !iterPos || CN::Dimension( TYPE_FROM_HANDLE( iterPos ) ) != entDimension ) atend = true;
 
 return MB_SUCCESS;
}
 
ErrorCode RangeSetIterator::reset()
{
 iterPos = 0;
 return MB_SUCCESS;
}
 
ErrorCode VectorSetIterator::get_next_arr( std::vector< EntityHandle >& arr, bool& atend )
{
 int count;
 const EntityHandle* ptr;
 WriteUtilIface* iface;
 Interface* mbImpl = dynamic_cast< Interface* >( myCore );
 ErrorCode rval = mbImpl->query_interface( iface );
 if( MB_SUCCESS != rval ) return rval;
 
 rval = iface->get_entity_list_pointers( &entSet, 1, &ptr, WriteUtilIface::CONTENTS, &count );
 if( MB_SUCCESS != rval ) return rval;
 mbImpl->release_interface( iface );
 
 if( !count || iterPos >= count )
 {
 atend = true;
 return MB_SUCCESS;
 }
 
 std::vector< EntityHandle > tmp_arr;
 std::vector< EntityHandle >* tmp_ptr = &arr;
 if( checkValid ) tmp_ptr = &tmp_arr;
 
 // just get the next chunkSize entities, or as many as you can
 int this_ct = 0;
 while( this_ct < (int)chunkSize && iterPos < count )
 {
 if( ( MBMAXTYPE == entType || TYPE_FROM_HANDLE( ptr[iterPos] ) == entType ) &&
 ( -1 == entDimension || CN::Dimension( TYPE_FROM_HANDLE( ptr[iterPos] ) ) == entDimension ) )
 {
 arr.push_back( ptr[iterPos] );
 this_ct++;
 }
 iterPos++;
 }
 
 atend = ( iterPos == count );
 
 if( checkValid )
 {
 for( std::vector< EntityHandle >::iterator vit = tmp_ptr->begin(); vit != tmp_ptr->end(); ++vit )
 {
 if( myCore->is_valid( *vit ) ) arr.push_back( *vit );
 }
 }
 
 // step along list, adding entities
 return MB_SUCCESS;
}
 
ErrorCode VectorSetIterator::reset()
{
 iterPos = 0;
 return MB_SUCCESS;
}
 
} // namespace moab