VarLenSparseTag.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 "VarLenSparseTag.hpp"
#include "moab/Range.hpp"
#include "TagCompare.hpp"
#include "SequenceManager.hpp"
#include "moab/Error.hpp"
#include "moab/ErrorHandler.hpp"
#include "moab/CN.hpp"

namespace moab
{

VarLenSparseTag::VarLenSparseTag( const char* name, DataType type, const void* default_value, int default_value_bytes )
    : TagInfo( name, MB_VARIABLE_LENGTH, type, default_value, default_value_bytes )
{
}

VarLenSparseTag::~VarLenSparseTag()
{
    release_all_data( 0, 0, true );
}

TagType VarLenSparseTag::get_storage_type() const
{
    return MB_TAG_SPARSE;
}

ErrorCode VarLenSparseTag::release_all_data( SequenceManager*, Error*, bool )
{
    mData.clear();
    return MB_SUCCESS;
}

ErrorCode VarLenSparseTag::get_data_ptr( Error* /* error */,
                                         EntityHandle entity_handle,
                                         const void*& ptr,
                                         int& length ) const
{
    MapType::const_iterator iter = mData.find( entity_handle );

    if( iter != mData.end() )
    {
        ptr    = iter->second.data();
        length = iter->second.size();
    }
    else if( get_default_value() )
    {
        ptr    = get_default_value();
        length = get_default_value_size();
    }
    else
        return MB_TAG_NOT_FOUND;

    return MB_SUCCESS;
}

ErrorCode VarLenSparseTag::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 VarLenSparseTag::get_data( const SequenceManager*,
                                     Error* /* error */,
                                     const Range& /*entities*/,
                                     void* /* data */ ) const
{
    MB_SET_ERR( MB_VARIABLE_DATA_LENGTH, "No size specified for variable-length tag " << get_name() << " data" );
}

ErrorCode VarLenSparseTag::get_data( const SequenceManager*,
                                     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 rval;
    for( size_t i = 0; i < num_entities; ++i )
    {
        rval = get_data_ptr( NULL, entities[i], pointers[i], lengths[i] );
        if( rval != MB_SUCCESS ) return rval;
    }

    return MB_SUCCESS;
}

ErrorCode VarLenSparseTag::get_data( const SequenceManager*,
                                     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;
    Range::const_iterator i;
    for( i = entities.begin(); i != entities.end(); ++i, ++pointers, ++lengths )
    {
        rval = get_data_ptr( NULL, *i, *pointers, *lengths );
        if( rval != MB_SUCCESS ) return rval;
    }

    return MB_SUCCESS;
}

ErrorCode VarLenSparseTag::set_data( SequenceManager* /* seqman */,
                                     Error* /* error */,
                                     const EntityHandle* /* entities */,
                                     size_t /* num_entities */,
                                     const void* /* data */ )
{
    MB_SET_ERR( MB_VARIABLE_DATA_LENGTH, "No size specified for variable-length tag " << get_name() << " data" );
}

ErrorCode VarLenSparseTag::set_data( SequenceManager* /* seqman */,
                                     Error* /* error */,
                                     const Range& /* entities */,
                                     const void* /* data */ )
{
    MB_SET_ERR( MB_VARIABLE_DATA_LENGTH, "No size specified for variable-length tag " << get_name() << " data" );
}

ErrorCode VarLenSparseTag::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 )
    {
        if( lengths[i] )
            mData[entities[i]].set( pointers[i], lengths[i] );
        else
        {
            MapType::iterator iter = mData.find( entities[i] );
            if( iter != mData.end() )
            {
                iter->second.clear();
                mData.erase( iter );
            }
        }
    }

    return MB_SUCCESS;
}

ErrorCode VarLenSparseTag::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, ++lengths )
    {
        if( *lengths )
            mData[*i].set( *pointers, *lengths );
        else
        {
            MapType::iterator iter = mData.find( *i );
            if( iter != mData.end() )
            {
                iter->second.clear();
                mData.erase( iter );
            }
        }
    }

    return MB_SUCCESS;
}

ErrorCode VarLenSparseTag::clear_data( SequenceManager* seqman,
                                       Error* /* error */,
                                       const EntityHandle* entities,
                                       size_t num_entities,
                                       const void* value_ptr,
                                       int value_len )
{
    if( 0 == value_len )
    {
        remove_data( seqman, 0, entities, num_entities );
        return MB_SUCCESS;
    }

    ErrorCode rval = validate_lengths( NULL, &value_len, 1 );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 )
        mData[entities[i]].set( value_ptr, value_len );

    return MB_SUCCESS;
}

ErrorCode VarLenSparseTag::clear_data( SequenceManager* seqman,
                                       Error* /* error */,
                                       const Range& entities,
                                       const void* value_ptr,
                                       int value_len )
{
    if( 0 == value_len )
    {
        remove_data( seqman, 0, entities );
        return MB_SUCCESS;
    }

    ErrorCode rval = validate_lengths( NULL, &value_len, 1 );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 )
        mData[*i].set( value_ptr, value_len );

    return MB_SUCCESS;
}

ErrorCode VarLenSparseTag::remove_data( SequenceManager*,
                                        Error* /* error */,
                                        const EntityHandle* entities,
                                        size_t num_entities )
{
    ErrorCode result = MB_SUCCESS;
    for( size_t i = 0; i < num_entities; ++i )
    {
        MapType::iterator p = mData.find( entities[i] );
        if( p == mData.end() )
            return MB_TAG_NOT_FOUND;
        else
        {
            p->second.clear();
            mData.erase( p );
        }
    }

    return result;
}

ErrorCode VarLenSparseTag::remove_data( SequenceManager*, Error* /* error */, const Range& entities )
{
    ErrorCode result = MB_SUCCESS;
    for( Range::iterator i = entities.begin(); i != entities.end(); ++i )
    {
        MapType::iterator p = mData.find( *i );
        if( p == mData.end() )
            return MB_TAG_NOT_FOUND;
        else
        {
            p->second.clear();
            mData.erase( p );
        }
    }

    return result;
}

ErrorCode VarLenSparseTag::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 void get_tagged( const VarLenSparseTag::MapType& mData, EntityType type, Container& output_range )
{
    VarLenSparseTag::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 ) );
        VarLenSparseTag::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 VarLenSparseTag::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 VarLenSparseTag::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 VarLenSparseTag::get_tagged_entities( const SequenceManager*,
                                                Range& entities,
                                                EntityType type,
                                                const Range* intersect ) const
{
    get_tagged( mData, entities, type, intersect );
    return MB_SUCCESS;
}

//! Gets all entity handles that match a type and tag
ErrorCode VarLenSparseTag::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 VarLenSparseTag::find_entities_with_value(
#ifdef MOAB_HAVE_UNORDERED_MAP
    const SequenceManager* seqman,
#else
    const SequenceManager*,
#endif
    Error*,
    Range& output_entities,
    const void* value,
    int value_bytes,
    const EntityType type,
    const Range* intersect_entities ) const
{
    if( value_bytes && value_bytes != get_size() ) return MB_INVALID_SIZE;

    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_varlen_values_equal( *this, value, get_size(), r.first, r.second, mData, output_entities );
    }
    else if( type == MBMAXTYPE )
    {
        find_tag_varlen_values_equal( *this, value, get_size(), mData.begin(), mData.end(), output_entities );
    }
    else
    {
        Range tmp;
        seqman->get_entities( type, tmp );
        find_map_varlen_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_varlen_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_varlen_values_equal( *this, value, get_size(), iter, end, output_entities );
    }
#endif

    return MB_SUCCESS;
}

bool VarLenSparseTag::is_tagged( const SequenceManager*, EntityHandle h ) const
{
    return mData.find( h ) != mData.end();
}

ErrorCode VarLenSparseTag::get_memory_use( const SequenceManager*,
                                           unsigned long& total,
                                           unsigned long& per_entity ) const
{
    total = mData.size() * ( 3 * sizeof( void* ) + sizeof( VarLenTag ) );
    for( MapType::const_iterator i = mData.begin(); i != mData.end(); ++i )
        total += i->second.mem();
    if( !mData.empty() ) per_entity = total / mData.size();
    total += sizeof( *this ) + TagInfo::get_memory_use();

    return MB_SUCCESS;
}

}  // namespace moab