SequenceData.hpp

Go to the documentation of this file.

#ifndef SEQUENCE_DATA_HPP
#define SEQUENCE_DATA_HPP


#include "TypeSequenceManager.hpp"

#include <vector>
#include <stdlib.h>
#include <string.h>

namespace moab {

class SequenceData
{
public:

  typedef std::vector<EntityHandle>* AdjacencyDataType;

  inline SequenceData( int num_sequence_arrays, 
                       EntityHandle start,
                       EntityHandle end );
  
  virtual ~SequenceData();
  
  EntityHandle start_handle() const 
    { return startHandle; }
  
  EntityHandle end_handle() const
    { return endHandle; }
    
  EntityID size() const
    { return endHandle + 1 - startHandle; }
  
  void*       get_sequence_data( int array_num )       
                { return arraySet[-1-array_num]; }
  void const* get_sequence_data( int array_num ) const 
                { return arraySet[-1-array_num]; }
  
  AdjacencyDataType*       get_adjacency_data( )       
                { return reinterpret_cast<AdjacencyDataType*>(arraySet[0]); }
  AdjacencyDataType const* get_adjacency_data( ) const 
                { return reinterpret_cast<AdjacencyDataType const*>(arraySet[0]); }
  
  void*       get_tag_data( unsigned tag_num )              
                { return tag_num < numTagData  ? arraySet[tag_num+1] : 0; }
  void const* get_tag_data( unsigned tag_num ) const        
                { return tag_num < numTagData  ? arraySet[tag_num+1] : 0; }
  
  void* create_sequence_data( int array_num, 
                              int bytes_per_ent,
                              const void* initial_val = 0 );
                             
  void* create_custom_data( int array_num, size_t total_bytes );
  
  AdjacencyDataType* allocate_adjacency_data();
  
  void* allocate_tag_array( int index, int bytes_per_ent, const void* default_value = 0 );
  
  SequenceData* subset( EntityHandle start, 
                        EntityHandle end,
                        const int* sequence_data_sizes ) const;
  
  TypeSequenceManager::SequenceDataPtr seqManData;
  
  void move_tag_data( SequenceData* destination, const int* tag_sizes, int num_tag_sizes );
  
  void release_tag_data(const int* tag_sizes, int num_tag_sizes);
  void release_tag_data( int index, int tag_size );
  
protected:

  SequenceData( const SequenceData* subset_from,
                EntityHandle start, 
                EntityHandle end,
                const int* sequence_data_sizes );

private:

  void increase_tag_count( unsigned by_this_many );

  void* create_data( int index, int bytes_per_ent, const void* initial_val = 0 );
  void copy_data_subset( int index, 
                         int size_per_ent, 
                         const void* source, 
                         size_t offset, 
                         size_t count );

  const int numSequenceData;
  unsigned numTagData;
  void** arraySet;
  EntityHandle startHandle, endHandle;
};

inline SequenceData::SequenceData( int num_sequence_arrays, 
                                   EntityHandle start,
                                   EntityHandle end )
  : numSequenceData(num_sequence_arrays),
    numTagData(0),
    startHandle(start),
    endHandle(end)
{
  const size_t sz = sizeof(void*) * (num_sequence_arrays + 1);
  void** data = (void**)malloc( sz );
  memset( data, 0, sz );
  arraySet = data + num_sequence_arrays;
}

} // namespace moab

#endif