AbsHcalFunctor.h

Go to the documentation of this file.

#ifndef CondFormats_HcalObjects_AbsHcalFunctor_h
#define CondFormats_HcalObjects_AbsHcalFunctor_h

#include <cfloat>
#include <typeinfo>

#include "boost/serialization/access.hpp"
#include "boost/serialization/base_object.hpp"
#include "boost/serialization/export.hpp"

// Archive headers are needed here for the serialization registration to work.
// <cassert> is needed for the archive headers to work.
#if !defined(__GCCXML__)
#include <cassert>
#include "CondFormats/Serialization/interface/eos/portable_iarchive.hpp"
#include "CondFormats/Serialization/interface/eos/portable_oarchive.hpp"
#endif /* #if !defined(__GCCXML__) */

class AbsHcalFunctor {
public:
  inline virtual ~AbsHcalFunctor() {}

  // Method to override by concrete storable functor classes
  virtual double operator()(double x) const = 0;

  // Functor domain. Should be overriden by derived classes if needed.
  inline virtual double xmin() const { return -DBL_MAX; }
  inline virtual double xmax() const { return DBL_MAX; }

  // Comparison operators. Note that they are not virtual and should
  // not be overriden by derived classes. These operators are very
  // useful for I/O testing.
  inline bool operator==(const AbsHcalFunctor& r) const { return (typeid(*this) == typeid(r)) && this->isEqual(r); }
  inline bool operator!=(const AbsHcalFunctor& r) const { return !(*this == r); }

protected:
  // Method needed to compare objects for equality.
  // Must be implemented by derived classes.
  virtual bool isEqual(const AbsHcalFunctor&) const = 0;

  // Check if the sequence of values is strictly increasing
  template <class Iter>
  static bool isStrictlyIncreasing(Iter begin, Iter const end) {
    if (begin == end)
      return false;
    Iter first(begin);
    bool status = ++begin != end;
    for (; begin != end && status; ++begin, ++first)
      if (!(*first < *begin))
        status = false;
    return status;
  }

  // Check if the sequence of values is strictly decreasing
  template <class Iter>
  static bool isStrictlyDecreasing(Iter begin, Iter const end) {
    if (begin == end)
      return false;
    Iter first(begin);
    bool status = ++begin != end;
    for (; begin != end && status; ++begin, ++first)
      if (!(*begin < *first))
        status = false;
    return status;
  }

private:
  friend class boost::serialization::access;
  template <typename Ar>
  inline void serialize(Ar& ar, unsigned /* version */) {}
};

BOOST_CLASS_EXPORT_KEY(AbsHcalFunctor)

#endif  // CondFormats_HcalObjects_AbsHcalFunctor_h