SequenceManager.hpp

Go to the documentation of this file.

#ifndef SEQUENCE_MANAGER_HPP
#define SEQUENCE_MANAGER_HPP

#include "TypeSequenceManager.hpp"
#include "TagInfo.hpp"
#include <vector>

namespace moab {

class HomCoord;
class Error;

class SequenceManager 
{
  public:
    
    ~SequenceManager();
    
    void clear();
    
    ErrorCode find( EntityHandle handle, EntitySequence*& sequence_out )
      { 
        return typeData[TYPE_FROM_HANDLE(handle)].find( handle, sequence_out );
      }
    
    ErrorCode find( EntityHandle handle, const EntitySequence*& sequence_out ) const
      { 
        return typeData[TYPE_FROM_HANDLE(handle)].find( handle, sequence_out );
      }
    
    void get_entities( EntityType type, Range& entities_out ) const
      { 
        if (type == MBMAXTYPE)
          get_entities( entities_out );
        else
          typeData[type].get_entities( entities_out ); 
      }

    void get_entities( Range& entities_out ) const;
    
    void get_entities( EntityType type, std::vector<EntityHandle>& entities_out ) const
      { 
        if (type == MBMAXTYPE)
          get_entities( entities_out );
        else
          typeData[type].get_entities( entities_out ); 
      }
    
    void get_entities( std::vector<EntityHandle>& entities_out ) const;
    
    EntityID get_number_entities( EntityType type ) const
      { return type == MBMAXTYPE ? get_number_entities() : typeData[type].get_number_entities(); }
    
    EntityID get_number_entities( ) const;
      
    const EntitySequence* get_last_accessed_sequence( EntityType type ) const
      { return typeData[type].get_last_accessed(); }
    
    ErrorCode replace_subsequence( EntitySequence* new_seq );
    
    ErrorCode check_valid_entities( Error* error_handler, 
                                    const Range& entities ) const;
    
    ErrorCode check_valid_entities( Error* error_handler,
                                    const EntityHandle entities[],
                                    size_t num_entities,
                                    bool root_set_okay = false ) const;
    
    ErrorCode delete_entity( Error* error_handler, EntityHandle entity );
    
    ErrorCode delete_entities( Error* error_handler, const Range& entities );
    
    ErrorCode create_vertex( const double coords[3],
                               EntityHandle& handle_out );
    
    ErrorCode create_element( EntityType type,
                                const EntityHandle* conn_array,
                                unsigned num_vertices,
                                EntityHandle& handle_out );
    
    ErrorCode create_mesh_set( unsigned flags,
                                 EntityHandle& handle_out );
    ErrorCode allocate_mesh_set( EntityHandle at_this_handle,
                                   unsigned flags );
    
    ErrorCode create_entity_sequence( EntityType type,
                                      EntityID num_entities,
                                      int nodes_per_entity,
                                      EntityID start_id_hint,
                                      EntityHandle& first_handle_out,
                                      EntitySequence*& sequence_out,
                                      int sequence_size);
    
    ErrorCode create_meshset_sequence( EntityID num_sets,
                                         EntityID start_id_hint,
                                         const unsigned* flags,
                                         EntityHandle& first_handle_out,
                                         EntitySequence*& sequence_out );
    
    ErrorCode create_meshset_sequence( EntityID num_sets,
                                         EntityID start_id_hint,
                                         unsigned flags,
                                         EntityHandle& first_handle_out,
                                         EntitySequence*& sequence_out );
    
    ErrorCode create_scd_sequence( int imin, int jmin, int kmin,
                                     int imax, int jmax, int kmax,
                                     EntityType type,
                                     EntityID start_id_hint,
                                     EntityHandle& first_handle_out,
                                   EntitySequence*& sequence_out,
                                   int *is_periodic = NULL);
    
    ErrorCode create_scd_sequence( const HomCoord& coord_min,
                                     const HomCoord& coord_max,
                                     EntityType type,
                                     EntityID start_id_hint,
                                     EntityHandle& first_handle_out,
                                     EntitySequence*& sequence_out,
                                   int *is_periodic = NULL);

    ErrorCode create_sweep_sequence( int imin, int jmin, int kmin,
                       int imax, int jmax, int kmax,
                       int* Cq,
                       EntityType type,
                       EntityID start_id_hint,
                       EntityHandle& first_handle_out,
                       EntitySequence*& sequence_out );
    
    ErrorCode create_sweep_sequence( const HomCoord& coord_min,
                       const HomCoord& coord_max,
                       int* Cq,
                       EntityType type,
                       EntityID start_id_hint,
                       EntityHandle& first_handle_out,
                       EntitySequence*& sequence_out );

  ErrorCode add_vsequence(EntitySequence *vert_seq,
                            EntitySequence *elem_seq,
                            const HomCoord &p1, const HomCoord &q1,
                            const HomCoord &p2, const HomCoord &q2,
                            const HomCoord &p3, const HomCoord &q3,
                            bool bb_input = false,
                            const HomCoord *bb_min = NULL,
                            const HomCoord *bb_max = NULL);

    TypeSequenceManager& entity_map( EntityType type )
      { return typeData[type]; }
    
    const TypeSequenceManager& entity_map( EntityType type ) const
      { return typeData[type]; }
    
    void get_memory_use( unsigned long& total_entity_storage,
                         unsigned long& total_storage ) const;
                         
    void get_memory_use( EntityType type,
                         unsigned long& total_entity_storage,
                         unsigned long& total_storage ) const;
    
    void get_memory_use( const Range& entities,
                         unsigned long& total_entity_storage,
                         unsigned long& total_amortized_storage ) const;
    
  
  
    /* Dense Tag Functions */
    
    ErrorCode reserve_tag_array( Error* error_handler, int tag_size, int& array_id_out );
    
    ErrorCode release_tag_array( Error* error_handler, int id, bool release_id );
    
    static EntityID default_poly_sequence_size( int entity_connectivity_length );
    
    EntityID new_sequence_size( EntityHandle start_handle, 
                                EntityID requested_size,
                                int sequence_size) const;
  
  static const EntityID DEFAULT_VERTEX_SEQUENCE_SIZE;
  
  static const EntityID DEFAULT_ELEMENT_SEQUENCE_SIZE;

  static const EntityID DEFAULT_POLY_SEQUENCE_SIZE;

  static const EntityID DEFAULT_MESHSET_SEQUENCE_SIZE;

  private:
   
    void trim_sequence_block( EntityHandle start_handle,
                              EntityHandle& end_handle_in_out,
                              unsigned maximum_sequence_size );
  
  
    EntityHandle sequence_start_handle( EntityType type,
                                          EntityID entity_count,
                                          int values_per_entity,
                                          EntityID start_id_hint,
                                          SequenceData*& data_out,
                                          EntityID &data_size );
  
    TypeSequenceManager typeData[MBMAXTYPE];
    
    std::vector<int> tagSizes;

};

} // namespace moab

#endif