PreMultiContainer.hh

Go to the documentation of this file.

#ifndef PRE_MULTICONTAINER_HH
  #define PRE_MULTICONTAINER_HH

  #include <openmodeller/Log.hh>
  #include <openmodeller/Exceptions.hh>
  
  #include <time.h>
  
  #include <vector>
  #include <map>
  #include <typeinfo>

  //adapted from Terralib PDI (Digital Image Processing) to OM Pre-analysis ( Missae & Emiliano - DPI/INPE )
  //Multi-container node interface.
  //author Emiliano F. Castejon <castejon@dpi.inpe.br>
  template< typename PreMultiContainerKeyT >
  class MCNodeInterface {
    public :
    
      //Default Constructor.    
      MCNodeInterface() {};
      
      //Default Destructor.  
      virtual ~MCNodeInterface() {};
      
      virtual MCNodeInterface< PreMultiContainerKeyT >* clone() 
        const = 0;
        
      virtual const std::string& getObjTypeInfo() const = 0;
      
    private :
    
      //Alternative constructor.  
      MCNodeInterface( 
        const MCNodeInterface< PreMultiContainerKeyT >& ) {};    
    
      const MCNodeInterface< PreMultiContainerKeyT >& operator=( 
        const MCNodeInterface< PreMultiContainerKeyT >& ) {};        
  };

  //adapted from Terralib PDI (Digital Image Processing) to OM Pre-analysis ( Missae & Emiliano - DPI/INPE )
  // Multi-container node class.
  //author Emiliano F. Castejon <castejon@dpi.inpe.br>
  template< typename ObjectT, typename PreMultiContainerKeyT >
  class MCNode : public MCNodeInterface< PreMultiContainerKeyT > {
    public :
    
      //Default Constructor.
      MCNode() 
      {
        obj_ptr_ = 0;
      };
      
      //Default Destructor.
      ~MCNode()
      {
        if( obj_ptr_ ) {
          delete obj_ptr_;
        }
      };
      
      MCNodeInterface< PreMultiContainerKeyT >* clone() const
      {
        MCNode< ObjectT, PreMultiContainerKeyT >* new_node_ptr =
          new MCNode< ObjectT, PreMultiContainerKeyT >;
          
        if( obj_ptr_ ) {
          new_node_ptr->obj_ptr_ = new ObjectT;
          ( *( new_node_ptr->obj_ptr_ ) ) = ( *obj_ptr_ );
          
          new_node_ptr->obj_type_str_ = obj_type_str_;
        }
        
        return new_node_ptr;
      };
      
      void setObjPtr( ObjectT* ptr ) 
      { 
    if( !ptr ) {
      std::string msg = "MCNode::setObjPtr: Invalid pointer.\n";
      Log::instance()->error( msg.c_str() );
      throw InvalidParameterException( msg );
    }
        
        if( obj_ptr_ ) {
          delete obj_ptr_;
        }      
      
        obj_ptr_ = ptr;
        obj_type_str_ = std::string( typeid( *ptr ).name() );
      };
      
      ObjectT* getObjPtr() const
      { 
        return obj_ptr_; 
      };
      
      const std::string& getObjTypeInfo() const
      { 
        return obj_type_str_; 
      };      
      
    protected :
      
 
      //The internal object pointer.
      ObjectT* obj_ptr_;
      
      //The internal object type.
      std::string obj_type_str_;      
      
  }; 

  //adapted from Terralib PDI (Digital Image Processing) to OM Pre-analysis ( Missae & Emiliano - DPI/INPE )
  //A container class to store multiple types os object copies.
  //author Emiliano F. Castejon <castejon@dpi.inpe.br>
  //note: This is a thread-safe class.
  //note: Do not use this class with polymorphic types !!
  template< typename PreMultiContainerKeyT >
  class PreMultiContainer {
  
    public :
    
      //brief Default Constructor
      PreMultiContainer();
      
      //Alternative Constructor
      //external: External reference.
      PreMultiContainer( 
        const PreMultiContainer< PreMultiContainerKeyT >& external );      

      //Default Destructor
      ~PreMultiContainer();
                           
      bool operator==( 
        const PreMultiContainer< PreMultiContainerKeyT >& ext_instance ) const;
      
      bool operator!=( 
        const PreMultiContainer< PreMultiContainerKeyT >& ext_instance ) const;
      
      const PreMultiContainer< PreMultiContainerKeyT >& operator=( 
        const PreMultiContainer< PreMultiContainerKeyT >& ext_instance );
      
      //Clear all contents.
      void clear();
                         
      template< typename ObjectT >
      void store( const PreMultiContainerKeyT& obj_key,
                         const ObjectT& obj_reference );
      
      template< typename ObjectT >
      bool retrieve( const PreMultiContainerKeyT& obj_key,
        ObjectT& obj_reference ) const;
        
      template< typename ObjectT >
      void multiRetrieve( std::vector< std::pair< PreMultiContainerKeyT, 
        ObjectT > >& objs_vector ) const;        
     
      template< typename ObjectT >
      bool isStored( const PreMultiContainerKeyT& obj_key ) const;
      
      void remove( const PreMultiContainerKeyT& obj_key );      
      
    protected :

      //Internal container type definition. 
      typedef typename std::map< PreMultiContainerKeyT,
        MCNodeInterface< PreMultiContainerKeyT >* > IntContainerT;
      
      //The nodes container instance. 
      IntContainerT container_instance_;    
      
      //The last update time.
      time_t last_up_time_;

      void update_time();            

};

template< typename PreMultiContainerKeyT >
PreMultiContainer< PreMultiContainerKeyT >::PreMultiContainer()
{
  last_up_time_ = 0;
}

template< typename PreMultiContainerKeyT >
PreMultiContainer< PreMultiContainerKeyT >::PreMultiContainer( 
  const PreMultiContainer< PreMultiContainerKeyT >& external )
{
  last_up_time_ = 0;
  
  operator=( external );
}

template< typename PreMultiContainerKeyT >
PreMultiContainer< PreMultiContainerKeyT >::~PreMultiContainer()
{
  clear();
}

template< typename PreMultiContainerKeyT >
void PreMultiContainer< PreMultiContainerKeyT >::clear()
{
  
  typename IntContainerT::iterator it = container_instance_.begin();
  typename IntContainerT::iterator it_end = container_instance_.end();
  
  while( it != it_end ) {
    delete (it->second);
    
    ++it;
  }
  
  container_instance_.clear();
  
}

template< typename PreMultiContainerKeyT >
bool PreMultiContainer< PreMultiContainerKeyT >::operator==( 
  const PreMultiContainer< PreMultiContainerKeyT >& ext_instance ) const
{
  if( last_up_time_ == ext_instance.last_up_time_ ) {
    return true;
  } else {
    return false;
  }
}

template< typename PreMultiContainerKeyT >
bool PreMultiContainer< PreMultiContainerKeyT >::operator!=( 
  const PreMultiContainer< PreMultiContainerKeyT >& ext_instance ) 
  const
{
  if( last_up_time_ == ext_instance.last_up_time_ ) {
    return false;
  } else {
    return true;
  }
}

template< typename PreMultiContainerKeyT >
const PreMultiContainer< PreMultiContainerKeyT >& 
PreMultiContainer< PreMultiContainerKeyT >::operator=( 
  const PreMultiContainer< PreMultiContainerKeyT >& ext_instance )
{
  if( ( &ext_instance ) != this ) {
    
    //Clearing the current objects 
    
    typename IntContainerT::iterator my_container_it = 
      container_instance_.begin();
    typename IntContainerT::iterator my_container_it_end = 
      container_instance_.end();
    
    while( my_container_it != my_container_it_end ) {
      delete (my_container_it->second);
      
      ++my_container_it;
    }    
    
    container_instance_.clear();
    
    //Cloning external objects 
    
    typename IntContainerT::const_iterator container_it = 
      ext_instance.container_instance_.begin();
    typename IntContainerT::const_iterator container_it_end = 
      ext_instance.container_instance_.end();
          
    while( container_it != container_it_end ) {
      container_instance_[ container_it->first ] = 
        container_it->second->clone();
          
      ++container_it;
    }
  
    last_up_time_ = ext_instance.last_up_time_;
  
     
  }

  return *this;
}

template< typename PreMultiContainerKeyT >
void PreMultiContainer< PreMultiContainerKeyT >::update_time()
{
  last_up_time_ = time( 0 );
}

template< typename PreMultiContainerKeyT >
template< typename ObjectT >
void PreMultiContainer< PreMultiContainerKeyT >::store( 
  const PreMultiContainerKeyT& obj_key, const ObjectT& obj_reference )
{

  //Creating a new node 
  
  ObjectT* newobjptr = new ObjectT;
  ( *newobjptr ) = obj_reference;
  
  MCNode< ObjectT, PreMultiContainerKeyT >* newnodeptr =
    new MCNode< ObjectT, PreMultiContainerKeyT >;  
  newnodeptr->setObjPtr( newobjptr );
  
  typename IntContainerT::iterator container_it = 
    container_instance_.find( obj_key );
    
  //If a old node with the same key exists, it will be deleted 
    
  if( container_it == container_instance_.end() ) {
    container_instance_[ obj_key ] = newnodeptr;
  } else {
    delete (container_it->second);
    
    container_it->second = newnodeptr;
  }
      
  update_time();
  
}

template< typename PreMultiContainerKeyT >
template< typename ObjectT >
bool PreMultiContainer< PreMultiContainerKeyT >::retrieve(
  const PreMultiContainerKeyT& obj_key, ObjectT& obj_reference ) const
{
  
  typename IntContainerT::const_iterator container_it = 
    container_instance_.find( obj_key );
    
  if( container_it == container_instance_.end() ) {
    
    return false;
  } else {
    if( typeid( ObjectT ).name() == 
      container_it->second->getObjTypeInfo() ) {
      
      obj_reference = 
        ( *( ( (MCNode< ObjectT, PreMultiContainerKeyT >* )
        container_it->second )->getObjPtr() ) );
    
      return true;
    } else {
   
      return false;
    }
  }
}

template< typename PreMultiContainerKeyT >
template< typename ObjectT >
void PreMultiContainer< PreMultiContainerKeyT >::multiRetrieve(
  std::vector< std::pair< PreMultiContainerKeyT, 
  ObjectT > >& objs_vector ) const
{
  objs_vector.clear();
  
  typename IntContainerT::const_iterator container_it = 
    container_instance_.begin();
  typename IntContainerT::const_iterator container_it_end = 
    container_instance_.end();
  
  std::pair< PreMultiContainerKeyT, ObjectT > temp_pair;
  
  while( container_it != container_it_end ) {
    if( typeid( ObjectT ).name() == 
      container_it->second->getObjTypeInfo() ) {  
      
      temp_pair.first = container_it->first;
      temp_pair.second = 
        ( *( ( ( MCNode< ObjectT, PreMultiContainerKeyT >* )
        container_it->second )->getObjPtr() ) );
    
      objs_vector.push_back( temp_pair );      
    }  
  
    ++container_it;
  }
  
}

template< typename PreMultiContainerKeyT >
template< typename ObjectT >
bool PreMultiContainer< PreMultiContainerKeyT >::isStored( 
  const PreMultiContainerKeyT& obj_key ) const
{
 
  typename IntContainerT::const_iterator container_it = 
    container_instance_.find( obj_key );
    
  if( container_it == container_instance_.end() ) {
    
    return false;
  } else {
    if( typeid( ObjectT ).name() == 
      container_it->second->getObjTypeInfo() ) {
    
      return true;
    } else {
    
      return false;
    }
  }
}


template< typename PreMultiContainerKeyT >
void PreMultiContainer< PreMultiContainerKeyT >::remove( 
  const PreMultiContainerKeyT& obj_key )
{
  
  typename IntContainerT::iterator container_it = 
    container_instance_.find( obj_key );
    
  //If a old node with the same key exists, it will be deleted 
    
  if( container_it != container_instance_.end() ) {
    delete (container_it->second);
    
    container_instance_.erase( container_it );
  }
      
  update_time();
  
}

#endif