DenseTag.cpp

Go to the documentation of this file.

/** \file   DenseTag.cpp
 *  \author Jason Kraftcheck
 *  \date   2010-12-14
 */

#include "DenseTag.hpp"
#include "moab/Range.hpp"
#include "TagCompare.hpp"
#include "SysUtil.hpp"
#include "SequenceManager.hpp"
#include "SequenceData.hpp"
#include "moab/Error.hpp"
#include "moab/ErrorHandler.hpp"
#include "moab/CN.hpp"
#include 

namespace moab
{

inline static ErrorCode not_found( const std::string& /*name*/, EntityHandle /*h*/ )
{
    // MB_TAG_NOT_FOUND could be a non-error condition, do not call MB_SET_ERR on it
#if 0
  if (h)
    fprintf(stderr, "[Warning]: No dense tag %s value for %s %ld\n",
        name.c_str(),
        CN::EntityTypeName(TYPE_FROM_HANDLE(h)),
        (unsigned long)ID_FROM_HANDLE(h));
  else
    fprintf(stderr, "[Warning]: No dense tag %s value for root set\n", name.c_str());
#endif

    return MB_TAG_NOT_FOUND;
}

inline static ErrorCode ent_not_found( const std::string& /*name*/, EntityHandle /*h*/ )
{
    // 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 setting tag %s: %s %ld\n",
      name.c_str(),
      CN::EntityTypeName(TYPE_FROM_HANDLE(h)),
      (unsigned long)ID_FROM_HANDLE(h)
      );
#endif

    return MB_ENTITY_NOT_FOUND;
}

DenseTag::DenseTag( int index, const char* name, int size, DataType type, const void* default_value )
    : TagInfo( name, size, type, default_value, size ), mySequenceArray( index ), meshValue( 0 )
{
}

TagType DenseTag::get_storage_type() const
{
    return MB_TAG_DENSE;
}

DenseTag* DenseTag::create_tag( SequenceManager* seqman,
                                Error* /* error */,
                                const char* name,
                                int bytes,
                                DataType type,
                                const void* default_value )
{
    if( bytes < 1 ) return 0;

    int index;
    if( MB_SUCCESS != seqman->reserve_tag_array( NULL, bytes, index ) ) return 0;

    return new DenseTag( index, name, bytes, type, default_value );
}

DenseTag::~DenseTag()
{
    assert( mySequenceArray < 0 );
    delete[] meshValue;
}

ErrorCode DenseTag::release_all_data( SequenceManager* seqman, Error* /* error */, bool delete_pending )
{
    ErrorCode result = seqman->release_tag_array( NULL, mySequenceArray, delete_pending );
    if( MB_SUCCESS == result && delete_pending ) mySequenceArray = -1;
    return result;
}

ErrorCode DenseTag::get_array( const SequenceManager* seqman,
                               Error* /* error */,
                               EntityHandle h,
                               const unsigned char* const& ptr,
                               size_t& count ) const
{
    //  cast away the const-ness; do we really want to do this?
    // probably we are not calling this anywhere;
    // clang compiler found this
    return get_array_private( seqman, NULL, h, const_cast< const unsigned char*& >( ptr ), count );
}

ErrorCode DenseTag::get_array_private( const SequenceManager* seqman,
                                       Error* /* error */,
                                       EntityHandle h,
                                       const unsigned char*& ptr,
                                       size_t& count ) const
{
    const EntitySequence* seq = 0;
    ErrorCode rval            = seqman->find( h, seq );
    if( MB_SUCCESS != rval )
    {
        if( !h )
        {  // Root set
            ptr   = meshValue;
            count = 1;
            return MB_SUCCESS;
        }
        else
        {  // Not root set
            ptr   = 0;
            count = 0;
            return ent_not_found( get_name(), h );
        }
    }

    const void* mem = seq->data()->get_tag_data( mySequenceArray );
    ptr             = reinterpret_cast< const unsigned char* >( mem );
    count           = seq->data()->end_handle() - h + 1;
    if( ptr ) ptr += get_size() * ( h - seq->data()->start_handle() );

    return MB_SUCCESS;
}

ErrorCode DenseTag::get_array( const EntitySequence* seq, const unsigned char* const& ptr ) const
{
    // cast away the constness; otherwise it would be infinite recursion
    // probably we are not calling this anywhere
    return get_array_private( seq, const_cast< const unsigned char*& >( ptr ) );
}

ErrorCode DenseTag::get_array_private( const EntitySequence* seq, const unsigned char*& ptr ) const
{
    ptr = reinterpret_cast< const unsigned char* >( seq->data()->get_tag_data( mySequenceArray ) );
    if( ptr ) ptr += get_size() * ( seq->start_handle() - seq->data()->start_handle() );

    return MB_SUCCESS;
}

ErrorCode DenseTag::get_array_private( SequenceManager* seqman,
                                       Error* /* error */,
                                       EntityHandle h,
                                       unsigned char*& ptr,
                                       size_t& count,
                                       bool allocate )
{
    EntitySequence* seq = 0;
    ErrorCode rval      = seqman->find( h, seq );
    if( MB_SUCCESS != rval )
    {
        if( !h )
        {  // Root set
            if( !meshValue && allocate ) meshValue = new unsigned char[get_size()];
            ptr   = meshValue;
            count = 1;
            return MB_SUCCESS;
        }
        else
        {  // Not root set
            ptr   = 0;
            count = 0;
            return ent_not_found( get_name(), h );
        }
    }

    void* mem = seq->data()->get_tag_data( mySequenceArray );
    if( !mem && allocate )
    {
        mem = seq->data()->allocate_tag_array( mySequenceArray, get_size(), get_default_value() );
        if( !mem )
        {
            MB_SET_ERR( MB_MEMORY_ALLOCATION_FAILED, "Memory allocation for dense tag data failed" );
        }

        if( !get_default_value() ) memset( mem, 0, get_size() * seq->data()->size() );
    }

    ptr   = reinterpret_cast< unsigned char* >( mem );
    count = seq->data()->end_handle() - h + 1;
    if( ptr ) ptr += get_size() * ( h - seq->data()->start_handle() );
    return MB_SUCCESS;
}

ErrorCode DenseTag::get_data( const SequenceManager* seqman,
                              Error* /* error */,
                              const EntityHandle* entities,
                              size_t num_entities,
                              void* adata ) const
{
    size_t junk                   = 0;
    unsigned char* ptr            = reinterpret_cast< unsigned char* >( adata );
    const EntityHandle* const end = entities + num_entities;
    for( const EntityHandle* i = entities; i != end; ++i, ptr += get_size() )
    {
        const unsigned char* data = 0;
        ErrorCode rval            = get_array( seqman, NULL, *i, data, junk );MB_CHK_ERR( rval );

        if( data )
            memcpy( ptr, data, get_size() );
        else if( get_default_value() )
            memcpy( ptr, get_default_value(), get_size() );
        else
            return not_found( get_name(), *i );
    }

    return MB_SUCCESS;
}

ErrorCode DenseTag::get_data( const SequenceManager* seqman,
                              Error* /* error */,
                              const Range& entities,
                              void* values ) const
{
    ErrorCode rval;
    size_t avail               = 0;
    const unsigned char* array = NULL;  // Initialize to get rid of warning
    unsigned char* data        = reinterpret_cast< unsigned char* >( values );

    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 )
                memcpy( data, array, get_size() * count );
            else if( get_default_value() )
                SysUtil::setmem( data, get_default_value(), get_size(), count );
            else
                return not_found( get_name(), start );

            data += get_size() * count;
            start += count;
        }
    }

    return MB_SUCCESS;
}

ErrorCode DenseTag::get_data( const SequenceManager* seqman,
                              Error* /* error */,
                              const EntityHandle* entities,
                              size_t num_entities,
                              const void** pointers,
                              int* data_lengths ) const
{
    ErrorCode result;
    const EntityHandle* const end = entities + num_entities;
    size_t junk                   = 0;
    const unsigned char* ptr      = NULL;  // Initialize to get rid of warning

    if( data_lengths )
    {
        const int len = get_size();
        SysUtil::setmem( data_lengths, &len, sizeof( int ), num_entities );
    }

    for( const EntityHandle* i = entities; i != end; ++i, ++pointers )
    {
        result = get_array( seqman, NULL, *i, ptr, junk );MB_CHK_ERR( result );

        if( ptr )
            *pointers = ptr;
        else if( get_default_value() )
            *pointers = get_default_value();
        else
            return not_found( get_name(), *i );
    }

    return MB_SUCCESS;
}

ErrorCode DenseTag::get_data( const SequenceManager* seqman,
                              Error* /* error */,
                              const Range& entities,
                              const void** pointers,
                              int* data_lengths ) const
{
    ErrorCode rval;
    size_t avail               = 0;
    const unsigned char* array = NULL;

    if( data_lengths )
    {
        int len = get_size();
        SysUtil::setmem( data_lengths, &len, sizeof( int ), entities.size() );
    }

    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 )
            {
                for( EntityHandle end = start + count; start != end; ++start )
                {
                    *pointers = array;
                    array += get_size();
                    ++pointers;
                }
            }
            else if( const void* val = get_default_value() )
            {
                SysUtil::setmem( pointers, &val, sizeof( void* ), count );
                pointers += count;
                start += count;
            }
            else
            {
                return not_found( get_name(), start );
            }
        }
    }

    return MB_SUCCESS;
}

ErrorCode DenseTag::set_data( SequenceManager* seqman,
                              Error* /* error */,
                              const EntityHandle* entities,
                              size_t num_entities,
                              const void* data )
{
    ErrorCode rval;
    const unsigned char* ptr      = reinterpret_cast< const unsigned char* >( data );
    const EntityHandle* const end = entities + num_entities;
    unsigned char* array          = NULL;
    size_t junk                   = 0;

    for( const EntityHandle* i = entities; i != end; ++i, ptr += get_size() )
    {
        rval = get_array_private( seqman, NULL, *i, array, junk, true );MB_CHK_ERR( rval );

        memcpy( array, ptr, get_size() );
    }

    return MB_SUCCESS;
}

ErrorCode DenseTag::set_data( SequenceManager* seqman, Error* /* error */, const Range& entities, const void* values )
{
    ErrorCode rval;
    const char* data     = reinterpret_cast< const char* >( values );
    unsigned char* array = NULL;
    size_t avail         = 0;

    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_private( seqman, NULL, start, array, avail, true );MB_CHK_ERR( rval );

            const size_t count = std::min< size_t >( p->second - start + 1, avail );
            memcpy( array, data, get_size() * count );
            data += get_size() * count;
            start += count;
        }
    }

    return MB_SUCCESS;
}

ErrorCode DenseTag::set_data( SequenceManager* seqman,
                              Error* /* error */,
                              const EntityHandle* entities,
                              size_t num_entities,
                              void const* const* pointers,
                              const int* data_lengths )
{
    ErrorCode rval = validate_lengths( NULL, data_lengths, num_entities );MB_CHK_ERR( rval );

    const EntityHandle* const end = entities + num_entities;
    unsigned char* array          = NULL;
    size_t junk                   = 0;

    for( const EntityHandle* i = entities; i != end; ++i, ++pointers )
    {
        rval = get_array_private( seqman, NULL, *i, array, junk, true );MB_CHK_ERR( rval );

        memcpy( array, *pointers, get_size() );
    }

    return MB_SUCCESS;
}

ErrorCode DenseTag::set_data( SequenceManager* seqman,
                              Error* /* error */,
                              const Range& entities,
                              void const* const* pointers,
                              const int* /* data_lengths */ )
{
    ErrorCode rval;
    unsigned char* array = NULL;
    size_t avail         = 0;

    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_private( seqman, NULL, start, array, avail, true );MB_CHK_ERR( rval );

            const EntityHandle end = std::min< EntityHandle >( p->second + 1, start + avail );
            while( start != end )
            {
                memcpy( array, *pointers, get_size() );
                ++start;
                ++pointers;
                array += get_size();
            }
        }
    }

    return MB_SUCCESS;
}

ErrorCode DenseTag::clear_data( bool allocate,
                                SequenceManager* seqman,
                                Error* /* error */,
                                const EntityHandle* entities,
                                size_t num_entities,
                                const void* value_ptr )
{
    ErrorCode rval;
    const EntityHandle* const end = entities + num_entities;
    unsigned char* array          = NULL;
    size_t junk                   = 0;

    for( const EntityHandle* i = entities; i != end; ++i )
    {
        rval = get_array_private( seqman, NULL, *i, array, junk, allocate );MB_CHK_ERR( rval );

        if( array )  // Array should never be null if allocate == true
            memcpy( array, value_ptr, get_size() );
    }

    return MB_SUCCESS;
}

ErrorCode DenseTag::clear_data( bool allocate,
                                SequenceManager* seqman,
                                Error* /* error */,
                                const Range& entities,
                                const void* value_ptr )
{
    ErrorCode rval;
    unsigned char* array = NULL;
    size_t avail         = 0;

    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_private( seqman, NULL, start, array, avail, allocate );MB_CHK_ERR( rval );

            const size_t count = std::min< size_t >( p->second - start + 1, avail );
            if( array )  // Array should never be null if allocate == true
                SysUtil::setmem( array, value_ptr, get_size(), count );
            start += count;
        }
    }

    return MB_SUCCESS;
}

ErrorCode DenseTag::clear_data( SequenceManager* seqman,
                                Error* /* error */,
                                const EntityHandle* entities,
                                size_t num_entities,
                                const void* value_ptr,
                                int value_len )
{
    if( value_len && value_len != get_size() ) return MB_INVALID_SIZE;

    return clear_data( true, seqman, NULL, entities, num_entities, value_ptr );
}

ErrorCode DenseTag::clear_data( SequenceManager* seqman,
                                Error* /* error */,
                                const Range& entities,
                                const void* value_ptr,
                                int value_len )
{
    if( value_len && value_len != get_size() ) return MB_INVALID_SIZE;

    return clear_data( true, seqman, NULL, entities, value_ptr );
}

ErrorCode DenseTag::remove_data( SequenceManager* seqman,
                                 Error* /* error */,
                                 const EntityHandle* entities,
                                 size_t num_entities )
{
    std::vector< unsigned char > zeros;
    const void* value = get_default_value();
    if( !value )
    {
        zeros.resize( get_size(), 0 );
        value = &zeros[0];
    }

    return clear_data( false, seqman, NULL, entities, num_entities, value );
}

ErrorCode DenseTag::remove_data( SequenceManager* seqman, Error* /* error */, const Range& entities )
{
    std::vector< unsigned char > zeros;
    const void* value = get_default_value();
    if( !value )
    {
        zeros.resize( get_size(), 0 );
        value = &zeros[0];
    }

    return clear_data( false, seqman, NULL, entities, value );
}

ErrorCode DenseTag::tag_iterate( SequenceManager* seqman,
                                 Error* /* error */,
                                 Range::iterator& iter,
                                 const Range::iterator& end,
                                 void*& data_ptr,
                                 bool allocate )
{
    // If asked for nothing, successfully return nothing.
    if( iter == end ) return MB_SUCCESS;

    unsigned char* array = NULL;
    size_t avail         = 0;
    ErrorCode rval       = get_array_private( seqman, NULL, *iter, array, avail, allocate );MB_CHK_ERR( rval );
    data_ptr = array;

    size_t count = std::min< size_t >( avail, *( iter.end_of_block() ) - *iter + 1 );
    if( 0 != *end && *end <= *( iter.end_of_block() ) )
        iter = end;
    else
        iter += count;

    return MB_SUCCESS;
}

ErrorCode DenseTag::get_tagged_entities( const SequenceManager* seqman,
                                         Range& entities_in,
                                         EntityType type,
                                         const Range* intersect_list ) const
{
    Range tmp;
    Range* entities                           = intersect_list ? &tmp : &entities_in;
    Range::iterator hint                      = entities->begin();
    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 )
            if( ( *i )->data()->get_tag_data( mySequenceArray ) )
                hint = entities->insert( hint, ( *i )->start_handle(), ( *i )->end_handle() );
    }

    if( intersect_list ) entities_in = intersect( *entities, *intersect_list );

    return MB_SUCCESS;
}

ErrorCode DenseTag::num_tagged_entities( const SequenceManager* seqman,
                                         size_t& output_count,
                                         EntityType type,
                                         const Range* intersect ) const
{
    Range tmp;
    ErrorCode rval = get_tagged_entities( seqman, tmp, type, intersect );
    output_count += tmp.size();

    return rval;
}

ErrorCode DenseTag::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( value_bytes && value_bytes != get_size() )
    {
        MB_SET_ERR( MB_INVALID_SIZE,
                    "Cannot compare data of size " << value_bytes << " with tag of size " << get_size() );
    }

    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_values_equal( *this, value, get_size(), start, end, output_entities );
                }
            }
        }
    }
    else
    {
        const unsigned char* array = NULL;  // Initialize to get rid of warning
        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, NULL, 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_values_equal( *this, value, get_size(), istart, iend, output_entities );
                }
                start += count;
            }
        }
    }

    return MB_SUCCESS;
}

bool DenseTag::is_tagged( const SequenceManager* seqman, EntityHandle h ) const
{
    const unsigned char* ptr = NULL;  // Initialize to get rid of warning
    size_t count;
    return ( MB_SUCCESS == get_array( seqman, 0, h, ptr, count ) ) && ( NULL != ptr );
}

ErrorCode DenseTag::get_memory_use( const SequenceManager* seqman,
                                    unsigned long& total,
                                    unsigned long& per_entity ) const
{
    per_entity = get_size();
    total      = TagInfo::get_memory_use() + sizeof( *this );
    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 )
        {
            if( ( *i )->data() != prev_data && ( *i )->data()->get_tag_data( mySequenceArray ) )
            {
                prev_data = ( *i )->data();
                total += get_size() * ( *i )->data()->size();
            }
        }
    }

    return MB_SUCCESS;
}

}  // namespace moab