/Users/thomasburton/Documents/projects/eic/Utilities/eicplot/trunk/include/eicplot/Utilities.h

#ifndef _EICPLOT_UTILITIES_H_
#define _EICPLOT_UTILITIES_H_

#include <functional>
#include <stdexcept>

#include <TObject.h>
#include <TVirtualPad.h>

class TAxis;
class TH1;

namespace erhic {

   double toDegrees(const double& radians);

   double toRadians(const double& degrees);
   
   template<typename T>
   class Range : public TObject {
   public:

      typedef T Type;

      virtual ~Range() { }

      Range(const T& low = T(), const T& up = T()) : mRange(low, up) {
      }

      T lower() const { return mRange.first;}

      T middle() const { return 0.5 * (upper() + lower()); }

      T upper() const { return mRange.second; }

      T span() const { return upper() - lower(); }

      bool excludes(const T& t) const { return t >= upper() or t < lower(); }

      bool contains(const T& t) const { return not excludes(t); }

      std::ostream& print(std::ostream& os) const {
         return os << lower() << ' '<< upper();
      }

      bool operator<(const Range<T>& other) const {
         if(lower() < other.lower()) return true;
         if(other.lower() > lower()) return false;
         // Lower limit must be equal
         return upper() < other.upper();
      }

   protected:

      std::pair<T, T> mRange;

      ClassDef(Range, 1)
   };

   template<typename T>
   class Range2D {
   public:

      typedef T Type;
      virtual ~Range2D() { }

      Range2D(const Range<T>& inDimension1 = Range<T>(),
               const Range<T>& inDimension2 = Range<T>())
      : mDimension1(inDimension1), mDimension2(inDimension2) { }

      bool excludes(const std::pair<T, T>& test) const {
         return
         mDimension1.excludes(test.first)
         or
         mDimension2.excludes(test.second);
      }

      bool contains(const std::pair<T, T>& test) const {
         return not excludes(test);
      }

      bool operator<(const Range2D& other) const {
         if(mDimension1 < other.mDimension1) return true;
         if(other.mDimension1 < mDimension1) return false;
         if(mDimension2 < other.mDimension2) return true;
         return false;
      }

      std::ostream& print(std::ostream& os) const {
         mDimension1.print(os) << '\t';
         return mDimension2.print(os);
      }

   protected:

      Range<T> mDimension1;
      Range<T> mDimension2;

      ClassDef(Range2D, 1)
   };

   class LogPad
   : public TObject, std::unary_function<TVirtualPad*, TVirtualPad*> {
   public:

      LogPad(Int_t x = 1, Int_t y = 1, Int_t z = 1);

      virtual ~LogPad();

      TVirtualPad* operator()(TVirtualPad* pad) const;

   protected:

      Int_t mX;
      Int_t mY;
      Int_t mZ;

      ClassDef(erhic::LogPad, 1)
   };

   class BinLog10 : public std::unary_function<TAxis*, void> {
   public:

      BinLog10();

      virtual ~BinLog10();

      virtual TAxis* operator()(TAxis*) const;

      virtual TAxis* operator()(TAxis&) const;

      virtual TH1* operator()(TH1*) const;

      virtual TH1* operator()(TH1&) const;

      ClassDef(erhic::BinLog10, 1)
   };
} // namespace erhic

#endif