VarLenDenseTag.cpp

Go to the documentation of this file.

/** \file   VarLenDenseTag.cpp
 *  \author Jason Kraftcheck
 *  \date   2010-12-14
 */
 
#include "VarLenDenseTag.hpp"
#include "moab/Range.hpp"
#include "TagCompare.hpp"
#include "SysUtil.hpp"
#include "SequenceManager.hpp"
#include "SequenceData.hpp"
#include "RangeSeqIntersectIter.hpp"
#include "moab/Error.hpp"
#include "moab/ErrorHandler.hpp"
#include "moab/CN.hpp"
#include <utility>
 
namespace moab
{
 
inline static ErrorCode not_found( std::string /*name*/, EntityHandle /*h*/ )
{
#if 0
  // MB_TAG_NOT_FOUND could be a non-error condition, do not call MB_SET_ERR on it
  // Print warning messages for debugging only
  if (h)
    fprintf(stderr, "[Warning]: No variable-length dense tag %s value for %s %lu\n",
        name.c_str(),
        CN::EntityTypeName(TYPE_FROM_HANDLE(h)),
        (unsigned long)ID_FROM_HANDLE(h));
  else
    fprintf(stderr, "[Warning]: No variable-length dense tag %s value for root set\n", name.c_str());
#endif
 
    return MB_TAG_NOT_FOUND;
}
 
VarLenDenseTag::VarLenDenseTag( int index,
                                const char* name,
                                DataType type,
                                const void* default_value,
                                int default_value_size )
    : TagInfo( name, MB_VARIABLE_LENGTH, type, default_value, default_value_size ), mySequenceArray( index )
{
}
 
VarLenDenseTag* VarLenDenseTag::create_tag( SequenceManager* seqman,
                                            Error* error,
                                            const char* name,
                                            DataType type,
                                            const void* default_value,
                                            int default_value_size )
{
    int index;
    if( MB_SUCCESS != seqman->reserve_tag_array( error, MB_VARIABLE_LENGTH, index ) ) return NULL;
 
    return new VarLenDenseTag( index, name, type, default_value, default_value_size );
}
 
VarLenDenseTag::~VarLenDenseTag()
{
    assert( mySequenceArray < 0 );
}
 
TagType VarLenDenseTag::get_storage_type() const
{
    return MB_TAG_DENSE;
}
 
ErrorCode VarLenDenseTag::release_all_data( SequenceManager* seqman, Error* error, bool delete_pending )
{
    Range all_ents;
    seqman->get_entities( all_ents );
    ErrorCode rval = remove_data( seqman, error, all_ents );
    if( MB_SUCCESS == rval )
    {
        rval = seqman->release_tag_array( error, mySequenceArray, delete_pending );
        if( MB_SUCCESS == rval && delete_pending ) mySequenceArray = -1;
    }
 
    return rval;
}
 
ErrorCode VarLenDenseTag::get_array( const SequenceManager* seqman,
                                     Error* /* error */,
                                     EntityHandle h,
                                     const VarLenTag*& ptr,
                                     size_t& count ) const
{
    const EntitySequence* seq = NULL;
    ErrorCode rval            = seqman->find( h, seq );
    if( MB_SUCCESS != rval )
    {
        if( !h )
        {  // Root set
            ptr   = &meshValue;
            count = 1;
            return MB_SUCCESS;
        }
        else
        {
            ptr   = NULL;
            count = 0;
            return not_found( get_name(), h );
        }
    }
 
    const void* mem = seq->data()->get_tag_data( mySequenceArray );
    ptr             = reinterpret_cast< const VarLenTag* >( mem );
    count           = seq->data()->end_handle() - h + 1;
    if( ptr ) ptr += h - seq->data()->start_handle();
 
    return MB_SUCCESS;
}
 
ErrorCode VarLenDenseTag::get_array( SequenceManager* seqman,
                                     Error* /* error */,
                                     EntityHandle h,
                                     VarLenTag*& ptr,
                                     size_t& count,
                                     bool allocate )
{
    EntitySequence* seq = NULL;
    ErrorCode rval      = seqman->find( h, seq );
    if( MB_SUCCESS != rval )
    {
        if( !h )
        {  // Root set
            ptr   = &meshValue;
            count = 1;
            return MB_SUCCESS;
        }
        else
        {
            ptr   = NULL;
            count = 0;
            return not_found( get_name(), h );
        }
    }
 
    void* mem = seq->data()->get_tag_data( mySequenceArray );
    if( !mem && allocate )
    {
        mem = seq->data()->allocate_tag_array( mySequenceArray, sizeof( VarLenTag ) );
        if( !mem )
        {
            MB_SET_ERR( MB_MEMORY_ALLOCATION_FAILED, "Memory allocation for variable-length dense tag data failed" );
        }
 
        memset( mem, 0, sizeof( VarLenTag ) * seq->data()->size() );
    }
 
    ptr   = reinterpret_cast< VarLenTag* >( mem );
    count = seq->data()->end_handle() - h + 1;
    if( ptr ) ptr += h - seq->data()->start_handle();
 
    return MB_SUCCESS;
}
 
ErrorCode VarLenDenseTag::get_data( const SequenceManager*,
                                    Error* /* error */,
                                    const EntityHandle*,
                                    size_t,
                                    void* ) const
{
    MB_SET_ERR( MB_VARIABLE_DATA_LENGTH, "No size specified for variable-length tag " << get_name() << " data" );
}
 
ErrorCode VarLenDenseTag::get_data( const SequenceManager*, Error* /* error */, const Range&, void* ) const
{
    MB_SET_ERR( MB_VARIABLE_DATA_LENGTH, "No size specified for variable-length tag " << get_name() << " data" );
}
 
ErrorCode VarLenDenseTag::get_data( const SequenceManager* seqman,
                                    Error* /* error */,
                                    const EntityHandle* entities,
                                    size_t num_entities,
                                    const void** pointers,
                                    int* lengths ) const
{
    if( !lengths )
    {
        MB_SET_ERR( MB_VARIABLE_DATA_LENGTH, "No size specified for variable-length tag " << get_name() << " data" );
    }
 
    ErrorCode result              = MB_SUCCESS, rval;
    const EntityHandle* const end = entities + num_entities;
    size_t junk                   = 0;
    const VarLenTag* ptr          = NULL;
 
    for( const EntityHandle* i = entities; i != end; ++i, ++pointers, ++lengths )
    {
        rval = get_array( seqman, NULL, *i, ptr, junk );MB_CHK_ERR( rval );
 
        if( ptr && ptr->size() )
        {
            *pointers = ptr->data();
            *lengths  = ptr->size();
        }
        else if( get_default_value() )
        {
            *pointers = get_default_value();
            *lengths  = get_default_value_size();
        }
        else
        {
            *pointers = 0;
            *lengths  = 0;
            result    = not_found( get_name(), *i );
        }
    }
 
    return result;
}
 
ErrorCode VarLenDenseTag::get_data( const SequenceManager* seqman,
                                    Error* /* error */,
                                    const Range& entities,
                                    const void** pointers,
                                    int* lengths ) const
{
    if( !lengths )
    {
        MB_SET_ERR( MB_VARIABLE_DATA_LENGTH, "No size specified for variable-length tag " << get_name() << " data" );
    }
 
    ErrorCode rval;
    size_t avail           = 0;
    const VarLenTag* array = NULL;
 
    for( Range::const_pair_iterator p = entities.const_pair_begin(); p != entities.const_pair_end(); ++p )
    {
        EntityHandle start = p->first;
        while( start <= p->second )
        {
            rval = get_array( seqman, NULL, start, array, avail );MB_CHK_ERR( rval );
 
            const size_t count = std::min< size_t >( p->second - start + 1, avail );
 
            if( !array )
            {
                const void* defval = get_default_value();
                const int len      = get_default_value_size();
                SysUtil::setmem( pointers, &defval, sizeof( void* ), count );
                SysUtil::setmem( lengths, &len, sizeof( int ), count );
                pointers += count;
                lengths += count;
                if( !defval ) return not_found( get_name(), start );
            }
 
            const VarLenTag* end_data = array + count;
            while( array != end_data )
            {
                if( array->size() )
                {
                    *pointers = array->data();
                    *lengths  = array->size();
                }
                else if( get_default_value() )
                {
                    *pointers = get_default_value();
                    *lengths  = get_default_value_size();
                }
                else
                {
                    *pointers = NULL;
                    *lengths  = 0;
                    return not_found( get_name(), start );
                }
                ++pointers;
                ++lengths;
                ++array;
                ++start;
            }
        }
    }
 
    return MB_SUCCESS;
}
 
ErrorCode VarLenDenseTag::set_data( SequenceManager*, Error* /* error */, const EntityHandle*, size_t, const void* )
{
    MB_SET_ERR( MB_VARIABLE_DATA_LENGTH, "No size specified for variable-length tag " << get_name() << " data" );
}
 
ErrorCode VarLenDenseTag::set_data( SequenceManager*, Error* /* error */, const Range&, const void* )
{
    MB_SET_ERR( MB_VARIABLE_DATA_LENGTH, "No size specified for variable-length tag " << get_name() << " data" );
}
 
ErrorCode VarLenDenseTag::set_data( SequenceManager* seqman,
                                    Error* /* error */,
                                    const EntityHandle* entities,
                                    size_t num_entities,
                                    bool one_value,
                                    void const* const* pointers,
                                    const int* lengths )
{
    ErrorCode rval = validate_lengths( NULL, lengths, one_value ? 1 : num_entities );MB_CHK_ERR( rval );
 
    const EntityHandle* const end = entities + num_entities;
    VarLenTag* array              = NULL;
    size_t junk                   = 0;
    const size_t step             = one_value ? 0 : 1;
 
    for( const EntityHandle* i = entities; i != end; ++i )
    {
        rval = get_array( seqman, NULL, *i, array, junk, true );MB_CHK_ERR( rval );
 
        array->set( *pointers, *lengths );
        pointers += step;
        lengths += step;
    }
 
    return MB_SUCCESS;
}
 
ErrorCode VarLenDenseTag::set_data( SequenceManager* seqman,
                                    Error* /* error */,
                                    const Range& entities,
                                    bool one_value,
                                    void const* const* pointers,
                                    const int* lengths )
{
    ErrorCode rval = validate_lengths( NULL, lengths, one_value ? 1 : entities.size() );MB_CHK_ERR( rval );
 
    VarLenTag* array  = NULL;
    size_t avail      = 0;
    const size_t step = one_value ? 0 : 1;
 
    for( Range::const_pair_iterator p = entities.const_pair_begin(); p != entities.const_pair_end(); ++p )
    {
        EntityHandle start = p->first;
        while( start <= p->second )
        {
            rval = get_array( seqman, NULL, start, array, avail, true );MB_CHK_ERR( rval );
 
            const EntityHandle end = std::min< EntityHandle >( p->second + 1, start + avail );
            while( start != end )
            {
                array->set( *pointers, *lengths );
                ++start;
                ++array;
                pointers += step;
                lengths += step;
            }
        }
    }
 
    return MB_SUCCESS;
}
 
ErrorCode VarLenDenseTag::set_data( SequenceManager* seqman,
                                    Error* /* error */,
                                    const EntityHandle* entities,
                                    size_t num_entities,
                                    void const* const* pointers,
                                    const int* lengths )
{
    return set_data( seqman, NULL, entities, num_entities, false, pointers, lengths );
}
 
ErrorCode VarLenDenseTag::set_data( SequenceManager* seqman,
                                    Error* /* error */,
                                    const Range& entities,
                                    void const* const* pointers,
                                    const int* lengths )
{
    return set_data( seqman, NULL, entities, false, pointers, lengths );
}
 
ErrorCode VarLenDenseTag::clear_data( SequenceManager* seqman,
                                      Error* /* error */,
                                      const EntityHandle* entities,
                                      size_t num_entities,
                                      const void* value_ptr,
                                      int value_len )
{
    if( !value_ptr || !value_len )
        return remove_data( seqman, NULL, entities, num_entities );
    else
        return set_data( seqman, NULL, entities, num_entities, true, &value_ptr, &value_len );
}
 
ErrorCode VarLenDenseTag::clear_data( SequenceManager* seqman,
                                      Error* /* error */,
                                      const Range& entities,
                                      const void* value_ptr,
                                      int value_len )
{
    if( !value_ptr || !value_len )
        return remove_data( seqman, NULL, entities );
    else
        return set_data( seqman, NULL, entities, true, &value_ptr, &value_len );
}
 
ErrorCode VarLenDenseTag::remove_data( SequenceManager* seqman,
                                       Error* /* error */,
                                       const EntityHandle* entities,
                                       size_t num_entities )
{
    const EntityHandle* const end = entities + num_entities;
    VarLenTag* array              = NULL;
    size_t junk                   = 0;
    ErrorCode rval;
 
    for( const EntityHandle* i = entities; i != end; ++i )
    {
        rval = get_array( seqman, NULL, *i, array, junk, false );MB_CHK_ERR( rval );
 
        if( array ) array->clear();
    }
 
    return MB_SUCCESS;
}
 
ErrorCode VarLenDenseTag::remove_data( SequenceManager* seqman, Error* /* error */, const Range& entities )
{
    VarLenTag* array = NULL;
    size_t avail     = 0;
    ErrorCode rval;
 
    for( Range::const_pair_iterator p = entities.const_pair_begin(); p != entities.const_pair_end(); ++p )
    {
        EntityHandle start = p->first;
        while( start <= p->second )
        {
            rval = get_array( seqman, NULL, start, array, avail, false );MB_CHK_ERR( rval );
 
            const EntityHandle end = std::min< EntityHandle >( p->second + 1, start + avail );
            if( array )
            {
                while( start != end )
                {
                    array->clear();
                    ++start;
                    ++array;
                }
            }
            else
            {
                start = end;
            }
        }
    }
 
    return MB_SUCCESS;
}
 
ErrorCode VarLenDenseTag::tag_iterate( SequenceManager*,
                                       Error* /* error */,
                                       Range::iterator&,
                                       const Range::iterator&,
                                       void*&,
                                       bool )
{
    MB_SET_ERR( MB_VARIABLE_DATA_LENGTH, "Cannot iterate over variable-length tag data" );
}
 
template < class Container >
static inline ErrorCode get_tagged( const SequenceManager* seqman,
                                    int mySequenceArray,
                                    EntityType type,
                                    Container& entities )
{
    typename Container::iterator hint         = entities.begin();
    std::pair< EntityType, EntityType > range = type_range( type );
    TypeSequenceManager::const_iterator i;
    const VarLenTag *data, *iter, *end;
    for( EntityType t = range.first; t != range.second; ++t )
    {
        const TypeSequenceManager& map = seqman->entity_map( t );
        for( i = map.begin(); i != map.end(); ++i )
        {
            data = reinterpret_cast< const VarLenTag* >( ( *i )->data()->get_tag_data( mySequenceArray ) );
            if( !data ) continue;
            end                 = data + ( *i )->end_handle() - ( *i )->data()->start_handle() + 1;
            iter                = data + ( *i )->start_handle() - ( *i )->data()->start_handle();
            EntityHandle handle = ( *i )->start_handle();
            for( ; iter != end; ++iter, ++handle )
                if( iter->size() ) hint = entities.insert( hint, handle );
        }
    }
 
    return MB_SUCCESS;
}
 
template < class Container >
static inline ErrorCode get_tagged( const SequenceManager* seqman,
                                    int mySequenceArray,
                                    Range::const_iterator begin,
                                    Range::const_iterator end,
                                    Container& entities )
{
    typename Container::iterator hint = entities.begin();
    RangeSeqIntersectIter iter( const_cast< SequenceManager* >( seqman ) );
    ErrorCode rval = iter.init( begin, end );
    const VarLenTag* data;
    for( ; MB_SUCCESS == rval; rval = iter.step() )
    {
        data = reinterpret_cast< const VarLenTag* >( iter.get_sequence()->data()->get_tag_data( mySequenceArray ) );
        if( !data ) continue;
 
        data += iter.get_start_handle() - iter.get_sequence()->data()->start_handle();
        size_t count = iter.get_end_handle() - iter.get_start_handle() + 1;
        for( size_t i = 0; i < count; ++i )
            if( data[i].size() ) hint = entities.insert( hint, iter.get_start_handle() + i );
        rval = iter.step();
    }
 
    if( MB_FAILURE != rval )  // We get MB_FAILURE at iterator end
        return rval;
 
    return MB_SUCCESS;
}
 
template < class Container >
static inline ErrorCode get_tagged( const SequenceManager* seqman,
                                    int mySequenceArray,
                                    Container& entities,
                                    EntityType type,
                                    const Range* intersect )
{
    if( !intersect )
        return get_tagged< Container >( seqman, mySequenceArray, type, entities );
    else if( MBMAXTYPE == type )
        return get_tagged< Container >( seqman, mySequenceArray, intersect->begin(), intersect->end(), entities );
    else
    {
        std::pair< Range::iterator, Range::iterator > r = intersect->equal_range( type );
        return get_tagged< Container >( seqman, mySequenceArray, r.first, r.second, entities );
    }
}
 
ErrorCode VarLenDenseTag::get_tagged_entities( const SequenceManager* seqman,
                                               Range& entities,
                                               EntityType type,
                                               const Range* intersect ) const
{
    return get_tagged( seqman, mySequenceArray, entities, type, intersect );
}
 
ErrorCode VarLenDenseTag::num_tagged_entities( const SequenceManager* seqman,
                                               size_t& output_count,
                                               EntityType type,
                                               const Range* intersect ) const
{
    InsertCount counter( output_count );
    ErrorCode rval = get_tagged( seqman, mySequenceArray, counter, type, intersect );
    output_count   = counter.end();
    return rval;
}
 
ErrorCode VarLenDenseTag::find_entities_with_value( const SequenceManager* seqman,
                                                    Error* error,
                                                    Range& output_entities,
                                                    const void* value,
                                                    int value_bytes,
                                                    EntityType type,
                                                    const Range* intersect_entities ) const
{
    if( !intersect_entities )
    {
        std::pair< EntityType, EntityType > range = type_range( type );
        TypeSequenceManager::const_iterator i;
        for( EntityType t = range.first; t != range.second; ++t )
        {
            const TypeSequenceManager& map = seqman->entity_map( t );
            for( i = map.begin(); i != map.end(); ++i )
            {
                const void* data = ( *i )->data()->get_tag_data( mySequenceArray );
                if( data )
                {
                    ByteArrayIterator start( ( *i )->data()->start_handle(), data, *this );
                    ByteArrayIterator end( ( *i )->end_handle() + 1, 0, 0 );
                    start += ( *i )->start_handle() - ( *i )->data()->start_handle();
                    find_tag_varlen_values_equal( *this, value, value_bytes, start, end, output_entities );
                }
            }
        }
    }
    else
    {
        const VarLenTag* array;
        size_t count;
        ErrorCode rval;
 
        Range::const_pair_iterator p = intersect_entities->begin();
        if( type != MBMAXTYPE )
        {
            p = intersect_entities->lower_bound( type );
            assert( TYPE_FROM_HANDLE( p->first ) == type );
        }
        for( ;
             p != intersect_entities->const_pair_end() && ( MBMAXTYPE == type || TYPE_FROM_HANDLE( p->first ) == type );
             ++p )
        {
            EntityHandle start = p->first;
            while( start <= p->second )
            {
                rval = get_array( seqman, error, start, array, count );MB_CHK_ERR( rval );
 
                if( p->second - start < count - 1 ) count = p->second - start + 1;
 
                if( array )
                {
                    ByteArrayIterator istart( start, array, *this );
                    ByteArrayIterator iend( start + count, 0, 0 );
                    find_tag_varlen_values_equal( *this, value, value_bytes, istart, iend, output_entities );
                }
                start += count;
            }
        }
    }
 
    return MB_SUCCESS;
}
 
bool VarLenDenseTag::is_tagged( const SequenceManager* seqman, EntityHandle h ) const
{
    const VarLenTag* ptr = NULL;  // Initialize to get rid of warning
    size_t count;
    return ( MB_SUCCESS == get_array( seqman, 0, h, ptr, count ) ) && ( NULL != ptr ) && ( NULL != ptr->data() );
}
 
ErrorCode VarLenDenseTag::get_memory_use( const SequenceManager* seqman,
                                          unsigned long& total,
                                          unsigned long& per_entity ) const
 
{
    total        = 0;
    per_entity   = 0;
    size_t count = 0;
    for( EntityType t = MBVERTEX; t <= MBENTITYSET; ++t )
    {
        const TypeSequenceManager& map = seqman->entity_map( t );
        const SequenceData* prev_data  = 0;
        for( TypeSequenceManager::const_iterator i = map.begin(); i != map.end(); ++i )
        {
            const void* mem = ( *i )->data()->get_tag_data( mySequenceArray );
            if( !mem ) continue;
 
            if( ( *i )->data() != prev_data )
            {
                total += ( *i )->data()->size();
                prev_data = ( *i )->data();
            }
 
            count += ( *i )->size();
            const VarLenTag* array = reinterpret_cast< const VarLenTag* >( mem );
            for( int j = 0; j < ( *i )->size(); ++j )
                per_entity += array[j].mem();
        }
    }
    total *= sizeof( VarLenTag );
    total += per_entity + sizeof( *this ) + TagInfo::get_memory_use();
    total += meshValue.mem() + sizeof( meshValue );
    if( count ) per_entity /= count;
    per_entity += sizeof( VarLenTag );
 
    return MB_SUCCESS;
}
 
}  // namespace moab