SequenceManager.cpp

Go to the documentation of this file.

#include "SequenceManager.hpp"
#include "VertexSequence.hpp"
#include "UnstructuredElemSeq.hpp"
#include "ScdVertexData.hpp"
#include "MeshSetSequence.hpp"
#include "SweptElementSeq.hpp"
#include "StructuredElementSeq.hpp"
#include "moab/HomXform.hpp"
#include "PolyElementSeq.hpp"
#include "SysUtil.hpp"
#include "moab/Error.hpp"
 
#include <cassert>
#include <new>
#include <algorithm>
 
#ifndef NDEBUG
#include <iostream>
#endif
 
namespace moab
{
 
const EntityID SequenceManager::DEFAULT_VERTEX_SEQUENCE_SIZE = 16 * 1024;
const EntityID SequenceManager::DEFAULT_ELEMENT_SEQUENCE_SIZE = DEFAULT_VERTEX_SEQUENCE_SIZE;
const EntityID SequenceManager::DEFAULT_POLY_SEQUENCE_SIZE = 16 * 1024;
const EntityID SequenceManager::DEFAULT_MESHSET_SEQUENCE_SIZE = DEFAULT_VERTEX_SEQUENCE_SIZE;
 
const int UNUSED_SIZE = 0;
 
EntityID SequenceManager::default_poly_sequence_size( int conn_len )
{
 return std::max( DEFAULT_POLY_SEQUENCE_SIZE / conn_len, (EntityID)1 );
}
 
SequenceManager::~SequenceManager()
{
 // Release variable-length tag data
 for( unsigned i = 0; i < tagSizes.size(); ++i )
 if( tagSizes[i] == MB_VARIABLE_LENGTH ) release_tag_array( 0, i, false );
}
 
void SequenceManager::clear()
{
 // reset sequence multiplier
 sequence_multiplier = 1.0;
 
 // Destroy all TypeSequenceManager instances
 for( EntityType t = MBVERTEX; t < MBMAXTYPE; ++t )
 typeData[t].~TypeSequenceManager();
 
 // Now re-create TypeSequenceManager instances
 for( EntityType t = MBVERTEX; t < MBMAXTYPE; ++t )
 new( typeData + t ) TypeSequenceManager();
}
 
void SequenceManager::get_entities( Range& entities_out ) const
{
 for( EntityType t = MBENTITYSET; t >= MBVERTEX; --t )
 typeData[t].get_entities( entities_out );
}
 
void SequenceManager::get_entities( std::vector< EntityHandle >& entities_out ) const
{
 for( EntityType t = MBVERTEX; t != MBMAXTYPE; ++t )
 typeData[t].get_entities( entities_out );
}
 
EntityID SequenceManager::get_number_entities() const
{
 EntityID sum = 0;
 for( EntityType t = MBVERTEX; t != MBMAXTYPE; ++t )
 sum += typeData[t].get_number_entities();
 
 return sum;
}
 
ErrorCode SequenceManager::check_valid_entities( Error* /* error */, const Range& entities ) const
{
 ErrorCode rval;
 Range::const_pair_iterator i;
 for( i = entities.const_pair_begin(); i != entities.const_pair_end(); ++i )
 {
 const EntityType type1 = TYPE_FROM_HANDLE( i->first );
 const EntityType type2 = TYPE_FROM_HANDLE( i->second );
 if( type1 == type2 )
 {
 rval = typeData[type1].check_valid_handles( NULL, i->first, i->second );
 if( MB_SUCCESS != rval ) return rval;
 }
 else
 {
 int junk;
 EntityHandle split = CREATE_HANDLE( type2, 0, junk );
 rval = typeData[type1].check_valid_handles( NULL, i->first, split - 1 );
 if( MB_SUCCESS != rval ) return rval;
 rval = typeData[type2].check_valid_handles( NULL, split, i->second );
 if( MB_SUCCESS != rval ) return rval;
 }
 }
 
 return MB_SUCCESS;
}
 
ErrorCode SequenceManager::check_valid_entities( Error* /* error_handler */,
 const EntityHandle* entities,
 size_t num_entities,
 bool root_set_okay ) const
{
 ErrorCode rval;
 const EntitySequence* ptr = 0;
 
 const EntityHandle* const end = entities + num_entities;
 for( ; entities < end; ++entities )
 {
 rval = find( *entities, ptr );
 if( MB_SUCCESS != rval && !( root_set_okay && !*entities ) )
 {
 if( MB_ENTITY_NOT_FOUND == rval )
 {
 // MB_ENTITY_NOT_FOUND could be a non-error condition, do not call MB_SET_ERR on it
#if 0
 fprintf(stderr, "[Warning]: Invalid entity handle: 0x%lx\n", (unsigned long)*entities);
#endif
 }
 return rval;
 }
 }
 
 return MB_SUCCESS;
}
 
ErrorCode SequenceManager::delete_entity( Error* /* error */, EntityHandle entity )
{
 return typeData[TYPE_FROM_HANDLE( entity )].erase( NULL, entity );
}
 
ErrorCode SequenceManager::delete_entities( Error* /* error */, const Range& entities )
{
 ErrorCode rval = check_valid_entities( NULL, entities );
 if( MB_SUCCESS != rval ) return rval;
 
 ErrorCode result = MB_SUCCESS;
 Range::const_pair_iterator i;
 for( i = entities.const_pair_begin(); i != entities.const_pair_end(); ++i )
 {
 const EntityType type1 = TYPE_FROM_HANDLE( i->first );
 const EntityType type2 = TYPE_FROM_HANDLE( i->second );
 if( type1 == type2 )
 {
 rval = typeData[type1].erase( NULL, i->first, i->second );
 if( MB_SUCCESS != rval ) return result = rval;
 }
 else
 {
 int junk;
 EntityHandle split = CREATE_HANDLE( type2, 0, junk );
 rval = typeData[type1].erase( NULL, i->first, split - 1 );
 if( MB_SUCCESS != rval ) return result = rval;
 rval = typeData[type2].erase( NULL, split, i->second );
 if( MB_SUCCESS != rval ) return result = rval;
 }
 }
 
 return result;
}
 
ErrorCode SequenceManager::create_vertex( const double coords[3], EntityHandle& handle )
{
 const EntityHandle start = CREATE_HANDLE( MBVERTEX, MB_START_ID );
 const EntityHandle end = CREATE_HANDLE( MBVERTEX, MB_END_ID );
 bool append;
 TypeSequenceManager::iterator seq = typeData[MBVERTEX].find_free_handle( start, end, append );
 VertexSequence* vseq;
 
 if( seq == typeData[MBVERTEX].end() )
 {
 SequenceData* seq_data = 0;
 EntityID seq_data_size = 0;
 handle =
 typeData[MBVERTEX].find_free_sequence( DEFAULT_VERTEX_SEQUENCE_SIZE, start, end, seq_data, seq_data_size );
 if( !handle ) return MB_FAILURE;
 
 if( seq_data )
 vseq = new VertexSequence( handle, 1, seq_data );
 else
 vseq = new VertexSequence( handle, 1, DEFAULT_VERTEX_SEQUENCE_SIZE );
 
 ErrorCode rval = typeData[MBVERTEX].insert_sequence( vseq );
 if( MB_SUCCESS != rval )
 {
 SequenceData* vdata = vseq->data();
 delete vseq;
 if( !seq_data ) delete vdata;
 
 return rval;
 }
 }
 else
 {
 vseq = reinterpret_cast< VertexSequence* >( *seq );
 if( append )
 {
 vseq->push_back( 1 );
 handle = vseq->end_handle();
 typeData[MBVERTEX].notify_appended( seq );
 }
 else
 {
 vseq->push_front( 1 );
 handle = vseq->start_handle();
 typeData[MBVERTEX].notify_prepended( seq );
 }
 }
 
 return vseq->set_coordinates( handle, coords );
}
 
ErrorCode SequenceManager::create_element( EntityType type,
 const EntityHandle* conn,
 unsigned conn_len,
 EntityHandle& handle )
{
 if( type <= MBVERTEX || type >= MBENTITYSET ) return MB_TYPE_OUT_OF_RANGE;
 
 const EntityHandle start = CREATE_HANDLE( type, MB_START_ID );
 const EntityHandle end = CREATE_HANDLE( type, MB_END_ID );
 bool append;
 TypeSequenceManager::iterator seq = typeData[type].find_free_handle( start, end, append, conn_len );
 UnstructuredElemSeq* eseq;
 
 if( seq == typeData[type].end() )
 {
 SequenceData* seq_data = 0;
 unsigned size = DEFAULT_ELEMENT_SEQUENCE_SIZE;
 if( type == MBPOLYGON || type == MBPOLYHEDRON )
 {
 size = default_poly_sequence_size( conn_len );
 }
 EntityID seq_data_size = 0;
 handle = typeData[type].find_free_sequence( size, start, end, seq_data, seq_data_size, conn_len );
 if( !handle ) return MB_FAILURE;
 
 if( MBPOLYGON == type || MBPOLYHEDRON == type )
 {
 if( seq_data )
 eseq = new PolyElementSeq( handle, 1, conn_len, seq_data );
 else
 eseq = new PolyElementSeq( handle, 1, conn_len, size );
 }
 else
 {
 if( seq_data )
 eseq = new UnstructuredElemSeq( handle, 1, conn_len, seq_data );
 else
 eseq = new UnstructuredElemSeq( handle, 1, conn_len, size );
 }
 
 ErrorCode rval = typeData[type].insert_sequence( eseq );
 if( MB_SUCCESS != rval )
 {
 SequenceData* vdata = eseq->data();
 delete eseq;
 if( !seq_data ) delete vdata;
 
 return rval;
 }
 }
 else
 {
 eseq = reinterpret_cast< UnstructuredElemSeq* >( *seq );
 if( append )
 {
 eseq->push_back( 1 );
 handle = eseq->end_handle();
 typeData[type].notify_appended( seq );
 }
 else
 {
 eseq->push_front( 1 );
 handle = eseq->start_handle();
 typeData[type].notify_prepended( seq );
 }
 }
 
 return eseq->set_connectivity( handle, conn, conn_len );
}
 
ErrorCode SequenceManager::create_mesh_set( unsigned flags, EntityHandle& handle )
{
 const EntityHandle start = CREATE_HANDLE( MBENTITYSET, MB_START_ID );
 const EntityHandle end = CREATE_HANDLE( MBENTITYSET, MB_END_ID );
 bool append;
 TypeSequenceManager::iterator seq = typeData[MBENTITYSET].find_free_handle( start, end, append );
 MeshSetSequence* msseq;
 
 if( seq == typeData[MBENTITYSET].end() )
 {
 SequenceData* seq_data = 0;
 EntityID seq_data_size = 0;
 handle = typeData[MBENTITYSET].find_free_sequence( DEFAULT_MESHSET_SEQUENCE_SIZE, start, end, seq_data,
 seq_data_size );
 if( !handle ) return MB_FAILURE;
 
 if( seq_data )
 msseq = new MeshSetSequence( handle, 1, flags, seq_data );
 else
 msseq = new MeshSetSequence( handle, 1, flags, DEFAULT_MESHSET_SEQUENCE_SIZE );
 
 ErrorCode rval = typeData[MBENTITYSET].insert_sequence( msseq );
 if( MB_SUCCESS != rval )
 {
 SequenceData* vdata = msseq->data();
 delete msseq;
 if( !seq_data ) delete vdata;
 
 return rval;
 }
 }
 else
 {
 msseq = reinterpret_cast< MeshSetSequence* >( *seq );
 if( append )
 {
 msseq->push_back( 1, &flags );
 handle = msseq->end_handle();
 typeData[MBENTITYSET].notify_appended( seq );
 }
 else
 {
 msseq->push_front( 1, &flags );
 handle = msseq->start_handle();
 typeData[MBENTITYSET].notify_prepended( seq );
 }
 }
 
 return MB_SUCCESS;
}
 
ErrorCode SequenceManager::allocate_mesh_set( EntityHandle handle, unsigned flags )
{
 SequenceData* data = 0;
 TypeSequenceManager::iterator seqptr;
 EntityHandle block_start = 1, block_end = 0;
 ErrorCode rval = typeData[MBENTITYSET].is_free_handle( handle, seqptr, data, block_start, block_end );
 if( MB_SUCCESS != rval ) return rval;
 
 MeshSetSequence* seq;
 if( seqptr != typeData[MBENTITYSET].end() )
 {
 seq = static_cast< MeshSetSequence* >( *seqptr );
 if( seq->start_handle() - 1 == handle )
 {
 rval = seq->push_front( 1, &flags );
 if( MB_SUCCESS == rval )
 {
 rval = typeData[MBENTITYSET].notify_prepended( seqptr );
 if( MB_SUCCESS != rval ) seq->pop_front( 1 );
 }
 return rval;
 }
 else if( seq->end_handle() + 1 == handle )
 {
 rval = seq->push_back( 1, &flags );
 if( MB_SUCCESS == rval )
 {
 rval = typeData[MBENTITYSET].notify_appended( seqptr );
 if( MB_SUCCESS != rval ) seq->pop_back( 1 );
 }
 return rval;
 }
 else
 return MB_FAILURE; // Should be unreachable
 }
 else
 {
 if( data )
 {
 seq = new MeshSetSequence( handle, 1, flags, data );
 }
 else
 {
 assert( handle >= block_start && handle <= block_end );
 trim_sequence_block( handle, block_end, DEFAULT_MESHSET_SEQUENCE_SIZE );
 seq = new MeshSetSequence( handle, 1, flags, block_end - handle + 1 );
 }
 
 rval = typeData[MBENTITYSET].insert_sequence( seq );
 if( MB_SUCCESS != rval )
 {
 SequenceData* vdata = seq->data();
 delete seq;
 if( !data ) delete vdata;
 return rval;
 }
 
 return MB_SUCCESS;
 }
}
 
void SequenceManager::trim_sequence_block( EntityHandle start_handle, EntityHandle& end_handle, unsigned max_size )
{
 assert( end_handle >= start_handle );
 assert( (int)max_size > 0 ); // Cast to int also prohibits some ridiculously large values
 
 // If input range is larger than preferred size, trim it
 if( end_handle - start_handle >= max_size ) end_handle = start_handle + max_size - 1;
}
 
EntityHandle SequenceManager::sequence_start_handle( EntityType type,
 EntityID count,
 int size,
 EntityID start,
 SequenceData*& data,
 EntityID& data_size )
{
 TypeSequenceManager& tsm = typeData[type];
 data = 0;
 EntityHandle handle = CREATE_HANDLE( type, start );
 if( start < MB_START_ID || !tsm.is_free_sequence( handle, count, data, size ) )
 {
 EntityHandle pstart = CREATE_HANDLE( type, MB_START_ID );
 EntityHandle pend = CREATE_HANDLE( type, MB_END_ID );
 handle = tsm.find_free_sequence( count, pstart, pend, data, data_size, size );
 }
 
 return handle;
}
 
EntityID SequenceManager::new_sequence_size( EntityHandle start, EntityID requested_size, int sequence_size ) const
{
 
 requested_size = (EntityID)( this->sequence_multiplier * requested_size );
 
 if( sequence_size < (int)requested_size ) return requested_size;
 
 EntityHandle last = typeData[TYPE_FROM_HANDLE( start )].last_free_handle( start );
 if( !last )
 {
 assert( false );
 return 0;
 }
 
 EntityID available_size = last - start + 1;
 if( sequence_size < available_size )
 return sequence_size;
 else
 return available_size;
}
 
ErrorCode SequenceManager::create_entity_sequence( EntityType type,
 EntityID count,
 int size,
 EntityID start,
 EntityHandle& handle,
 EntitySequence*& sequence,
 int sequence_size )
{
 SequenceData* data = NULL;
 EntityID data_size = 0;
 handle = sequence_start_handle( type, count, size, start, data, data_size );
 
 if( !handle ) return MB_MEMORY_ALLOCATION_FAILED;
 
 switch( type )
 {
 case MBENTITYSET:
 case MBMAXTYPE:
 return MB_TYPE_OUT_OF_RANGE;
 
 case MBVERTEX:
 if( size != 0 ) return MB_INDEX_OUT_OF_RANGE;
 
 if( data )
 sequence = new VertexSequence( handle, count, data );
 else
 {
 if( !data_size ) data_size = new_sequence_size( handle, count, sequence_size );
 sequence = new VertexSequence( handle, count, data_size );
 }
 break;
 
 case MBPOLYGON:
 case MBPOLYHEDRON:
 if( size == 0 ) return MB_INDEX_OUT_OF_RANGE;
 
 if( data )
 sequence = new PolyElementSeq( handle, count, size, data );
 else
 {
 if( !data_size )
 data_size = new_sequence_size(
 handle, count, ( -1 == sequence_size ? default_poly_sequence_size( size ) : sequence_size ) );
 sequence = new PolyElementSeq( handle, count, size, data_size );
 }
 break;
 
 default:
 if( size == 0 ) return MB_INDEX_OUT_OF_RANGE;
 
 if( data )
 sequence = new UnstructuredElemSeq( handle, count, size, data );
 else
 {
 if( !data_size ) data_size = new_sequence_size( handle, count, sequence_size );
 sequence = new UnstructuredElemSeq( handle, count, size, data_size );
 }
 // tjt calling new_sequence_size 'cuz don't have a sequence data;
 // start 41467, count 246
 break;
 }
 
 ErrorCode result = typeData[type].insert_sequence( sequence );
 if( MB_SUCCESS != result )
 {
 // Change to NULL if had an existing data or if no existing data,
 // change to the new data created
 data = data ? 0 : sequence->data();
 delete sequence;
 delete data;
 return result;
 }
 
 return MB_SUCCESS;
}
 
ErrorCode SequenceManager::create_meshset_sequence( EntityID count,
 EntityID start,
 const unsigned* flags,
 EntityHandle& handle,
 EntitySequence*& sequence )
{
 SequenceData* data = 0;
 EntityID data_size = 0;
 handle = sequence_start_handle( MBENTITYSET, count, 0, start, data, data_size );
 
 if( !handle ) return MB_MEMORY_ALLOCATION_FAILED;
 
 if( data )
 sequence = new MeshSetSequence( handle, count, flags, data );
 else
 sequence = new MeshSetSequence( handle, count, flags, count );
 
 ErrorCode result = typeData[MBENTITYSET].insert_sequence( sequence );
 if( MB_SUCCESS != result )
 {
 // Change to NULL if had an existing data or if no existing data,
 // change to the new data created
 data = data ? 0 : sequence->data();
 delete sequence;
 delete data;
 return result;
 }
 
 return MB_SUCCESS;
}
 
ErrorCode SequenceManager::create_meshset_sequence( EntityID count,
 EntityID start,
 unsigned flags,
 EntityHandle& handle,
 EntitySequence*& sequence )
{
 SequenceData* data = 0;
 EntityID data_size = 0;
 handle = sequence_start_handle( MBENTITYSET, count, 0, start, data, data_size );
 if( !handle ) return MB_MEMORY_ALLOCATION_FAILED;
 
 if( data )
 sequence = new MeshSetSequence( handle, count, flags, data );
 else
 sequence = new MeshSetSequence( handle, count, flags, count );
 
 ErrorCode result = typeData[MBENTITYSET].insert_sequence( sequence );
 if( MB_SUCCESS != result )
 {
 // Change to NULL if had an existing data or if no existing data,
 // change to the new data created
 data = data ? 0 : sequence->data();
 delete sequence;
 delete data;
 return result;
 }
 
 return MB_SUCCESS;
}
 
ErrorCode SequenceManager::create_scd_sequence( int imin,
 int jmin,
 int kmin,
 int imax,
 int jmax,
 int kmax,
 EntityType type,
 EntityID start_id_hint,
 EntityHandle& handle,
 EntitySequence*& sequence,
 int* is_periodic )
{
 int this_dim = CN::Dimension( type );
 
 // Use > instead of != in the following assert to also catch cases where imin > imax, etc.
 assert( ( this_dim < 3 || kmax > kmin ) && ( this_dim < 2 || jmax > jmin ) && ( this_dim < 1 || imax > imin ) );
 
 // Compute # entities; not as easy as it would appear...
 EntityID num_ent;
 if( MBVERTEX == type )
 num_ent = (EntityID)( imax - imin + 1 ) * (EntityID)( jmax - jmin + 1 ) * (EntityID)( kmax - kmin + 1 );
 else
 {
 num_ent = ( imax - imin + ( is_periodic && is_periodic[0] ? 1 : 0 ) ) *
 ( this_dim >= 2 ? ( jmax - jmin + ( is_periodic && is_periodic[1] ? 1 : 0 ) ) : 1 ) *
 ( this_dim >= 3 ? ( kmax - kmin ) : 1 );
 }
 
 if( MBVERTEX == type && ( is_periodic && ( is_periodic[0] || is_periodic[1] ) ) ) return MB_FAILURE;
 
 // Get a start handle
 SequenceData* data = 0;
 EntityID data_size = 0;
 handle = sequence_start_handle( type, num_ent, -1, start_id_hint, data, data_size );
 
 if( !handle ) return MB_MEMORY_ALLOCATION_FAILED;
 assert( !data );
 
 switch( type )
 {
 case MBVERTEX:
 data = new ScdVertexData( handle, imin, jmin, kmin, imax, jmax, kmax );
 sequence = new VertexSequence( handle, data->size(), data );
 break;
 case MBEDGE:
 case MBQUAD:
 case MBHEX:
 sequence = new StructuredElementSeq( handle, imin, jmin, kmin, imax, jmax, kmax, is_periodic );
 break;
 default:
 return MB_TYPE_OUT_OF_RANGE;
 }
 
 ErrorCode result = typeData[type].insert_sequence( sequence );
 if( MB_SUCCESS != result )
 {
 data = sequence->data();
 delete sequence;
 delete data;
 return result;
 }
 
 return MB_SUCCESS;
}
 
ErrorCode SequenceManager::create_scd_sequence( const HomCoord& coord_min,
 const HomCoord& coord_max,
 EntityType type,
 EntityID start_id_hint,
 EntityHandle& first_handle_out,
 EntitySequence*& sequence_out,
 int* is_periodic )
{
 return create_scd_sequence( coord_min.i(), coord_min.j(), coord_min.k(), coord_max.i(), coord_max.j(),
 coord_max.k(), type, start_id_hint, first_handle_out, sequence_out, is_periodic );
}
 
ErrorCode SequenceManager::create_sweep_sequence( int imin,
 int jmin,
 int kmin,
 int imax,
 int jmax,
 int kmax,
 int* Cq,
 EntityType type,
 EntityID start_id_hint,
 EntityHandle& handle,
 EntitySequence*& sequence )
{
 int this_dim = CN::Dimension( type );
 
 assert( ( this_dim < 3 || kmax > kmin ) && ( this_dim < 2 || jmax > jmin ) && ( this_dim < 1 || imax > imin ) );
 
 EntityID num_ent;
 if( MBVERTEX == type )
 num_ent = (EntityID)( imax - imin + 1 ) * (EntityID)( jmax - jmin + 1 ) * (EntityID)( kmax - kmin + 1 );
 else
 {
 num_ent = ( imax - imin ) * ( this_dim >= 2 ? ( jmax - jmin ) : 1 ) * ( this_dim >= 3 ? ( kmax - kmin ) : 1 );
 }
 
 // Get a start handle
 SequenceData* data = 0;
 EntityID data_size = 0;
 handle = sequence_start_handle( type, num_ent, -1, start_id_hint, data, data_size );
 
 if( !handle ) return MB_MEMORY_ALLOCATION_FAILED;
 assert( !data );
 
 switch( type )
 {
 case MBVERTEX:
 data = new ScdVertexData( handle, imin, jmin, kmin, imax, jmax, kmax );
 sequence = new VertexSequence( handle, data->size(), data );
 break;
 case MBEDGE:
 case MBQUAD:
 case MBHEX:
 sequence = new SweptElementSeq( handle, imin, jmin, kmin, imax, jmax, kmax, Cq );
 break;
 default:
 return MB_TYPE_OUT_OF_RANGE;
 }
 
 ErrorCode result = typeData[type].insert_sequence( sequence );
 if( MB_SUCCESS != result )
 {
 data = sequence->data();
 delete sequence;
 delete data;
 return result;
 }
 
 return MB_SUCCESS;
}
 
ErrorCode SequenceManager::create_sweep_sequence( const HomCoord& coord_min,
 const HomCoord& coord_max,
 int* Cq,
 EntityType type,
 EntityID start_id_hint,
 EntityHandle& first_handle_out,
 EntitySequence*& sequence_out )
{
 return create_sweep_sequence( coord_min.i(), coord_min.j(), coord_min.k(), coord_max.i(), coord_max.j(),
 coord_max.k(), Cq, type, start_id_hint, first_handle_out, sequence_out );
}
 
ErrorCode SequenceManager::add_vsequence( EntitySequence* vert_seq,
 EntitySequence* elem_seq,
 const HomCoord& p1,
 const HomCoord& q1,
 const HomCoord& p2,
 const HomCoord& q2,
 const HomCoord& p3,
 const HomCoord& q3,
 bool bb_input,
 const HomCoord* bb_min,
 const HomCoord* bb_max )
{
 // Check first that they're structured vtx/elem sequences
 ScdVertexData* scd_vd = dynamic_cast< ScdVertexData* >( vert_seq->data() );
 if( !scd_vd ) return MB_FAILURE;
 
 ScdElementData* scd_ed = dynamic_cast< ScdElementData* >( elem_seq->data() );
 if( !scd_ed ) return MB_FAILURE;
 
 if( bb_min && bb_max )
 return scd_ed->add_vsequence( scd_vd, p1, q1, p2, q2, p3, q3, bb_input, *bb_min, *bb_max );
 else
 return scd_ed->add_vsequence( scd_vd, p1, q1, p2, q2, p3, q3, bb_input, HomCoord::unitv[0],
 HomCoord::unitv[0] );
}
 
ErrorCode SequenceManager::replace_subsequence( EntitySequence* new_seq )
{
 const EntityType type = TYPE_FROM_HANDLE( new_seq->start_handle() );
 return typeData[type].replace_subsequence( new_seq, &tagSizes[0], tagSizes.size() );
}
 
void SequenceManager::get_memory_use( unsigned long long& total_entity_storage,
 unsigned long long& total_storage ) const
 
{
 total_entity_storage = 0;
 total_storage = 0;
 unsigned long long temp_entity, temp_total;
 for( EntityType i = MBVERTEX; i < MBMAXTYPE; ++i )
 {
 temp_entity = temp_total = 0;
 get_memory_use( i, temp_entity, temp_total );
 total_entity_storage += temp_entity;
 total_storage += temp_total;
 }
}
 
void SequenceManager::get_memory_use( EntityType type,
 unsigned long long& total_entity_storage,
 unsigned long long& total_storage ) const
{
 typeData[type].get_memory_use( total_entity_storage, total_storage );
}
 
void SequenceManager::get_memory_use( const Range& entities,
 unsigned long long& total_entity_storage,
 unsigned long long& total_amortized_storage ) const
{
 total_entity_storage = 0;
 total_amortized_storage = 0;
 unsigned long long temp_entity, temp_total;
 Range::const_pair_iterator i;
 for( i = entities.const_pair_begin(); i != entities.const_pair_end(); ++i )
 {
 const EntityType t1 = TYPE_FROM_HANDLE( i->first );
 const EntityType t2 = TYPE_FROM_HANDLE( i->second );
 if( t1 == t2 )
 {
 temp_entity = temp_total = 0;
 typeData[t1].get_memory_use( i->first, i->second, temp_entity, temp_total );
 total_entity_storage += temp_entity;
 total_amortized_storage += temp_total;
 }
 else
 {
 int junk;
 
 temp_entity = temp_total = 0;
 typeData[t1].get_memory_use( i->first, CREATE_HANDLE( t1, MB_END_ID, junk ), temp_entity, temp_total );
 total_entity_storage += temp_entity;
 total_amortized_storage += temp_total;
 
 temp_entity = temp_total = 0;
 typeData[t2].get_memory_use( CREATE_HANDLE( t2, MB_START_ID, junk ), i->second, temp_entity, temp_total );
 total_entity_storage += temp_entity;
 total_amortized_storage += temp_total;
 }
 }
}
 
ErrorCode SequenceManager::reserve_tag_array( Error* /* error_handler */, int size, int& index )
{
 if( size < 1 && size != MB_VARIABLE_LENGTH )
 {
 MB_SET_ERR( MB_INVALID_SIZE, "Invalid tag size: " << size );
 }
 
 std::vector< int >::iterator i = std::find( tagSizes.begin(), tagSizes.end(), UNUSED_SIZE );
 if( i == tagSizes.end() )
 {
 index = tagSizes.size();
 tagSizes.push_back( size );
 }
 else
 {
 index = i - tagSizes.begin();
 *i = size;
 }
 
 return MB_SUCCESS;
}
 
ErrorCode SequenceManager::release_tag_array( Error* /* error_handler */, int index, bool release_id )
{
 if( (unsigned)index >= tagSizes.size() || UNUSED_SIZE == tagSizes[index] )
 {
 // MB_TAG_NOT_FOUND could be a non-error condition, do not call MB_SET_ERR on it
#if 0
 fprintf(stderr, "[Warning]: Invalid dense tag index: %d\n", index);
#endif
 return MB_TAG_NOT_FOUND;
 }
 
 for( EntityType t = MBVERTEX; t <= MBENTITYSET; ++t )
 {
 TypeSequenceManager& seqs = entity_map( t );
 for( TypeSequenceManager::iterator i = seqs.begin(); i != seqs.end(); ++i )
 ( *i )->data()->release_tag_data( index, tagSizes[index] );
 }
 
 if( release_id ) tagSizes[index] = UNUSED_SIZE;
 
 return MB_SUCCESS;
}
 
// These are meant to be called from the debugger (not declared in any header)
// so leave them out of release builds (-DNDEBUG).
#ifndef NDEBUG
 
std::ostream& operator<<( std::ostream& s, const TypeSequenceManager& seq_man )
{
 const SequenceData* prev_data = 0;
 for( TypeSequenceManager::const_iterator i = seq_man.begin(); i != seq_man.end(); ++i )
 {
 const EntitySequence* seq = *i;
 if( seq->data() != prev_data )
 {
 prev_data = seq->data();
 s << "SequenceData [" << ID_FROM_HANDLE( seq->data()->start_handle() ) << ","
 << ID_FROM_HANDLE( seq->data()->end_handle() ) << "]" << std::endl;
 }
 s << " Sequence [" << ID_FROM_HANDLE( seq->start_handle() ) << "," << ID_FROM_HANDLE( seq->end_handle() )
 << "]" << std::endl;
 }
 
 return s;
}
 
std::ostream& operator<<( std::ostream& s, const SequenceManager& seq_man )
{
 for( EntityType t = MBVERTEX; t < MBMAXTYPE; ++t )
 {
 if( !seq_man.entity_map( t ).empty() )
 s << std::endl
 << "****************** " << CN::EntityTypeName( t ) << " ******************" << std::endl
 << seq_man.entity_map( t ) << std::endl;
 }
 
 return s;
}
 
void print_sequences( const SequenceManager& seqman )
{
 std::cout << seqman << std::endl;
}
 
void print_sequences( const TypeSequenceManager& seqman )
{
 std::cout << seqman << std::endl;
}
 
#endif
 
} // namespace moab