---

cond::IOVEditorImpl Class Reference

#include <CondCore/IOVService/src/IOVEditorImpl.h>

Inheritance diagram for cond::IOVEditorImpl:

List of all members.

Public Member Functions
virtual unsigned int	append (cond::Time_t sinceTime, const std::string &payloadToken)
	Append a payload with known since time. The previous last payload's till time will be adjusted to the new payload since time. Returns the payload index in the iov sequence.
void	bulkInsert (std::vector< std::pair< cond::Time_t, std::string > > &values)
	Bulk insert of iov chunck.
void	create (cond::Time_t firstSince, cond::TimeType timetype)
	create a new IOV
virtual void	deleteEntries (bool withPayload=false)
virtual unsigned int	deleteEntry (cond::Time_t time, bool withPayload=false)
	delete entry at a given time
cond::Time_t	firstSince () const
unsigned int	freeInsert (cond::Time_t sinceTime, const std::string &payloadToken)
	insert a payload with known since in any position
virtual void	import (const std::string &sourceIOVtoken)
virtual unsigned int	insert (cond::Time_t tillTime, const std::string &payloadToken)
	Assign a payload with till time. Returns the payload index in the iov sequence.
	IOVEditorImpl (cond::PoolTransaction &pooldb, const std::string &token)
virtual unsigned int	replaceInterval (cond::Time_t sinceTime, cond::Time_t tillTime, const std::string &payloadToken, bool deletePayload=false)
	insert/replace an item in a given fixed IOV interval.
cond::TimeType	timetype () const
std::string	token () const
	Returns the token of the iov sequence associated with this editor.
virtual void	updateClosure (cond::Time_t newtillTime)
	Update the closure of the iov sequence.
virtual	~IOVEditorImpl ()
	Destructor.
Private Member Functions
void	init ()
bool	validTime (cond::Time_t time) const
bool	validTime (cond::Time_t time, cond::TimeType timetype) const
Private Attributes
cond::TypedRef< cond::IOV >	m_iov
bool	m_isActive
cond::PoolTransaction *	m_pooldb
std::string	m_token

---

Detailed Description

Definition at line 10 of file IOVEditorImpl.h.

---

Constructor & Destructor Documentation

cond::IOVEditorImpl::IOVEditorImpl	(	cond::PoolTransaction &	pooldb,
		const std::string &	token
	)

Definition at line 10 of file IOVEditorImpl.cc.

                                 :m_pooldb(&pooldb),m_token(token),
                                  m_isActive(false){
  }

cond::IOVEditorImpl::~IOVEditorImpl

(

)

[virtual]

Destructor.

Definition at line 55 of file IOVEditorImpl.cc.

                               {
  }

---

Member Function Documentation

unsigned int cond::IOVEditorImpl::append	(	cond::Time_t	sinceTime,
		const std::string &	payloadToken
	)			[virtual]

Append a payload with known since time. The previous last payload's till time will be adjusted to the new payload since time. Returns the payload index in the iov sequence.

Implements cond::IOVEditor.

Definition at line 126 of file IOVEditorImpl.cc.

References cond::TimeTypeSpecs::endValue, Exception, first, firstSince(), init(), m_iov, m_isActive, m_token, cond::TypedRef< T >::markUpdate(), timetype(), cond::timeTypeSpecs, and validTime().

                                {
    if( m_token.empty() ) {
      throw cond::Exception("cond::IOVEditorImpl::appendIOV cannot append to non-existing IOV index");
    }
    
    if(!m_isActive) {
      this->init();
    }
    
    if( m_iov->iov.empty() ) throw cond::Exception("cond::IOVEditorImpl::appendIOV cannot append to empty IOV index");
    

   if(!validTime(sinceTime))
      throw cond::Exception("cond::IOVEditorImpl::append time not in global range");

   if (sinceTime<=firstSince())  throw cond::Exception("IOVEditor::append Error: since time out of range, below first since");
    
    
    if(  m_iov->iov.size()>1 ){
      //range check in case 
      cond::Time_t lastValidTill=(++m_iov->iov.rbegin())->first;
      //std::cout<<"lastValidTill "<<lastValidTill<<std::endl;
      if( (sinceTime-1)<= lastValidTill){
        throw cond::Exception("IOVEditor::append Error: since time out of range: below last since");
      }
    }

    cond::Time_t lastIOV=m_iov->iov.back().first;
    // does it make sense? (in case of mixed till and since insertions...)
    if (lastIOV<sinceTime) lastIOV=timeTypeSpecs[timetype()].endValue;
    m_iov.markUpdate();
    m_iov->iov.back().first = sinceTime-1;
    return m_iov->add(lastIOV,payloadToken);


  }

void cond::IOVEditorImpl::bulkInsert

(

std::vector< std::pair< cond::Time_t, std::string > > &

values

)

[virtual]

Bulk insert of iov chunck.

Implements cond::IOVEditor.

Definition at line 97 of file IOVEditorImpl.cc.

References Exception, firstSince(), init(), m_iov, m_isActive, cond::TypedRef< T >::markUpdate(), validTime(), and values.

                                                                             {
    if (values.empty()) return;
    if(!m_isActive) this->init();
    cond::Time_t tillTime = values.front().first;

    if(!validTime(tillTime))
      throw cond::Exception("cond::IOVEditorImpl::bulkInsert first time not in global range");

    if(!validTime(values.back().first))
      throw cond::Exception("cond::IOVEditorImpl::bulkInsert last time not in global range");

   if(tillTime<firstSince() ||
       ( !m_iov->iov.empty() && tillTime<=m_iov->iov.back().first) 
       )    throw cond::Exception("cond::IOVEditorImpl::bulkInsert IOV not in range");
    
    m_iov->iov.insert(m_iov->iov.end(), values.begin(), values.end());
    m_iov.markUpdate();   
  }

void cond::IOVEditorImpl::create	(	cond::Time_t	firstSince,
		cond::TimeType	timetype
	)			[virtual]

create a new IOV

Implements cond::IOVEditor.

Definition at line 16 of file IOVEditorImpl.cc.

References cond::IOVNames::container(), Exception, int, m_iov, m_isActive, m_pooldb, m_token, cond::TypedRef< T >::markWrite(), cond::TypedRef< T >::token(), and validTime().

                                                     {

    if(!m_token.empty()){
      // problem??
      throw cond::Exception("cond::IOVEditorImpl::create cannot create a IOV using an initialized Editor");
    }

    if(!validTime(firstSince, timetype))
      throw cond::Exception("cond::IOVEditorImpl::create time not in global range");
      

    m_iov=cond::TypedRef<cond::IOV>(*m_pooldb,new cond::IOV);
    m_iov->timetype=(int)timetype;
    m_iov->firstsince=firstSince;
    
    m_iov.markWrite(cond::IOVNames::container());
    m_token=m_iov.token();
    m_isActive=true;
 
  }

void cond::IOVEditorImpl::deleteEntries

(

bool

withPayload = false

)

[virtual]

Implements cond::IOVEditor.

Definition at line 363 of file IOVEditorImpl.cc.

References init(), m_iov, m_isActive, m_pooldb, m_token, cond::GenericRef::markDelete(), cond::TypedRef< T >::markDelete(), and cond::GenericRef::reset().

                                              {
    if( m_token.empty() ) throw cond::Exception("cond::IOVEditorImpl::deleteEntries cannot delete to non-existing IOV index");
    if(!m_isActive) this->init();
    if(withPayload){
      std::string tokenStr;
      IOV::iterator payloadIt;
      IOV::iterator payloadItEnd=m_iov->iov.end();
      for(payloadIt=m_iov->iov.begin();payloadIt!=payloadItEnd;++payloadIt){
        tokenStr=payloadIt->second;
        cond::GenericRef ref(*m_pooldb,tokenStr);
        ref.markDelete();
        ref.reset();
      }
    }
    m_iov.markDelete();
  }

unsigned int cond::IOVEditorImpl::deleteEntry	(	cond::Time_t	time,
		bool	withPayload = false
	)			[virtual]

delete entry at a given time

Implements cond::IOVEditor.

Definition at line 324 of file IOVEditorImpl.cc.

References Exception, first, firstSince(), init(), m_iov, m_isActive, m_pooldb, m_token, cond::GenericRef::markDelete(), cond::TypedRef< T >::markUpdate(), n, p, and validTime().

                                                 {
   if( m_token.empty() ) {
      throw cond::Exception("cond::IOVEditorImpl::deleteEntry cannot delete from non-existing IOV index");
    }
    
    if(!m_isActive) {
      this->init();
    }
    
    if( m_iov->iov.empty() ) throw cond::Exception("cond::IOVEditorImpl::deleteEntry cannot delete from empty IOV index");
    

   if(!validTime(time)||time<firstSince())
     throw cond::Exception("cond::IOVEditorImpl::deleteEntry time not in IOVs range");

   IOV::iterator p = m_iov->find(time);
   if (p==m_iov->iov.end())
     throw cond::Exception("cond::IOVEditorImpl::deleteEntry time not in IOVs range");

   int n = p-m_iov->iov.begin();
   if(withPayload) {
     cond::GenericRef ref(*m_pooldb,(*p).second);
     ref.markDelete();
   }
   
   m_iov.markUpdate();
   if (p==m_iov->iov.begin() )
     m_iov->firstsince=(*p).first+1;
   else 
     (*(p-1)).first=(*p).first;
   m_iov->iov.erase(p);

   return n;

  }

Time_t cond::IOVEditorImpl::firstSince

(

)

const

Definition at line 58 of file IOVEditorImpl.cc.

References m_iov.

Referenced by append(), bulkInsert(), deleteEntry(), freeInsert(), insert(), and replaceInterval().

                                         {
    return m_iov->firstsince;
  }

unsigned int cond::IOVEditorImpl::freeInsert	(	cond::Time_t	sinceTime,
		const std::string &	payloadToken
	)			[virtual]

insert a payload with known since in any position

Implements cond::IOVEditor.

Definition at line 166 of file IOVEditorImpl.cc.

References cond::TimeTypeSpecs::endValue, Exception, firstSince(), init(), m_iov, m_isActive, m_token, cond::TypedRef< T >::markUpdate(), p, timetype(), cond::timeTypeSpecs, and validTime().

                                {
    if( m_token.empty() ) {
      throw cond::Exception("cond::IOVEditorImpl::appendIOV cannot append to non-existing IOV index");
    }
    
    if(!m_isActive) {
      this->init();
    }
    
    if( m_iov->iov.empty() ) throw cond::Exception("cond::IOVEditorImpl::appendIOV cannot insert  to empty IOV index");
    

   if(!validTime(sinceTime))
      throw cond::Exception("cond::IOVEditorImpl::freeInsert time not in global range");


 
   if (sinceTime<firstSince()) {
     m_iov->iov.insert(m_iov->iov.begin(),IOV::Item(firstSince()-1,payloadToken));
     m_iov->firstsince=sinceTime;
     m_iov.markUpdate();
    return 0;
   }

   // insert after found one.
   cond::Time_t tillTime;
   IOV::iterator p = m_iov->find(sinceTime);
   if (p==m_iov->iov.end()) {
     // closed range???
     tillTime=timeTypeSpecs[timetype()].endValue;
     (*(p-1)).first=sinceTime-1;

   }
   else {

     {
       // check for existing since
       if (p==m_iov->iov.begin() ) {
         if (firstSince()==sinceTime)
           throw cond::Exception("cond::IOVEditorImpl::freeInsert sinceTime already existing");
       } else
         if ((*(p-1)).first==sinceTime-1)
           throw cond::Exception("cond::IOVEditorImpl::freeInsert sinceTime already existing");
     }

     tillTime=(*p).first;
     (*p).first=sinceTime-1;
     p++;
   }

   p = m_iov->iov.insert(p,IOV::Item(tillTime,payloadToken));
   m_iov.markUpdate();
   return p - m_iov->iov.begin();

    
  }

void cond::IOVEditorImpl::import

(

const std::string &

sourceIOVtoken

)

[virtual]

Implements cond::IOVEditor.

Definition at line 381 of file IOVEditorImpl.cc.

References cond::IOVNames::container(), m_iov, m_pooldb, m_token, cond::TypedRef< T >::markWrite(), and cond::TypedRef< T >::token().

                                                        {
    if( !m_token.empty() ) throw cond::Exception("cond::IOVEditorImpl::import IOV index already exists, cannot import");
    m_iov=cond::TypedRef<cond::IOV>(*m_pooldb,sourceIOVtoken);
    m_iov.markWrite(cond::IOVNames::container());
    m_token=m_iov.token();
  }

void cond::IOVEditorImpl::init

(

void

)

[private]

Definition at line 41 of file IOVEditorImpl.cc.

References Exception, m_iov, m_isActive, m_pooldb, and m_token.

Referenced by append(), bulkInsert(), deleteEntries(), deleteEntry(), freeInsert(), insert(), replaceInterval(), and updateClosure().

                          {
    if(m_token.empty()){
      // problem?
      throw cond::Exception("cond::IOVEditorImpl::init cannot init w/o token change");
      
    }
    
    m_iov=cond::TypedRef<cond::IOV>(*m_pooldb, m_token); 
    m_isActive=true;
    
}

unsigned int cond::IOVEditorImpl::insert	(	cond::Time_t	tillTime,
		const std::string &	payloadToken
	)			[virtual]

Assign a payload with till time. Returns the payload index in the iov sequence.

Implements cond::IOVEditor.

Definition at line 78 of file IOVEditorImpl.cc.

References Exception, firstSince(), init(), m_iov, m_isActive, cond::TypedRef< T >::markUpdate(), and validTime().

                          {
    if(!m_isActive) this->init();


    if(!validTime(tillTime))
      throw cond::Exception("cond::IOVEditorImpl::insert time not in global range");
  
    if(tillTime<firstSince() ||
       ( !m_iov->iov.empty() && tillTime<=m_iov->iov.back().first) 
       )    throw cond::Exception("cond::IOVEditorImpl::insert IOV not in range");
 
    m_iov.markUpdate();
    return m_iov->add(tillTime, payloadToken);
    
  }

unsigned int cond::IOVEditorImpl::replaceInterval	(	cond::Time_t	sinceTime,
		cond::Time_t	tillTime,
		const std::string &	payloadToken,
		bool	deletePayload = false
	)			[virtual]

insert/replace an item in a given fixed IOV interval.

It will pad the IOV non covered with an IOV corresponding to an "invalid" payload

Implements cond::IOVEditor.

Definition at line 227 of file IOVEditorImpl.cc.

References b, e, Exception, firstSince(), init(), m_iov, m_isActive, m_pooldb, m_token, cond::GenericRef::markDelete(), cond::TypedRef< T >::markUpdate(), p, cond::GenericRef::reset(), and validTime().

                                                     {

    static const std::string invalidToken(":");

    if( m_token.empty() ) {
     throw cond::Exception("cond::IOVEditorImpl::replaceInterval cannot edit an non-existing IOV index");
    }
    
    if(!m_isActive) {
      this->init();
    }
    
    if( m_iov->iov.empty() ) throw cond::Exception("cond::IOVEditorImpl::replaceInterval cannot replace in an empty IOV index");
    

   if(!validTime(sinceTime)||!validTime(tillTime)||tillTime<sinceTime)
     throw cond::Exception("cond::IOVEditorImpl::replaceInterval times not in IOVs range");

  
   IOV::iterator b = m_iov->find(sinceTime);
   IOV::iterator e = m_iov->find(tillTime);
 
   
   if (b==m_iov->iov.end()) {
     // pad....
     if (m_iov->iov.back().first<sinceTime-1) 
       m_iov->iov.push_back(IOV::Item(sinceTime-1,invalidToken));
     m_iov->iov.push_back(IOV::Item(tillTime,payloadToken));
     m_iov.markUpdate();
     return m_iov->iov.size()-1;
   }

   if (sinceTime<firstSince()) {
     // pad
     if (tillTime<firstSince()-1)
       b=m_iov->iov.insert(b,IOV::Item(firstSince()-1,invalidToken));
     else  { 
       // cleanup
       if (e!=m_iov->iov.end() && (*e).first==tillTime) e++;
       if(deletePayload) {
         for ( IOV::iterator p=b; p!=e; p++) {
           cond::GenericRef ref(*m_pooldb,(*p).second);
           ref.markDelete();
           ref.reset();
         }
       }
       m_iov->iov.erase(b,e);
     }
     b=m_iov->iov.begin();
     m_iov->iov.insert(b,IOV::Item(tillTime,payloadToken));
     m_iov->firstsince=sinceTime;
     m_iov.markUpdate();
     return 0;
   }

   cond::Time_t newSince = (b==m_iov->iov.begin()) ? firstSince() : (*(b-1)).first+1;

   if (sinceTime>newSince) {
     if ( (*b).first>tillTime) {
       // split
       b=m_iov->iov.insert(b,IOV::Item(sinceTime-1,(*b).second));
       b=m_iov->iov.insert(b+1,IOV::Item(tillTime,payloadToken));
       m_iov.markUpdate();
       return b-m_iov->iov.begin();
     }
     (*b).first>sinceTime-1;
     b++;
   }

   // cleanup
   if (e!=m_iov->iov.end() && (*e).first==tillTime) e++;
   if(deletePayload) {
     for ( IOV::iterator p=b; p!=e; p++) {
       cond::GenericRef ref(*m_pooldb,(*p).second);
       ref.markDelete();
       ref.reset();
     }
   }
   m_iov->iov.erase(b,e);
   
   b = m_iov->find(sinceTime);
   e = m_iov->find(tillTime);
   if (e-b>1) 
     throw cond::Exception("cond::IOVEditorImpl::replaceInterval vincenzo logic has a fault!!!!");

   b = m_iov->iov.insert(b,IOV::Item(tillTime,payloadToken));
   m_iov.markUpdate();
   return b-m_iov->iov.begin();

  }

TimeType cond::IOVEditorImpl::timetype

(

)

const

Definition at line 62 of file IOVEditorImpl.cc.

References m_iov.

Referenced by append(), freeInsert(), and validTime().

                                         {
    return m_iov->timeType();
  }

std::string cond::IOVEditorImpl::token

(

)

const [inline, virtual]

Returns the token of the iov sequence associated with this editor.

Implements cond::IOVEditor.

Definition at line 57 of file IOVEditorImpl.h.

References m_token.

                            {
      return m_token;
    }

void cond::IOVEditorImpl::updateClosure

(

cond::Time_t

newtillTime

)

[virtual]

Update the closure of the iov sequence.

Implements cond::IOVEditor.

Definition at line 118 of file IOVEditorImpl.cc.

References init(), m_iov, m_isActive, m_token, and cond::TypedRef< T >::markUpdate().

                                                      {
    if( m_token.empty() ) throw cond::Exception("cond::IOVEditorImpl::updateClosure cannot change non-existing IOV index");
    if(!m_isActive) this->init();
    m_iov->iov.back().first=newtillTime;
    m_iov.markUpdate();
  }

bool cond::IOVEditorImpl::validTime

(

cond::Time_t

time

)

const [private]

Definition at line 71 of file IOVEditorImpl.cc.

References timetype(), and validTime().

                                                     {
    return validTime(time,timetype());
  }

bool cond::IOVEditorImpl::validTime	(	cond::Time_t	time,
		cond::TimeType	timetype
	)			const [private]

Definition at line 67 of file IOVEditorImpl.cc.

References cond::TimeTypeSpecs::beginValue, cond::TimeTypeSpecs::endValue, and cond::timeTypeSpecs.

Referenced by append(), bulkInsert(), create(), deleteEntry(), freeInsert(), insert(), replaceInterval(), and validTime().

                                                                            {
    return time>=timeTypeSpecs[timetype].beginValue && time<=timeTypeSpecs[timetype].endValue;   

  }

---

Member Data Documentation

cond::TypedRef<cond::IOV> cond::IOVEditorImpl::m_iov [private]

Definition at line 73 of file IOVEditorImpl.h.

Referenced by append(), bulkInsert(), create(), deleteEntries(), deleteEntry(), firstSince(), freeInsert(), import(), init(), insert(), replaceInterval(), timetype(), and updateClosure().

bool cond::IOVEditorImpl::m_isActive [private]

Definition at line 72 of file IOVEditorImpl.h.

Referenced by append(), bulkInsert(), create(), deleteEntries(), deleteEntry(), freeInsert(), init(), insert(), replaceInterval(), and updateClosure().

cond::PoolTransaction* cond::IOVEditorImpl::m_pooldb [private]

Definition at line 70 of file IOVEditorImpl.h.

Referenced by create(), deleteEntries(), deleteEntry(), import(), init(), and replaceInterval().

std::string cond::IOVEditorImpl::m_token [private]

Definition at line 71 of file IOVEditorImpl.h.

Referenced by append(), create(), deleteEntries(), deleteEntry(), freeInsert(), import(), init(), replaceInterval(), token(), and updateClosure().

---

The documentation for this class was generated from the following files:

• CondCore/IOVService/src/IOVEditorImpl.h
• CondCore/IOVService/src/IOVEditorImpl.cc

---