TagInfo.hpp

Go to the documentation of this file.

#ifndef TAG_INFO_HPP
#define TAG_INFO_HPP

#include "moab/Range.hpp"
#include <string>

namespace moab {

class SequenceManager;
class Range;
class Error;

// ! stores information about a tag
class TagInfo
{
public:

  TagInfo() : mDefaultValue(0),
              mDefaultValueSize(0),
              mDataSize(0), 
              dataType(MB_TYPE_OPAQUE)
              {}

  TagInfo( const char * name, 
           int size, 
           DataType type, 
           const void * default_value,
           int default_value_size);
  
  virtual ~TagInfo();

  virtual ErrorCode release_all_data( SequenceManager* seqman,
                                      Error* error_handler,
                                      bool tag_delete_pending ) = 0;
  
  void set_name( const std::string& name) { mTagName = name; }

  const std::string& get_name() const { return mTagName; }

  int get_default_value_size() const { return mDefaultValueSize; }

  const void *get_default_value() const { return mDefaultValue; }
  
  bool equals_default_value( const void* data, int size = -1 ) const;
  
  inline DataType get_data_type() const     { return dataType; }

  int get_size() const { return mDataSize; }
  
  bool variable_length() const { return get_size() == MB_VARIABLE_LENGTH; }

  static int size_from_data_type( DataType t );
  
    // Check that all lengths are valid multiples of the type size.
    // Returns true if all lengths are valid, false othersize.
  bool check_valid_sizes( const int* sizes, int num_sizes ) const;

  ErrorCode validate_lengths( Error* error_handler,
                              const int* lengths, 
                              size_t num_lengths ) const;

  virtual
  TagType get_storage_type() const = 0;

  virtual
  ErrorCode get_data( const SequenceManager* seqman,
                      Error* error_handler,
                      const EntityHandle* entities,
                      size_t num_entities,
                      void* data ) const = 0;
  
  virtual
  ErrorCode get_data( const SequenceManager* seqman,
                      Error* error_handler,
                      const Range& entities,
                      void* data ) const = 0;
                      
  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 = 0;
                      
                      
  virtual
  ErrorCode get_data( const SequenceManager* seqman,
                      Error* error_handler,
                      const Range& entities,
                      const void** data_ptrs,
                      int* data_lengths ) const = 0;
  
  virtual
  ErrorCode set_data( SequenceManager* seqman,
                      Error* error_handler,
                      const EntityHandle* entities,
                      size_t num_entities,
                      const void* data ) = 0;
  
  virtual
  ErrorCode set_data( SequenceManager* seqman,
                      Error* error_handler,
                      const Range& entities,
                      const void* data ) = 0;
                      
  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 ) = 0;
                      
                      
  virtual
  ErrorCode set_data( SequenceManager* seqman,
                      Error* error_handler,
                      const Range& entities,
                      void const* const* data_ptrs,
                      const int* data_lengths ) = 0;
                      
  virtual
  ErrorCode clear_data( SequenceManager* seqman,
                        Error* error_handler,
                        const EntityHandle* entities,
                        size_t num_entities,
                        const void* value_ptr,
                        int value_len = 0 ) = 0;
                      
  virtual
  ErrorCode clear_data( SequenceManager* seqman,
                        Error* error_handler,
                        const Range& entities,
                        const void* value_ptr,
                        int value_len = 0 ) = 0;

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

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

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

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

  virtual
  ErrorCode num_tagged_entities( const SequenceManager* seqman,
                                 size_t& output_count,
                                 EntityType type = MBMAXTYPE,
                                 const Range* intersect = 0 ) const = 0;
  
  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 = 0;
  
  virtual
  bool is_tagged( const SequenceManager* seqman, EntityHandle entity ) const = 0;
  
  virtual
  ErrorCode get_memory_use( const SequenceManager* seqman,
                            unsigned long& total,
                            unsigned long& per_entity ) const = 0;

protected:    

  unsigned long get_memory_use() const
  {
    return get_default_value_size() + get_name().size();
  }

private:
  
  TagInfo( const TagInfo& copy );
  
  TagInfo& operator=( const TagInfo& copy );

  void* mDefaultValue;
  
  void* mMeshValue;
  
  int mDefaultValueSize, mMeshValueSize;

  int mDataSize;
  
  DataType dataType;

  std::string mTagName;
};

} // namespace moab

#endif // TAG_INFO_HPP