IOVProxy.h

Go to the documentation of this file.

#ifndef CondCore_CondDB_IOVProxy_h
#define CondCore_CondDB_IOVProxy_h
//
// Package:     CondDB
// Class  :     IOVProxy
//
//
// Author:      Giacomo Govi
// Created:     Apr 2013
//

#include "CondCore/CondDB/interface/Time.h"
#include "CondCore/CondDB/interface/Types.h"
//
#include <boost/date_time/posix_time/posix_time.hpp>

namespace cond {

  namespace persistency {

    class SessionImpl;
    class IOVProxyData;

    // value semantics. to be used WITHIN the parent session transaction ( therefore the session should be kept alive ).
    class IOVProxy {
    public:
      typedef std::vector<std::tuple<cond::Time_t, cond::Hash> > IOVContainer;
      // more or less compliant with typical iterator semantics...
      class Iterator : public std::iterator<std::input_iterator_tag, cond::Iov_t> {
      public:
        //
        Iterator();
        Iterator(IOVContainer::const_iterator current,
                 IOVContainer::const_iterator end,
                 cond::TimeType timeType,
                 cond::Time_t lastTill,
                 cond::Time_t endOfValidity);
        Iterator(const Iterator& rhs);

        //
        Iterator& operator=(const Iterator& rhs);

        // returns a VALUE not a reference!
        cond::Iov_t operator*();

        //
        Iterator& operator++();
        Iterator operator++(int);

        //
        bool operator==(const Iterator& rhs) const;
        bool operator!=(const Iterator& rhs) const;

      private:
        IOVContainer::const_iterator m_current;
        IOVContainer::const_iterator m_end;
        cond::TimeType m_timeType;
        cond::Time_t m_lastTill;
        cond::Time_t m_endOfValidity;
      };

    public:
      //
      IOVProxy();

      // the only way to construct it from scratch...
      explicit IOVProxy(const std::shared_ptr<SessionImpl>& session);

      //
      IOVProxy(const IOVProxy& rhs);

      //
      IOVProxy& operator=(const IOVProxy& rhs);

      // loads in memory the tag information and the iov groups
      // full=true load the full iovSequence
      void load(const std::string& tag, bool full = false);

      // loads in memory the tag information and the iov groups
      void load(const std::string& tag, const boost::posix_time::ptime& snapshottime, bool full = false);

      // loads an IOV range in memory
      void loadRange(const std::string& tag, const cond::Time_t& begin, const cond::Time_t& end);

      // loads an IOV range in memory
      void loadRange(const std::string& tag,
                     const cond::Time_t& begin,
                     const cond::Time_t& end,
                     const boost::posix_time::ptime& snapshottime);

      // reset the data in memory and execute again the queries for the current tag
      void reload();

      // clear all the iov data in memory
      void reset();

      std::string tag() const;

      cond::TimeType timeType() const;

      std::string payloadObjectType() const;

      cond::SynchronizationType synchronizationType() const;

      cond::Time_t endOfValidity() const;

      cond::Time_t lastValidatedTime() const;

      std::tuple<std::string, boost::posix_time::ptime, boost::posix_time::ptime> getMetadata() const;

      // returns true if at least one IOV is in the sequence.
      bool isEmpty() const;

      // start the iteration. it referes to the LOADED iov sequence subset, which consists in two consecutive groups - or the entire sequence if it has been requested.
      // returns data only when a find or a load( tag, true ) have been at least called once.
      Iterator begin() const;

      // the real end of the LOADED iov sequence subset.
      Iterator end() const;

      // searches the DB for a valid iov containing the specified time.
      // if the available iov sequence subset contains the target time, it does not issue a new query.
      // otherwise, a new query will be executed using the resolved group boundaries.
      Iterator find(cond::Time_t time);

      // searches the DB for a valid iov containing the specified time.
      // if the available iov sequence subset contains the target time, it does not issue a new query.
      // otherwise, a new query will be executed using the resolved group boundaries.
      // throws if the target time cannot be found.
      cond::Iov_t getInterval(cond::Time_t time);

      // it does NOT use the cache, every time it performs a new query.
      cond::Iov_t getLast();

      // the size of the LOADED iov sequence subset. Matches the sequence size if a load( tag, true ) has been called.
      int loadedSize() const;

      // the size of the entire iov sequence. Peforms a query at every call.
      int sequenceSize() const;

      // for reporting
      size_t numberOfQueries() const;

      // for debugging
      std::pair<cond::Time_t, cond::Time_t> loadedGroup() const;

      // maybe will be removed with a re-design of the top level interface (ESSources )
      const std::shared_ptr<SessionImpl>& session() const;

    private:
      void checkTransaction(const std::string& ctx) const;
      void fetchSequence(cond::Time_t lowerGroup, cond::Time_t higherGroup);

    private:
      std::shared_ptr<IOVProxyData> m_data;
      std::shared_ptr<SessionImpl> m_session;
    };

  }  // namespace persistency
}  // namespace cond

#endif