IOV.h

Go to the documentation of this file.

//==========================================================================
//  AIDA Detector description implementation 
//--------------------------------------------------------------------------
// Copyright (C) Organisation europeenne pour la Recherche nucleaire (CERN)
// All rights reserved.
//
// For the licensing terms see $DD4hepINSTALL/LICENSE.
// For the list of contributors see $DD4hepINSTALL/doc/CREDITS.
//
// Author     : M.Frank
//
//==========================================================================
#ifndef DD4HEP_IOV_H
#define DD4HEP_IOV_H
 
// C/C++ include files
#include <string>
#include <limits>
#include <utility>
#include <cstdint>
 
namespace dd4hep {
 
  // Forward declarations
  class IOVType;
  class IOV;
 
 
  class IOVType   {
  public:
    static constexpr unsigned int UNKNOWN_IOV = ~0x0;
    unsigned int type = UNKNOWN_IOV;
    std::string  name;
    IOVType() = default;
    ~IOVType() = default;
    IOVType(const IOVType& copy) = default; //: type(copy.type), name(copy.name) {}
    IOVType(IOVType&& copy) = default;
    IOVType& operator=(const IOVType& copy) = default;
    IOVType& operator=(IOVType&& copy) = default;
    std::string str() const;
  };
 
 
  class IOV   {
  private:
    explicit IOV() = delete;
  public:
    using Key_value_type = std::int64_t;
    using Key = std::pair<Key_value_type, Key_value_type>;
 
    static constexpr Key_value_type MIN_KEY = std::numeric_limits<Key_value_type>::min();
    static constexpr Key_value_type MAX_KEY = std::numeric_limits<Key_value_type>::max();
 
    const IOVType* iovType = 0;
    Key            keyData{MIN_KEY,MIN_KEY};
    int            optData = 0;
    unsigned int   type    = IOVType::UNKNOWN_IOV;
    
    explicit IOV(const IOVType* typ);
    explicit IOV(const IOVType* typ, const Key& key);
    explicit IOV(const IOVType* typ, Key_value_type iov_value);
    IOV(const IOV& copy) = default;
    IOV(IOV&& copy) = default;
    ~IOV() = default;
    IOV& operator=(const IOV& c) = default;
    IOV& operator=(IOV&& c) = default;
    bool operator<(const IOV& test)  const;
    void move(IOV& from);
    std::string str() const;
    bool has_range() const             {  return keyData.first != keyData.second;  }
    bool is_discrete() const           {  return keyData.first == keyData.second;  }
    Key  key() const                   {  return keyData;                          }
    void set(const Key& value);
    void set(Key_value_type value);
    void set(Key_value_type val_1, Key_value_type val_2);
    IOV& reset();
    IOV& invert();
    void iov_intersection(const IOV& comparator);
    void iov_intersection(const IOV::Key& comparator);
    void iov_union(const IOV& comparator);
    void iov_union(const IOV::Key& comparator);
 
 
    bool contains(const IOV& iov)  const;
    static IOV forever(const IOVType* typ)
    { return IOV(typ, Key(MIN_KEY, MAX_KEY));                             }
    static Key key_forever()
    { return Key(MIN_KEY, MAX_KEY);                                       }
    static bool same_type(const IOV& iov, const IOV& test)           {
      unsigned int typ1 = iov.iovType ? iov.iovType->type : iov.type;
      unsigned int typ2 = test.iovType ? test.iovType->type : test.type;
      return typ1 == typ2;
    }
    static bool key_is_contained(const Key& key, const Key& test)
    {   return key.first >= test.first && key.second <= test.second;      }
    static bool key_contains_range(const Key& key, const Key& test)
    {   return key.first <= test.first && key.second >= test.second;      }
    static bool key_overlaps_lower_end(const Key& key, const Key& test)         
    {   return key.first <= test.second && key.first >= test.first;       }
    static bool key_overlaps_higher_end(const Key& key, const Key& test)         
    {   return key.second >= test.first && key.second <= test.second;     }
    static bool key_partially_contained(const Key& key, const Key& test)         
    {   
      return 
        (test.first <= key.first  && key.second   >= test.second) || // test fully contained in key
        (test.first <= key.first  && key.first    <= test.second) || // test overlaps left edge of key
        (test.first <= key.second && key.second   <= test.second);   // test overlaps right edge of key
    }
    static bool full_match(const IOV& iov, const IOV& test)
    {   return same_type(iov,test) && key_is_contained(iov.keyData,test.keyData);      }
    static bool partial_match(const IOV& iov, const IOV& test)
    {   return same_type(iov,test) && key_partially_contained(iov.keyData,test.keyData);      }
  };
 
  inline bool IOV::operator<(const IOV& test)  const   {
    if ( type > test.type ) return false; // Actually this should never happen!
    if ( keyData.first > test.keyData.first ) return false;
    if ( keyData.second > test.keyData.second ) return false;
    return true;
  }
 
} /* End namespace dd4hep                   */
#endif // DD4HEP_IOV_H