SparseTag.hpp

Go to the documentation of this file.

#ifndef SPARSE_TAG_HPP
#define SPARSE_TAG_HPP

#ifndef IS_BUILDING_MB
#error "SparseTag.hpp isn't supposed to be included into an application"
#endif

#ifdef WIN32
#pragma warning(disable : 4786)
#endif


#define STRINGIFY_(X) #X
#define STRINGIFY(X) STRINGIFY_(X)
#ifdef HAVE_UNORDERED_MAP
# include STRINGIFY(HAVE_UNORDERED_MAP)
#else
# include <map>
#endif
#include <vector>

#include "TagInfo.hpp"
#include <stdlib.h>

namespace moab {

class SparseTagDataAllocator
{
public:
  SparseTagDataAllocator(){}
  ~SparseTagDataAllocator(){}
  void* allocate(size_t data_size) { return malloc(data_size); }
  void destroy(void* p){ free(p); }
};


class SparseTag : public TagInfo
{
public:
  
  SparseTag( const char* name,
             int size,
             DataType type,
             const void* default_value );
  
  ~SparseTag();

  virtual TagType get_storage_type() const;

  virtual ErrorCode release_all_data( SequenceManager* seqman, 
                                      Error* error_handler, 
                                      bool delete_pending );
  

  virtual
  ErrorCode get_data( const SequenceManager* seqman,
                      Error* error_handler, 
                      const EntityHandle* entities,
                      size_t num_entities,
                      void* data ) const;
  
  virtual
  ErrorCode get_data( const SequenceManager* seqman,
                      Error* error_handler, 
                      const Range& entities,
                      void* data ) const;
                      
  virtual
  ErrorCode get_data( const SequenceManager* seqman,
                      Error* error_handler, 
                      const EntityHandle* entities,
                      size_t num_entities,
                      const void** data_ptrs,
                      int* data_lengths ) const ;
                      
                      
  virtual
  ErrorCode get_data( const SequenceManager* seqman,
                      Error* error_handler, 
                      const Range& entities,
                      const void** data_ptrs,
                      int* data_lengths ) const;
  
  virtual
  ErrorCode set_data( SequenceManager* seqman,
                      Error* error_handler, 
                      const EntityHandle* entities,
                      size_t num_entities,
                      const void* data );
  
  virtual
  ErrorCode set_data( SequenceManager* seqman,
                      Error* error_handler, 
                      const Range& entities,
                      const void* data );
                      
  virtual
  ErrorCode set_data( SequenceManager* seqman,
                      Error* error_handler, 
                      const EntityHandle* entities,
                      size_t num_entities,
                      void const* const* data_ptrs,
                      const int* data_lengths );
                      
                      
  virtual
  ErrorCode set_data( SequenceManager* seqman,
                      Error* error_handler, 
                      const Range& entities,
                      void const* const* data_ptrs,
                      const int* data_lengths );
                      
  virtual
  ErrorCode clear_data( SequenceManager* seqman,
                        Error* error_handler, 
                        const EntityHandle* entities,
                        size_t num_entities,
                        const void* value_ptr,
                        int value_len = 0 );
                      
  virtual
  ErrorCode clear_data( SequenceManager* seqman,
                        Error* error_handler, 
                        const Range& entities,
                        const void* value_ptr,
                        int value_len = 0 );

  virtual ErrorCode remove_data( SequenceManager* seqman,
                                 Error* error_handler, 
                                 const EntityHandle* entities,
                                 size_t num_entities );

  virtual ErrorCode remove_data( SequenceManager* seqman,
                                 Error* error_handler, 
                                 const Range& entities );

  virtual
  ErrorCode tag_iterate( SequenceManager* seqman,
                         Error* error_handler, 
                         Range::iterator& iter,
                         const Range::iterator& end,
                         void*& data_ptr,
                         bool allocate = true);

  virtual
  ErrorCode get_tagged_entities( const SequenceManager* seqman,
                                 Range& output_entities,
                                 EntityType type = MBMAXTYPE,
                                 const Range* intersect = 0 ) const;

  virtual
  ErrorCode num_tagged_entities( const SequenceManager* seqman,
                                 size_t& output_count,
                                 EntityType type = MBMAXTYPE,
                                 const Range* intersect = 0 ) const;
  
  virtual
  ErrorCode find_entities_with_value( const SequenceManager* seqman,
                                      Error* error_handler, 
                                      Range& output_entities,
                                      const void* value,
                                      int value_bytes = 0,
                                      EntityType type = MBMAXTYPE,
                                      const Range* intersect_entities = 0 ) const;
  
  virtual bool is_tagged( const SequenceManager*, EntityHandle h ) const;
 
  virtual
  ErrorCode get_memory_use( const SequenceManager* seqman,
                            unsigned long& total,
                            unsigned long& per_entity ) const;

  unsigned long get_number_entities()
    { return mData.size(); }


#ifdef HAVE_UNORDERED_MAP
  typedef UNORDERED_MAP_NS::unordered_map<EntityHandle,void*> MapType;
#else
  typedef std::map<EntityHandle,void*> MapType;
#endif

private:
  
  SparseTag( const SparseTag& );
  SparseTag& operator=( const SparseTag& );

  inline void *allocate_data(EntityHandle h, MapType::const_iterator iter, bool copy_default = true);
  
  inline
  ErrorCode set_data(Error*, EntityHandle entity_handle, const void* data);

  inline
  ErrorCode get_data(Error*, EntityHandle entity_handle, void* data) const;

  inline
  ErrorCode get_data_ptr(EntityHandle entity_handle, const void*& data, bool allocate = true) const;

  inline
  ErrorCode remove_data(Error*, EntityHandle entity_handle);

  SparseTagDataAllocator mAllocator;

  MapType mData;
};

inline void *SparseTag::allocate_data(EntityHandle h, MapType::const_iterator iter, bool copy_default) 
{
  void* new_data = mAllocator.allocate(get_size());
#ifdef HAVE_UNORDERED_MAP
  mData.insert(iter, std::pair<const EntityHandle,void*>(h, new_data));
#else
  mData[h] = new_data;
#endif
  if (copy_default)
    memcpy(new_data, get_default_value(), get_size());
  return new_data;
}

} // namespace moab

#endif // SPARSE_TAG_HPP