IOV.h

Go to the documentation of this file.

//==========================================================================
//  AIDA Detector description implementation for LCD
//--------------------------------------------------------------------------
// 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_CONDITIONS_IOV_H
#define DD4HEP_CONDITIONS_IOV_H

// C/C++ include files
#include <string>
#include <algorithm>

namespace DD4hep {

  class IOVType;
  class IOV;


  class IOVType   {
  public:
    enum { UNKNOWN_IOV = ~0x0 } _IOVTypes;
    unsigned int type = UNKNOWN_IOV;
    std::string  name;
    IOVType() = default;
    ~IOVType() = default;
    IOVType(const IOVType& copy) : type(copy.type), name(copy.name) {}
    IOVType& operator=(const IOVType& copy);
    std::string str() const;
  };


  class IOV   {
  private:
    explicit IOV() = delete;
  public:
    typedef long Key_first_type;
    typedef long Key_second_type;
    typedef std::pair<Key_first_type,Key_second_type> Key;

    const IOVType* iovType;
    Key            keyData;
    int            optData;
    unsigned int   type;

    explicit IOV(const IOVType* typ);
    explicit IOV(const IOVType* typ, const Key& key);
    IOV(const IOV& copy) = default;
    ~IOV() = default;
    IOV& operator=(const IOV& c) = default;
    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_first_type value);
    void set(Key_first_type val_1, Key_second_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 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);      }
  };
    
} /* End namespace DD4hep                   */
#endif    /* DD4HEP_CONDITIONS_IOV_H        */