SparseTag.cpp

Go to the documentation of this file.

/**
 * MOAB, a Mesh-Oriented datABase, is a software component for creating,
 * storing and accessing finite element mesh data.
 *
 * Copyright 2004 Sandia Corporation.  Under the terms of Contract
 * DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government
 * retains certain rights in this software.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 */
 
#include <memory.h>
#include <algorithm>
 
#include "SparseTag.hpp"
#include "moab/Range.hpp"
#include "TagCompare.hpp"
#include "SysUtil.hpp"
#include "SequenceManager.hpp"
#include "moab/Error.hpp"
#include "moab/ErrorHandler.hpp"
#include "moab/CN.hpp"
 
namespace moab
{
 
SparseTag::SparseTag( const char* name, int size, DataType type, const void* default_value )
    : TagInfo( name, size, type, default_value, size )
{
}
 
SparseTag::~SparseTag()
{
    release_all_data( 0, 0, true );
}
 
TagType SparseTag::get_storage_type() const
{
    return MB_TAG_SPARSE;
}
 
ErrorCode SparseTag::release_all_data( SequenceManager*, Error*, bool )
{
    for( MapType::iterator i = mData.begin(); i != mData.end(); ++i )
        mAllocator.destroy( i->second );
    mData.clear();
    return MB_SUCCESS;
}
 
ErrorCode SparseTag::set_data( Error*, EntityHandle entity_handle, const void* data )
{
#ifdef MOAB_HAVE_UNORDERED_MAP
    MapType::iterator iter = mData.find( entity_handle );
#else
    MapType::iterator iter = mData.lower_bound( entity_handle );
#endif
 
    // Data space already exists
    if( iter != mData.end() && iter->first == entity_handle ) memcpy( iter->second, data, get_size() );
    // We need to make some data space
    else
    {
        void* new_data = allocate_data( entity_handle, iter, false );
        memcpy( new_data, data, get_size() );
    }
 
    return MB_SUCCESS;
}
 
ErrorCode SparseTag::get_data_ptr( EntityHandle entity_handle, const void*& ptr, bool allocate ) const
{
    MapType::const_iterator iter = mData.find( entity_handle );
 
    if( iter != mData.end() )
        ptr = iter->second;
    else if( get_default_value() && allocate )
        ptr = const_cast< SparseTag* >( this )->allocate_data( entity_handle, iter, allocate );
    else
        return MB_FAILURE;
 
    return MB_SUCCESS;
}
 
ErrorCode SparseTag::get_data( Error* /* error */, EntityHandle entity_handle, void* data ) const
{
    const void* ptr = 0;
    ErrorCode rval  = get_data_ptr( entity_handle, ptr, false );
    if( MB_SUCCESS == rval )
    {
        memcpy( data, ptr, get_size() );
        return rval;
    }
    else if( get_default_value() )
    {
        memcpy( data, get_default_value(), get_size() );
        return MB_SUCCESS;
    }
    else
        return MB_TAG_NOT_FOUND;
}
 
ErrorCode SparseTag::remove_data( Error* /* error */, EntityHandle entity_handle )
{
    MapType::iterator i = mData.find( entity_handle );
    if( i == mData.end() ) return MB_TAG_NOT_FOUND;
 
    mAllocator.destroy( i->second );
    mData.erase( i );
 
    return MB_SUCCESS;
}
 
ErrorCode SparseTag::get_data( const SequenceManager*,
                               Error* /* error */,
                               const EntityHandle* entities,
                               size_t num_entities,
                               void* data ) const
{
    ErrorCode rval;
    unsigned char* ptr = reinterpret_cast< unsigned char* >( data );
    for( size_t i = 0; i < num_entities; ++i, ptr += get_size() )
    {
        rval = get_data( NULL, entities[i], ptr );
        if( MB_SUCCESS != rval ) return rval;
    }
 
    return MB_SUCCESS;
}
 
ErrorCode SparseTag::get_data( const SequenceManager*, Error* /* error */, const Range& entities, void* data ) const
{
    ErrorCode rval;
    unsigned char* ptr = reinterpret_cast< unsigned char* >( data );
    Range::const_iterator i;
    for( i = entities.begin(); i != entities.end(); ++i, ptr += get_size() )
    {
        rval = get_data( NULL, *i, ptr );
        if( MB_SUCCESS != rval ) return rval;
    }
 
    return MB_SUCCESS;
}
 
ErrorCode SparseTag::get_data( const SequenceManager*,
                               Error* /* error */,
                               const EntityHandle* entities,
                               size_t num_entities,
                               const void** pointers,
                               int* data_lengths ) const
{
    if( data_lengths )
    {
        int len = get_size();
        SysUtil::setmem( data_lengths, &len, sizeof( int ), num_entities );
    }
 
    ErrorCode rval = MB_SUCCESS, rval_tmp;
    for( size_t i = 0; i < num_entities; ++i, ++pointers )
    {
        rval_tmp = get_data_ptr( entities[i], *pointers );
        if( MB_SUCCESS != rval_tmp && get_default_value() )
        {
            *pointers = get_default_value();
        }
        else if( MB_SUCCESS != rval_tmp )
        {
            return MB_TAG_NOT_FOUND;
        }
    }
 
    return rval;
}
 
ErrorCode SparseTag::get_data( const SequenceManager*,
                               Error* /* error */,
                               const Range& entities,
                               const void** pointers,
                               int* data_lengths ) const
{
    if( data_lengths )
    {
        int len = get_size();
        SysUtil::setmem( data_lengths, &len, sizeof( int ), entities.size() );
    }
 
    ErrorCode rval = MB_SUCCESS, rval_tmp;
    Range::const_iterator i;
    for( i = entities.begin(); i != entities.end(); ++i, ++pointers )
    {
        rval_tmp = get_data_ptr( *i, *pointers );
        if( MB_SUCCESS != rval_tmp && get_default_value() )
        {
            *pointers = get_default_value();
        }
        else if( MB_SUCCESS != rval_tmp )
        {
            return MB_TAG_NOT_FOUND;
        }
    }
 
    return rval;
}
 
ErrorCode SparseTag::set_data( SequenceManager* seqman,
                               Error* /* error */,
                               const EntityHandle* entities,
                               size_t num_entities,
                               const void* data )
{
    ErrorCode rval = seqman->check_valid_entities( NULL, entities, num_entities, true );MB_CHK_ERR( rval );
 
    const unsigned char* ptr = reinterpret_cast< const unsigned char* >( data );
    for( size_t i = 0; i < num_entities; ++i, ptr += get_size() )
    {
        rval = set_data( NULL, entities[i], ptr );MB_CHK_ERR( rval );
    }
 
    return MB_SUCCESS;
}
 
ErrorCode SparseTag::set_data( SequenceManager* seqman, Error* /* error */, const Range& entities, const void* data )
{
    ErrorCode rval = seqman->check_valid_entities( NULL, entities );MB_CHK_ERR( rval );
 
    const unsigned char* ptr = reinterpret_cast< const unsigned char* >( data );
    Range::const_iterator i;
    for( i = entities.begin(); i != entities.end(); ++i, ptr += get_size() )
        if( MB_SUCCESS != ( rval = set_data( NULL, *i, ptr ) ) ) return rval;
 
    return MB_SUCCESS;
}
 
ErrorCode SparseTag::set_data( SequenceManager* seqman,
                               Error* /* error */,
                               const EntityHandle* entities,
                               size_t num_entities,
                               void const* const* pointers,
                               const int* lengths )
{
    ErrorCode rval = validate_lengths( NULL, lengths, num_entities );MB_CHK_ERR( rval );
 
    rval = seqman->check_valid_entities( NULL, entities, num_entities, true );MB_CHK_ERR( rval );
 
    for( size_t i = 0; i < num_entities; ++i, ++pointers )
    {
        rval = set_data( NULL, entities[i], *pointers );MB_CHK_ERR( rval );
    }
 
    return MB_SUCCESS;
}
 
ErrorCode SparseTag::set_data( SequenceManager* seqman,
                               Error* /* error */,
                               const Range& entities,
                               void const* const* pointers,
                               const int* lengths )
{
    ErrorCode rval = validate_lengths( NULL, lengths, entities.size() );MB_CHK_ERR( rval );
 
    rval = seqman->check_valid_entities( NULL, entities );MB_CHK_ERR( rval );
 
    Range::const_iterator i;
    for( i = entities.begin(); i != entities.end(); ++i, ++pointers )
    {
        rval = set_data( NULL, *i, *pointers );MB_CHK_ERR( rval );
    }
 
    return MB_SUCCESS;
}
 
ErrorCode SparseTag::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() )
    {
        MB_SET_ERR( MB_INVALID_SIZE, "Invalid data size " << get_size() << " specified for sparse tag " << get_name()
                                                          << " of size " << value_len );
    }
 
    ErrorCode rval = seqman->check_valid_entities( NULL, entities, num_entities, true );MB_CHK_ERR( rval );
 
    for( size_t i = 0; i < num_entities; ++i )
    {
        rval = set_data( NULL, entities[i], value_ptr );MB_CHK_ERR( rval );
    }
 
    return MB_SUCCESS;
}
 
ErrorCode SparseTag::clear_data( SequenceManager* seqman,
                                 Error* /* error */,
                                 const Range& entities,
                                 const void* value_ptr,
                                 int value_len )
{
    if( value_len && value_len != get_size() )
    {
        MB_SET_ERR( MB_INVALID_SIZE, "Invalid data size " << get_size() << " specified for sparse tag " << get_name()
                                                          << " of size " << value_len );
    }
 
    ErrorCode rval = seqman->check_valid_entities( NULL, entities );MB_CHK_ERR( rval );
 
    Range::const_iterator i;
    for( i = entities.begin(); i != entities.end(); ++i )
    {
        rval = set_data( NULL, *i, value_ptr );MB_CHK_ERR( rval );
    }
 
    return MB_SUCCESS;
}
 
ErrorCode SparseTag::remove_data( SequenceManager*,
                                  Error* /* error */,
                                  const EntityHandle* entities,
                                  size_t num_entities )
{
    ErrorCode rval;
    for( size_t i = 0; i < num_entities; ++i )
    {
        rval = remove_data( NULL, entities[i] );
        if( MB_SUCCESS != rval ) return rval;
    }
 
    return MB_SUCCESS;
}
 
ErrorCode SparseTag::remove_data( SequenceManager*, Error* /* error */, const Range& entities )
{
    for( Range::const_iterator i = entities.begin(); i != entities.end(); ++i )
        if( MB_SUCCESS != remove_data( NULL, *i ) ) return MB_TAG_NOT_FOUND;
 
    return MB_SUCCESS;
}
 
ErrorCode SparseTag::tag_iterate( SequenceManager* seqman,
                                  Error* /* error */,
                                  Range::iterator& iter,
                                  const Range::iterator& end,
                                  void*& data_ptr,
                                  bool allocate )
{
    // Note: We are asked to returning a block of contiguous storage
    //       for some block of contiguous handles for which the tag
    //       storage is also contiguous. As sparse tag storage is
    //       never contiguous, all we can do is return a pointer to the
    //       data for the first entity.
 
    // If asked for nothing, successfully return nothing.
    if( iter == end ) return MB_SUCCESS;
 
    // Note: get_data_ptr will return the default value if the
    //       handle is not found, so test to make sure that the
    //       handle is valid.
    ErrorCode rval = seqman->check_valid_entities( NULL, &*iter, 1 );MB_CHK_ERR( rval );
 
    // Get pointer to tag storage for entity pointed to by iter
    const void* ptr = NULL;
    rval            = get_data_ptr( *iter, ptr );
    if( MB_SUCCESS == rval )
        data_ptr = const_cast< void* >( ptr );
    else if( get_default_value() && allocate )
    {
        ptr      = allocate_data( *iter, mData.end() );
        data_ptr = const_cast< void* >( ptr );
    }
    else
    {
        // If allocation was not requested, need to increment the iterator so that
        // the count can be computed properly
        if( get_default_value() && !allocate ) ++iter;
        // return not_found(get_name(), *iter);
    }
 
    // Increment iterator and return
    ++iter;
    return MB_SUCCESS;
}
 
template < class Container >
static inline void get_tagged( const SparseTag::MapType& mData, EntityType type, Container& output_range )
{
    SparseTag::MapType::const_iterator iter;
    typename Container::iterator hint = output_range.begin();
    if( MBMAXTYPE == type )
    {
        for( iter = mData.begin(); iter != mData.end(); ++iter )
            hint = output_range.insert( hint, iter->first );
    }
    else
    {
#ifdef MOAB_HAVE_UNORDERED_MAP
        for( iter = mData.begin(); iter != mData.end(); ++iter )
            if( TYPE_FROM_HANDLE( iter->first ) == type ) hint = output_range.insert( hint, iter->first );
#else
        iter                                   = mData.lower_bound( FIRST_HANDLE( type ) );
        SparseTag::MapType::const_iterator end = mData.lower_bound( LAST_HANDLE( type ) + 1 );
        for( ; iter != end; ++iter )
            hint = output_range.insert( hint, iter->first );
#endif
    }
}
 
template < class Container >
static inline void get_tagged( const SparseTag::MapType& mData,
                               Range::const_iterator begin,
                               Range::const_iterator end,
                               Container& output_range )
{
    typename Container::iterator hint = output_range.begin();
    for( Range::const_iterator i = begin; i != end; ++i )
        if( mData.find( *i ) != mData.end() ) hint = output_range.insert( hint, *i );
}
 
template < class Container >
static inline void get_tagged( const SparseTag::MapType& mData,
                               Container& entities,
                               EntityType type,
                               const Range* intersect )
{
    if( !intersect )
        get_tagged< Container >( mData, type, entities );
    else if( MBMAXTYPE == type )
        get_tagged< Container >( mData, intersect->begin(), intersect->end(), entities );
    else
    {
        std::pair< Range::iterator, Range::iterator > r = intersect->equal_range( type );
        get_tagged< Container >( mData, r.first, r.second, entities );
    }
}
 
//! Gets all entity handles that match a type and tag
ErrorCode SparseTag::get_tagged_entities( const SequenceManager*,
                                          Range& output_range,
                                          EntityType type,
                                          const Range* intersect ) const
{
    get_tagged( mData, output_range, type, intersect );
    return MB_SUCCESS;
}
 
//! Gets all entity handles that match a type and tag
ErrorCode SparseTag::num_tagged_entities( const SequenceManager*,
                                          size_t& output_count,
                                          EntityType type,
                                          const Range* intersect ) const
{
    InsertCount counter( output_count );
    get_tagged( mData, counter, type, intersect );
    output_count = counter.end();
    return MB_SUCCESS;
}
 
ErrorCode SparseTag::find_entities_with_value(
#ifdef MOAB_HAVE_UNORDERED_MAP
    const SequenceManager* seqman,
#else
    const SequenceManager*,
#endif
    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, "Invalid data size " << get_size() << " specified for sparse tag " << get_name()
                                                          << " of size " << value_bytes );
    }
 
    MapType::const_iterator iter, end;
#ifdef MOAB_HAVE_UNORDERED_MAP
    if( intersect_entities )
    {
        std::pair< Range::iterator, Range::iterator > r;
        if( type == MBMAXTYPE )
        {
            r.first  = intersect_entities->begin();
            r.second = intersect_entities->end();
        }
        else
        {
            r = intersect_entities->equal_range( type );
        }
 
        find_map_values_equal( *this, value, get_size(), r.first, r.second, mData, output_entities );
    }
    else if( type == MBMAXTYPE )
    {
        find_tag_values_equal( *this, value, get_size(), mData.begin(), mData.end(), output_entities );
    }
    else
    {
        Range tmp;
        seqman->get_entities( type, tmp );
        find_map_values_equal( *this, value, get_size(), tmp.begin(), tmp.end(), mData, output_entities );
    }
#else
    if( intersect_entities )
    {
        for( Range::const_pair_iterator p = intersect_entities->begin(); p != intersect_entities->end(); ++p )
        {
            iter = mData.lower_bound( p->first );
            end = mData.upper_bound( p->second );
            find_tag_values_equal( *this, value, get_size(), iter, end, output_entities );
        }
    }
    else
    {
        if( type == MBMAXTYPE )
        {
            iter = mData.begin();
            end = mData.end();
        }
        else
        {
            iter = mData.lower_bound( CREATE_HANDLE( type, MB_START_ID ) );
            end = mData.upper_bound( CREATE_HANDLE( type, MB_END_ID ) );
        }
        find_tag_values_equal( *this, value, get_size(), iter, end, output_entities );
    }
#endif
 
    return MB_SUCCESS;
}
 
bool SparseTag::is_tagged( const SequenceManager*, EntityHandle h ) const
{
    return mData.find( h ) != mData.end();
}
 
ErrorCode SparseTag::get_memory_use( const SequenceManager*, unsigned long& total, unsigned long& per_entity ) const
 
{
    per_entity = get_size() + 4 * sizeof( void* );
    total      = ( mData.size() * per_entity ) + sizeof( *this ) + TagInfo::get_memory_use();
 
    return MB_SUCCESS;
}
 
}  // namespace moab