BitTag.hpp

Go to the documentation of this file.

#ifndef BIT_TAG_HPP
#define BIT_TAG_HPP

#include "TagInfo.hpp"
#include "Internals.hpp"
#include <algorithm>
#include <vector>
#include <assert.h>

namespace moab {

class BitPage;

class BitTag : public TagInfo
{
  private:
  
  BitTag( const char* name,
          int size,
          const void* default_value )
    : TagInfo( name, size, MB_TYPE_BIT, default_value, default_value ? 1 : 0 )
    {}
  
  public: 
  
  static BitTag* create_tag( const char* name,
                             int size,
                             const void* default_value = 0 );
  
  virtual ~BitTag();

  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;
  
  ErrorCode get_memory_use( const SequenceManager* seqman,
                            unsigned long& total,
                            unsigned long& per_entity ) const;

  ErrorCode get_entities_with_bits( EntityType type, 
                                      Range& entities,
                                      unsigned char bits ) const;

  ErrorCode get_entities_with_bits( const Range &range,
                                      EntityType type, 
                                      Range& entities,
                                      unsigned char bits ) const;
                              
  enum { Ln2PageSize = 12,              
         PageSize = (1u << Ln2PageSize) 
      };

  private:
  
  BitTag( const BitTag& );
  BitTag& operator=( const BitTag& );
  ErrorCode reserve( unsigned bits );
  
  inline unsigned char default_val() const {
    if (get_default_value())
      return *reinterpret_cast<const unsigned char*>(get_default_value());
    else
      return 0;
  }
  
  std::vector<BitPage*> pageList[MBMAXTYPE]; 
  unsigned int requestedBitsPerEntity; 
  unsigned int storedBitsPerEntity;    
  unsigned int pageShift;              
  
  void unpack( EntityHandle h, EntityType& type, size_t& page, int& offset ) const
    { 
      type = TYPE_FROM_HANDLE(h);
      h = ID_FROM_HANDLE(h);
      page = ((size_t)h) >> pageShift;   // h / ents_per_page()
      offset = h & ((1u<<pageShift)-1u); // h % ends_per_page()
    }
    
  int ents_per_page() const { return 8*PageSize/storedBitsPerEntity; }
  
  template <class Container> inline 
  void get_tagged( EntityType type,
                   Container& entities ) const;
  template <class Container> inline 
  void get_tagged( Range::const_iterator begin,
                   Range::const_iterator end,
                   Container& entities ) const;
  template <class Container> inline 
  void get_tagged( Container& entities,
                   EntityType type,
                   const Range* intersect ) const;
};
  
} // namespace moab

#endif