---

CondIter.h

Go to the documentation of this file.

#ifndef CondIter_CondIter_h
#define CondIter_CondIter_h


#include "CondCore/Utilities/interface/CondBasicIter.h"



#include "CondCore/DBCommon/interface/TypedRef.h"

#include "CondCore/IOVService/interface/IOVIterator.h"
#include "CondCore/DBCommon/interface/CoralTransaction.h"
#include "CondCore/DBCommon/interface/PoolTransaction.h"
#include "CondCore/DBCommon/interface/AuthenticationMethod.h"
#include "CondCore/DBCommon/interface/SessionConfiguration.h"
#include "CondCore/DBCommon/interface/ConnectionConfiguration.h"
#include "CondCore/DBCommon/interface/MessageLevel.h"
#include "CondCore/DBCommon/interface/DBSession.h"
#include "CondCore/DBCommon/interface/Exception.h"
#include "CondCore/MetaDataService/interface/MetaData.h"
#include "CondCore/IOVService/interface/IOVService.h"

#include <boost/program_options.hpp>
#include <iterator>
#include <iostream>
#include<vector>
#include <string>


template <class T>
class CondIter{
    private:
        

        const T* Reference;
        cond::TypedRef<T> *ref;  
        CondBasicIter bIter;
                  
    public:
   
        bool NumberOfTimes;
        
        
        CondIter();
        ~CondIter();

        
        template <class A> friend class CondCachedIter;
        
        
        
        void create(const std::string & NameDB,
                    const std::string & File,
                    const std::string & User = "",
                    const std::string & Pass = "",
                    const std::string & nameBlob = ""
                   );
    
        T const * next(int test = 1);

        void setRange(unsigned int min,unsigned int max);
        void setRange(int min,int max); 

        void setMin(unsigned int min);
        void setMin(int min);
 
        void setMax(unsigned int max);
        void setMax(int max);
 
        unsigned int getTime();
  
        unsigned int getStartTime();
  
        unsigned int getStopTime();

   
        void jump();

        void free();
  
        cond::TypedRef<T> const * whatRef();
        
        unsigned int getMin();
  
        unsigned int getMax();
  

        void getRange(unsigned int*,unsigned int*);

  
};


          template <class T> CondIter<T>::CondIter(){

              Reference = 0;
              ref = 0;  
          }


          template <class T> CondIter<T>::~CondIter(){

              if (ref) delete ref; 
          }


          template <class T> void CondIter<T>::create(const std::string & NameDB,const std::string & File,const std::string & User,const std::string & Pass,const std::string & nameBlob){

              bIter.create(NameDB,File,User,Pass,nameBlob);
              NumberOfTimes = true;
              ref = 0; 
              Reference = 0;

          }





 
          template <class T> T const * CondIter<T>::next(int test) {
             
              if ((bIter.iter_Min)==0 && (bIter.iter_Max)==0){
// method next without range

                  if( (bIter.ioviterator)->next() ){
       
                      std::cout<<"PayloadContainerName "<<bIter.payloadContainer<<"\n";
                      std::cout<<"since \t till \t payloadToken"<<std::endl;
                      std::cout<< (bIter.ioviterator)->validity().first<<" \t "<< (bIter.ioviterator)->validity().second<<" \t "<<(bIter.ioviterator)->payloadToken()<<std::endl; 
                      if (test && ref) {
//                 delete Reference;
                          delete ref;
                      }   
                      ref = new cond::TypedRef<T> (*(bIter.pooldb),(bIter.ioviterator)->payloadToken());
                      Reference = (const T*) ref->ptr();
                      bIter.setStartTime((bIter.ioviterator)->validity().first);
                      bIter.setStopTime((bIter.ioviterator)->validity().second);
    
                      long long int temp = (long long int) (( bIter.getStartTime()+ bIter.getStopTime()) / 2.);
                      if (temp<0) temp = - temp;
                      bIter.setTime((unsigned int) temp);
                      return Reference;
                  }
                  else {
                      std::cout << "No more data ! " << std::endl;
                      Reference = 0;
                      ref = 0;
                      return Reference;
    //return a pointer to NULL
                  }
              }
              else{    
//test to see if it is the first time
                  if (NumberOfTimes){
                      unsigned int minTemp = bIter.getMin(); 
                      for (unsigned int i=0; i< minTemp; i++){//iter_Min <= run since at least I have one IOV for each run  
    //control if the min is too high
                          if (!((bIter.ioviterator)->next())) {
                              std::cout << "No data. Minimum too high." << std::endl;
                              Reference = 0;
                              ref = 0;
                              return Reference;
    //return a pointer to NULL
                          }
                          if (((bIter.ioviterator)->validity().second)>=minTemp) i = minTemp; //Minimum reached 
                      }
                      NumberOfTimes = false;
                  }
                  if( (bIter.ioviterator)->next() ){
                      if (((bIter.ioviterator)->validity().first)>=(bIter.getMax())){
                          std::cout << "No more data in the range" << std::endl;
                          Reference = 0;
                          ref = 0;
                          return Reference;
        //return a pointer to NULL
                      }
                      else {
                          std::cout<<"PayloadContainerName "<<bIter.payloadContainer<<"\n";
                          std::cout<<"since \t till \t payloadToken"<<std::endl;
                          std::cout<< (bIter.ioviterator)->validity().first<<" \t "<< (bIter.ioviterator)->validity().second<<" \t "<<(bIter.ioviterator)->payloadToken()<<std::endl; 

    
                          if (test && ref) {
//                     delete Reference;
                              delete ref;
                          }   //test to choose if mantain the object or not
                          ref = new cond::TypedRef<T> (*(bIter.pooldb),(bIter.ioviterator)->payloadToken());
                          Reference = (const T*) ref->ptr();
                          bIter.setStartTime((bIter.ioviterator)->validity().first);
                          bIter.setStopTime((bIter.ioviterator)->validity().second);
    
                          long long int temp = (long long int) (( bIter.getStartTime()+ bIter.getStopTime()) / 2.);
                          if (temp<0) temp = - temp;
                          bIter.setTime((unsigned int) temp);   
                          return Reference;
                      }
                  }
      
                  else {
                      std::cout << "No more data ! " << std::endl;
                      Reference = 0;
                      ref = 0;
                      return Reference;
    //return a pointer to NULL
                  }
              }

          }






          template <class T> void CondIter<T>::jump() {
    
              if (NumberOfTimes){
                  unsigned int minTemp = bIter.getMin(); 
          
                  for (unsigned int i=0; i< minTemp; i++){//iter_Min <= run since at least I have one IOV for each run 
    //control if the min is too high
                      if (!((bIter.ioviterator)->next())) {
                          std::cout << "No data. Minimum too high." << std::endl;
    //return a pointer to NULL
                      }
                      if (((bIter.ioviterator)->validity().second)>=minTemp) i = minTemp; //Minimum reached 
                  }
                  NumberOfTimes = false;
              }
              else (bIter.ioviterator)->next();
          }


          template <class T> void CondIter<T>::free(){
              Reference = 0;
              ref = 0;
          }




          template <class T> cond::TypedRef<T> const * CondIter<T>::whatRef() {

              return ref;
    
          }








          template <class T> void CondIter<T>::setRange(unsigned int min,unsigned int max){
              bIter.setRange(min,max);
          }
 
          template <class T> void CondIter<T>::setMin(unsigned int min){
              bIter.setMin(min);
          }
 
          template <class T> void CondIter<T>::setMax(unsigned int max){
              bIter.setMax(max);
          }

          template <class T> void CondIter<T>::setRange(int min,int max){
              bIter.setRange(min,max);
          }
 
          template <class T> void CondIter<T>::setMin(int min){
              bIter.setMin(min);
          }
 
          template <class T> void CondIter<T>::setMax(int max){
              bIter.setMax(max);
          }
 

          template <class T> unsigned int CondIter<T>::getMin(){return bIter.getMin();}
  
          template <class T> unsigned int CondIter<T>::getMax(){return bIter.getMax();}
  
          template <class T> void CondIter<T>::getRange(unsigned int * Min_out,unsigned int * Max_out){
              *Min_out = bIter.getMin();
              *Max_out = bIter.getMax();
          }


          template <class T> unsigned int CondIter<T>::getTime(){return bIter.getTime();}
  
          template <class T> unsigned int CondIter<T>::getStartTime(){return bIter.getStartTime();}
  
          template <class T> unsigned int CondIter<T>::getStopTime(){return bIter.getStopTime();}
  
#endif

---