RhoColumn.h

Go to the documentation of this file.

#ifndef RHOCOLUMN_H
#define RHOCOLUMN_H
//                                                                      //
// RhoColumn                                                            //
//                                                                      //
// Nested class hierarchy to hold information about TTuple columns.     //
//                                                                      //
// Author List:                                                         //
// Marcel Kunze,  RUB, Mar. 99                                          //
// Apr.2001 (MK), Inherit from TNamed to support THashList              //
// Copyright (C) 1999-2001, Ruhr-University Bochum.                     //
// Ralf Kliemt, HIM/GSI Feb.2013 (Cleanup & Restructuring)              //
//                                                                      //

#include "TNamed.h"
#include "TString.h"
#include "TVector.h"

class TTree;
class TBranch;

#ifndef RhoHTRange_HH
#define RhoHTRange_HH

template <class T>
class RhoHTRange {

  //--------------------
  // Declarations     --
  //--------------------

  // Typedefs, consts, and enums

  //--------------------
  // Instance Members --
  //--------------------

 public:
  // Constructors
  RhoHTRange() : fDefined(kFALSE), fLower(0), fUpper(0) {}

  RhoHTRange(T lowerv, T upperv) : fDefined(kTRUE), fLower(lowerv), fUpper(upperv) {}

  // Copy Constructor
  RhoHTRange(const RhoHTRange<T> &o) : fDefined(o.fDefined), fLower(o.fLower), fUpper(o.fUpper) {}

  // Destructor
  virtual ~RhoHTRange() {}

  // Operators

  RhoHTRange<T> &operator=(const RhoHTRange<T> &o)
  {
    if (&o == this) {
      return *this;
    }
    fDefined = o.fDefined;
    fLower = o.fLower;
    fUpper = o.fUpper;
    return *this;
  }

  // Selectors (const)
  Bool_t operator()() const { return fDefined; }

  // get upper/lower limits
  T lower() const { return fLower; }
  T upper() const { return fUpper; }

  // Modifiers

 protected:
  // Helper functions

 private:
  // Friends

  // Data members
  Bool_t fDefined;
  T fLower, fUpper;
};
#endif

#ifndef RhoHTAbsValVector_HH
#define RhoHTAbsValVector_HH

template <class T>
class RhoHTAbsValVector {

 public:
  // This must return the number of the stored elements
  virtual size_t length() const = 0;
  virtual ~RhoHTAbsValVector(){};
  // This provides access to the indifidual elements.
  // Index runs from 0 to length()-1. Here () means that we do not requre
  // index checking from it, though the real classe may do what they like.
  virtual const T &operator()(size_t i) const = 0;
};
#endif

// Parent class (abstract):
class RhoColumn : public TNamed {
 public:
  RhoColumn(const char *l) : TNamed(l, l), fLabel(l), fUseDefValue(0), fPointer(nullptr), fBranch(nullptr) {}
  virtual ~RhoColumn() {}
  const TString &GetLabel() const { return fLabel; }
  TBranch *GetBrPointer() { return fBranch; }
  void *GetPointer() { return fPointer; }
  void SetPointer(void *p) { fPointer = p; }
  void SetUseDefValue(Int_t b) { fUseDefValue = b; }
  const Int_t &GetUseDefValue() const { return fUseDefValue; }
  virtual void SetDefValue() = 0;
  virtual void SetValue(const void *, RhoColumn *cp = nullptr) = 0;

 protected:
  TString fLabel;
  Int_t fUseDefValue;
  void *fPointer;
  TBranch *fBranch;
};

// Classes for Bool_t:
class RhoBoolColumn : public RhoColumn {
 public:
  RhoBoolColumn(const char *, const Bool_t &, const Bool_t &, TTree *);
  virtual ~RhoBoolColumn() { delete (Bool_t *)fPointer; }
  virtual void SetDefValue() { *(Char_t *)fPointer = fDefValue; }
  virtual void SetValue(const void *p, RhoColumn *) { *(Char_t *)fPointer = *(const Bool_t *)p; }

 private:
  Bool_t fDefValue;
};

class RhoBoolArrColumn : public RhoColumn {
 public:
  RhoBoolArrColumn(const char *, const RhoHTAbsValVector<Bool_t> &, const Bool_t &, TTree *);
  virtual ~RhoBoolArrColumn() { delete[](Bool_t *) fPointer; }
  virtual void SetDefValue()
  {
    for (Int_t i = 0; i < fMax; ++i) {
      ((Char_t *)fPointer)[i] = fDefValue;
    }
  }
  virtual void SetValue(const void *, RhoColumn *cp = nullptr);

 private:
  Bool_t fDefValue;
  Int_t fMax;
};

class RhoBoolDynArrColumn : public RhoColumn {
 public:
  RhoBoolDynArrColumn(const char *, const RhoHTAbsValVector<Bool_t> &, const Bool_t &, RhoColumn *, TTree *);
  virtual ~RhoBoolDynArrColumn() { delete[](Bool_t *) fPointer; }
  virtual void SetDefValue();
  virtual void SetValue(const void *, RhoColumn *cp = nullptr);

 private:
  Bool_t fDefValue;
  RhoColumn *fIndexPtr;
};

// Classes for Int_t:
class RhoIntColumn : public RhoColumn {
 public:
  RhoIntColumn(const char *, const Int_t &, const Int_t &, TTree *);
  virtual ~RhoIntColumn() { delete (Int_t *)fPointer; }
  virtual void SetDefValue() { *(Int_t *)fPointer = fDefValue; }
  virtual void SetValue(const void *p, RhoColumn *) { *(Int_t *)fPointer = *(const Int_t *)p; }

 private:
  Int_t fDefValue;
};

class RhoIntArrColumn : public RhoColumn {
 public:
  RhoIntArrColumn(const char *, const RhoHTAbsValVector<Int_t> &, const Int_t &, TTree *);
  virtual ~RhoIntArrColumn() { delete[](Int_t *) fPointer; }
  virtual void SetDefValue()
  {
    for (Int_t i = 0; i < fMax; ++i) {
      ((Int_t *)fPointer)[i] = fDefValue;
    }
  }
  virtual void SetValue(const void *, RhoColumn *cp = nullptr);

 private:
  Int_t fDefValue;
  Int_t fMax;
};

class RhoIntDynArrColumn : public RhoColumn {
 public:
  RhoIntDynArrColumn(const char *, const RhoHTAbsValVector<Int_t> &, const Int_t &, RhoColumn *, TTree *);
  virtual ~RhoIntDynArrColumn() { delete[](Int_t *) fPointer; }
  virtual void SetDefValue();
  virtual void SetValue(const void *, RhoColumn *cp = nullptr);

 private:
  Int_t fDefValue;
  RhoColumn *fIndexPtr;
};

// Classes for Float_t:
class RhoFloatColumn : public RhoColumn {
 public:
  RhoFloatColumn(const char *, const Float_t &, const Float_t &, TTree *);
  virtual ~RhoFloatColumn() { delete (Float_t *)fPointer; }
  virtual void SetDefValue() { *(Float_t *)fPointer = fDefValue; }
  virtual void SetValue(const void *p, RhoColumn *) { *(Float_t *)fPointer = *(const Float_t *)p; }

 private:
  Float_t fDefValue;
};

class RhoFloatArrColumn : public RhoColumn {
 public:
  RhoFloatArrColumn(const char *, const RhoHTAbsValVector<Float_t> &, const Float_t &, TTree *);
  RhoFloatArrColumn(const char *, const TVector &, const Float_t &, TTree *);
  virtual ~RhoFloatArrColumn() { delete[](Float_t *) fPointer; }
  virtual void SetDefValue()
  {
    for (Int_t i = 0; i < fMax; ++i) {
      ((Float_t *)fPointer)[i] = fDefValue;
    }
  }
  virtual void SetValue(const void *, RhoColumn *cp = nullptr);

 private:
  Float_t fDefValue;
  Int_t fMax;
};

class RhoFloatDynArrColumn : public RhoColumn {
 public:
  RhoFloatDynArrColumn(const char *, const RhoHTAbsValVector<Float_t> &, const Float_t &, RhoColumn *, TTree *);
  RhoFloatDynArrColumn(const char *, const TVector &, const Float_t &, RhoColumn *, TTree *);
  virtual ~RhoFloatDynArrColumn() { delete[](Float_t *) fPointer; }
  virtual void SetDefValue();
  virtual void SetValue(const void *, RhoColumn *cp = nullptr);

 private:
  Float_t fDefValue;
  RhoColumn *fIndexPtr;
};

// Classes for Double_t:
class RhoDoubleColumn : public RhoColumn {
 public:
  RhoDoubleColumn(const char *, const Double_t &, const Double_t &, TTree *);
  virtual ~RhoDoubleColumn() { delete (Double_t *)fPointer; }
  virtual void SetDefValue() { *(Double_t *)fPointer = fDefValue; }
  virtual void SetValue(const void *p, RhoColumn *) { *(Double_t *)fPointer = *(const Double_t *)p; }

 private:
  Double_t fDefValue;
};

class RhoDoubleArrColumn : public RhoColumn {
 public:
  RhoDoubleArrColumn(const char *, const RhoHTAbsValVector<Double_t> &, const Double_t &, TTree *);
  virtual ~RhoDoubleArrColumn() { delete[](Double_t *) fPointer; }
  virtual void SetDefValue()
  {
    for (Int_t i = 0; i < fMax; ++i) {
      ((Double_t *)fPointer)[i] = fDefValue;
    }
  }
  virtual void SetValue(const void *, RhoColumn *cp = nullptr);

 private:
  Double_t fDefValue;
  Int_t fMax;
};

class RhoDoubleDynArrColumn : public RhoColumn {
 public:
  RhoDoubleDynArrColumn(const char *, const RhoHTAbsValVector<Double_t> &, const Double_t &, RhoColumn *, TTree *);
  virtual ~RhoDoubleDynArrColumn() { delete[](Double_t *) fPointer; }
  virtual void SetDefValue();
  virtual void SetValue(const void *, RhoColumn *cp = nullptr);

 private:
  Double_t fDefValue;
  RhoColumn *fIndexPtr;
};

// String column:
class RhoStringColumn : public RhoColumn {
 public:
  RhoStringColumn(const TString &, const TString &, const TString &, TTree *);
  virtual ~RhoStringColumn() { delete[](TString *) fPointer; }
  virtual void SetDefValue();
  virtual void SetValue(const void *, RhoColumn *cp = nullptr);

 private:
  TString fDefValue;
};

#endif