MeshTag.cpp

Go to the documentation of this file.

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

#include "moab/Interface.hpp"
#include "MeshTag.hpp"
#include "SysUtil.hpp"
#include "moab/Error.hpp"
#include "moab/CN.hpp"
#include "Internals.hpp"

namespace moab
{

inline static ErrorCode not_root_set( const std::string& /*name*/, EntityHandle /*h*/ )
{
    // 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 0
  MB_SET_ERR(MB_VARIABLE_DATA_LENGTH, "Cannot get/set mesh/global tag " << name << " on non-root-set " << CN::EntityTypeName(TYPE_FROM_HANDLE(h)) << " " << (unsigned long)ID_FROM_HANDLE(h));
#endif

    return MB_TAG_NOT_FOUND;
}

inline static bool all_root_set( std::string name, const EntityHandle* array, size_t len )
{
    for( size_t i = 0; i < len; ++i )
    {
        if( array[i] )
        {
            not_root_set( name, array[i] );
            return false;
        }
    }

    return true;
}

inline static ErrorCode not_found( const std::string& /*name*/ )
{
    // MB_TAG_NOT_FOUND could be a non-error condition, do not call MB_SET_ERR on it
#if 0
  fprintf(stderr, "[Warning]: No mesh tag %s value for global/mesh tag\n", name.c_str());
#endif

    return MB_TAG_NOT_FOUND;
}

MeshTag::MeshTag( const char* name, int size, DataType type, const void* default_value, int default_value_size )
    : TagInfo( name, size, type, default_value, default_value_size )
{
}

MeshTag::~MeshTag() {}

TagType MeshTag::get_storage_type() const
{
    return MB_TAG_MESH;
}

ErrorCode MeshTag::release_all_data( SequenceManager*, Error*, bool )
{
    return MB_SUCCESS;
}

ErrorCode MeshTag::get_data( const SequenceManager*,
                             Error* /* error */,
                             const EntityHandle* entities,
                             size_t num_entities,
                             void* data ) const
{
    if( !all_root_set( get_name(), entities, num_entities ) ) return MB_TAG_NOT_FOUND;

    const void* ptr;
    int len;

    if( !mValue.empty() )
    {
        ptr = &mValue[0];
        len = mValue.size();
    }
    else if( get_default_value() )
    {
        ptr = get_default_value();
        len = get_default_value_size();
    }
    else
    {
        return not_found( get_name() );
    }

    SysUtil::setmem( data, ptr, len, num_entities );
    return MB_SUCCESS;
}

ErrorCode MeshTag::get_data( const SequenceManager*, Error* /* error */, const Range& r, void* ) const
{
    if( variable_length() )
    {
        MB_SET_ERR( MB_VARIABLE_DATA_LENGTH, "No length specified for variable-length tag " << get_name() << " value" );
    }
    else if( r.empty() )
        return MB_SUCCESS;
    else
        return not_root_set( get_name(), r.front() );
}

ErrorCode MeshTag::get_data( const SequenceManager*,
                             Error* /* error */,
                             const EntityHandle* entities,
                             size_t num_entities,
                             const void** data_ptrs,
                             int* data_lengths ) const
{
    const void* ptr;
    int len;

    if( !mValue.empty() )
    {
        ptr = &mValue[0];
        len = mValue.size();
    }
    else if( get_default_value() )
    {
        ptr = get_default_value();
        len = get_default_value_size();
    }
    else
    {
        return not_found( get_name() );
    }

    for( size_t i = 0; i < num_entities; ++i )
    {
        if( entities[i] ) return not_root_set( get_name(), entities[i] );  // Not root set
        data_ptrs[i] = ptr;
        if( data_lengths ) data_lengths[i] = len;
    }

    return MB_SUCCESS;
}

ErrorCode MeshTag::get_data( const SequenceManager*, Error* /* error */, const Range& range, const void**, int* ) const
{
    if( range.empty() )
        return MB_SUCCESS;
    else
        return not_root_set( get_name(), range.front() );
}

ErrorCode MeshTag::set_data( SequenceManager*,
                             Error* /* error */,
                             const EntityHandle* entities,
                             size_t num_entities,
                             const void* data )
{
    if( variable_length() )
    {
        MB_SET_ERR( MB_VARIABLE_DATA_LENGTH, "No length specified for variable-length tag " << get_name() << " value" );
    }
    if( !all_root_set( get_name(), entities, num_entities ) ) return MB_TAG_NOT_FOUND;

    if( num_entities > 0 )
    {
        mValue.resize( get_size() );
        const unsigned char* bytes = reinterpret_cast< const unsigned char* >( data );
        memcpy( &mValue[0], bytes + get_size() * ( num_entities - 1 ), get_size() );
    }

    return MB_SUCCESS;
}

ErrorCode MeshTag::set_data( SequenceManager*, Error* /* error */, const Range& range, const void* )
{
    if( variable_length() )
    {
        MB_SET_ERR( MB_VARIABLE_DATA_LENGTH, "No length specified for variable-length tag " << get_name() << " value" );
    }
    else if( range.empty() )
        return MB_SUCCESS;
    else
        return not_root_set( get_name(), range.front() );
}

ErrorCode MeshTag::set_data( SequenceManager*,
                             Error* /* error */,
                             const EntityHandle* entities,
                             size_t num_entities,
                             void const* const* data_ptrs,
                             const int* data_lengths )
{
    if( !all_root_set( get_name(), entities, num_entities ) ) return MB_TAG_NOT_FOUND;

    ErrorCode valid = validate_lengths( NULL, data_lengths, num_entities );MB_CHK_ERR( valid );

    if( num_entities > 0 )
    {
        mValue.resize( data_lengths[num_entities - 1] );
        memcpy( &mValue[0], data_ptrs[num_entities - 1], mValue.size() );
    }

    return MB_SUCCESS;
}

ErrorCode MeshTag::set_data( SequenceManager*, Error* /* error */, const Range& range, void const* const*, const int* )
{
    if( range.empty() )
        return MB_SUCCESS;
    else
        return not_root_set( get_name(), range.front() );
}

ErrorCode MeshTag::clear_data( SequenceManager*,
                               Error* /* error */,
                               const EntityHandle* entities,
                               size_t num_entities,
                               const void* value_ptr,
                               int value_len )
{
    if( !all_root_set( get_name(), entities, num_entities ) ) return MB_TAG_NOT_FOUND;

    ErrorCode valid = validate_lengths( NULL, value_len ? &value_len : 0, 1 );MB_CHK_ERR( valid );

    if( num_entities > 0 )
    {
        mValue.resize( value_len );
        memcpy( &mValue[0], value_ptr, value_len );
    }

    return MB_SUCCESS;
}

ErrorCode MeshTag::clear_data( SequenceManager*, Error* /* error */, const Range& range, const void*, int )
{
    if( range.empty() )
        return MB_SUCCESS;
    else
        return not_root_set( get_name(), range.front() );
}

ErrorCode MeshTag::remove_data( SequenceManager*,
                                Error* /* error */,
                                const EntityHandle* entities,
                                size_t num_entities )
{
    if( !all_root_set( get_name(), entities, num_entities ) ) return MB_TAG_NOT_FOUND;

    if( num_entities ) mValue.clear();

    return MB_SUCCESS;
}

ErrorCode MeshTag::remove_data( SequenceManager*, Error* /* error */, const Range& range )
{
    if( range.empty() )
        return MB_SUCCESS;
    else
        return not_root_set( get_name(), range.front() );
}

ErrorCode MeshTag::tag_iterate( SequenceManager*,
                                Error* /* error */,
                                Range::iterator& beg,
                                const Range::iterator& end,
                                void*&,
                                bool )
{
    if( beg == end )
        return MB_SUCCESS;
    else
        return not_root_set( get_name(), *beg );
}

ErrorCode MeshTag::get_tagged_entities( const SequenceManager*, Range&, EntityType, const Range* ) const
{
    return MB_SUCCESS;
}

ErrorCode MeshTag::num_tagged_entities( const SequenceManager*, size_t&, EntityType, const Range* ) const
{
    return MB_SUCCESS;
}

ErrorCode MeshTag::find_entities_with_value( const SequenceManager*,
                                             Error*,
                                             Range&,
                                             const void*,
                                             int,
                                             EntityType,
                                             const Range* ) const
{
    return MB_SUCCESS;
}

bool MeshTag::is_tagged( const SequenceManager*, EntityHandle h ) const
{
    return ( 0 == h ) && ( !mValue.empty() );
}

ErrorCode MeshTag::get_memory_use( const SequenceManager*, unsigned long& total, unsigned long& per_entity ) const
{
    total      = TagInfo::get_memory_use() + sizeof( *this ) + mValue.size();
    per_entity = 0;
    return MB_SUCCESS;
}

}  // namespace moab