GTProxy.cc

Go to the documentation of this file.

#include "CondCore/CondDB/interface/GTProxy.h"
#include "SessionImpl.h"

namespace cond {

  namespace persistency {

    std::pair<std::string,std::string> parseTag( const std::string& tag ){
      std::string pfn("");
      std::string t(tag);
      size_t pos = tag.rfind('@');
      if( pos != std::string::npos && tag.size() >= pos+3 ){
    if( tag[pos+1]=='[' && tag[tag.size()-1]==']' ) {
      pfn = tag.substr( pos+2,tag.size()-pos-3 ); 
      t = tag.substr( 0, pos );
    }
      }
      return std::make_pair( t, pfn );
    }

    // implementation details...
    // only hosting data in this case
    class GTProxyData {
    public: 
      
      GTProxyData():
    name(""),
    preFix(""),
        postFix(""),
    tagList(){
      }
      
      std::string name;
      // will become useless after the transition...
      std::string preFix;
      std::string postFix;
      cond::Time_t validity;
      boost::posix_time::ptime snapshotTime;
      // tag list
      GTProxy::GTContainer tagList;
    };

    GTProxy::Iterator::Iterator():
      m_current(){
    }

    GTProxy::Iterator::Iterator( GTContainer::const_iterator current ):
      m_current( current ){
    }
    
    GTProxy::Iterator::Iterator( const Iterator& rhs ):
      m_current( rhs.m_current ){
    }
    
    GTProxy::Iterator& GTProxy::Iterator::operator=( const Iterator& rhs ){
      if( this != &rhs ){
    m_current = rhs.m_current;
      }
      return *this;
    }

    cond::GTEntry_t GTProxy::Iterator::operator*() {
      return cond::GTEntry_t( *m_current );
    }
    
    GTProxy::Iterator& GTProxy::Iterator::operator++(){
      m_current++;
      return *this;
    }
    
    GTProxy::Iterator GTProxy::Iterator::operator++(int){
      Iterator tmp( *this );
      operator++();
      return tmp;
    }
    
    bool GTProxy::Iterator::operator==( const Iterator& rhs ) const {
      if( m_current != rhs.m_current ) return false;
      return true;
    }
    
    bool GTProxy::Iterator::operator!=( const Iterator& rhs ) const {
      return !operator==( rhs );
    }
    
    GTProxy::GTProxy():
      m_data(),
      m_session(){
    }
    
    GTProxy::GTProxy( const std::shared_ptr<SessionImpl>& session ):
      m_data( new GTProxyData ),
      m_session( session ){
    }
    
    GTProxy::GTProxy( const GTProxy& rhs ):
      m_data( rhs.m_data ),
      m_session( rhs.m_session ){
    }
    
    GTProxy& GTProxy::operator=( const GTProxy& rhs ){
      m_data = rhs.m_data;
      m_session = rhs.m_session;
      return *this;
    }
    
      // overloading for pre- and post-fix. Used in the ORA implementation
    void GTProxy::load( const std::string& gtName, const std::string& pref, const std::string& postf ){
      // clear
      reset();
      
      checkTransaction( "GTProxy::load" );
      
      if(!m_session->gtSchema().gtTable().select( gtName, m_data->validity, m_data->snapshotTime ) ){
    throwException( "Global Tag \""+gtName+"\" has not been found in the database.","GTProxy::load");
      }
      m_data->name = gtName;
      m_data->preFix = pref;
      m_data->postFix = postf;

      m_session->gtSchema().gtMapTable().select( m_data->name, pref, postf, m_data->tagList );

    }

    
    void GTProxy::reload(){
      load( m_data->name );
    }
    
    void GTProxy::reset(){
      if( m_data.get() ){
    m_data->tagList.clear();
      }
    }
    
    std::string GTProxy::name() const {
      return m_data.get() ? m_data->name : std::string("");
    }
    
    cond::Time_t GTProxy::validity() const {
      return m_data.get() ? m_data->validity : cond::time::MIN_VAL;
    }
    
    boost::posix_time::ptime GTProxy::snapshotTime() const {
      return m_data.get() ? m_data->snapshotTime : boost::posix_time::ptime();
    }
    
    void GTProxy::checkTransaction( const std::string& ctx ){
      if( !m_session.get() ) throwException("The session is not active.",ctx );
      if( !m_session->isTransactionActive( false ) ) throwException("The transaction is not active.",ctx );
    }
    
    GTProxy::Iterator GTProxy::begin() const {
      if( m_data.get() ){
    return Iterator( m_data->tagList.begin() );
      } 
      return Iterator();
    }
    
    GTProxy::Iterator GTProxy::end() const {
      if( m_data.get() ){
    return Iterator( m_data->tagList.end() );
      } 
      return Iterator();
    }
    
    int GTProxy::size() const {
      return m_data.get()? m_data->tagList.size() : 0;
    }

  }
}