DBImportBase.h

/**************************************************************************
 * BASF2 (Belle Analysis Framework 2)                                     *
 * Copyright(C) 2016 - Belle II Collaboration                             *
 *                                                                        *
 * Author: The Belle II Collaboration                                     *
 * Contributors: Marko Staric                                             *
 *                                                                        *
 * This software is provided "as is" without any warranty.                *
 **************************************************************************/
#pragma once
 
#include <framework/database/DBStore.h>
#include <framework/database/IntervalOfValidity.h>
 
namespace Belle2 {
  class DBImportBase {
  public:
 
    explicit DBImportBase(const std::string& name): m_name(name) {}
 
    virtual ~DBImportBase();
 
    const std::string& getName() const {return m_name;}
 
    virtual void addEventDependency(unsigned int eventNumber)
    {
      addIntraRunDependency(eventNumber, c_Event);
    }
 
    virtual void addTimeStampDependency(unsigned long long int timeStamp)
    {
      addIntraRunDependency(timeStamp, c_TimeStamp);
    }
 
    virtual void addSubrunDependency(int subrun)
    {
      addIntraRunDependency(subrun, c_Subrun);
    }
 
    bool import(const IntervalOfValidity& iov);
 
    virtual void clear();
 
  protected:
 
    enum EIntraRunDependency { c_None = 0,
                               c_Event = 1,
                               c_TimeStamp = 2,
                               c_Subrun = 3
                             };
 
    void addIntraRunDependency(unsigned long long int tag, EIntraRunDependency type);
 
    std::string m_name;      
    TObject* m_object = 0;     
  private:
 
    DBImportBase(const DBImportBase&);
 
    template<class IntraRun> bool import(const IntervalOfValidity& iov)
    {
      if (m_objects.empty()) return false;
      IntraRun intraRun(m_objects[0], false); // IntraRun must not own the objects
 
      if (m_object) m_objects.push_back(m_object);
      for (unsigned i = 1; i < m_objects.size(); i++) {
        intraRun.add(m_tags[i - 1], m_objects[i]);
      }
      if (m_object) m_objects.pop_back(); // restore initial state (mandatory!)
 
      return storeData(&intraRun, iov);
    }
 
    bool storeData(TObject* intraRun, const IntervalOfValidity& iov);
 
 
    EIntraRunDependency m_dependency = c_None;  
    std::vector<TObject*> m_objects; 
    std::vector<unsigned long long int> m_tags; 
  };
}