Array.h

/*
 * HalMemoryManagerArrays.h
 *
 *  Created on: 30-04-2022
 *      Author: Daniel Wielanek
 *      E-mail: daniel.wielanek@gmail.com
 *      Warsaw University of Technology, Faculty of Physics
 */
#ifndef HALMEMORYMANAGERARRAYS_H_
#define HALMEMORYMANAGERARRAYS_H_
#include <TNamed.h>
#include <TObject.h>
 
namespace Hal {
  template<typename T>
  class Array_1 : public TObject {
    Int_t fSize;
    T* fArray;  //[fSize]
  public:
    Array_1() : TObject(), fSize(0), fArray(nullptr) {}
    Array_1(Int_t size);
    Array_1(const Array_1<T>& obj);
    void MakeBigger(Int_t new_dim);
    void Resize(Int_t new_dim);
    inline T& operator[](const int index) { return fArray[index]; };
    inline Int_t GetSize() const { return fSize; }
    inline T* GetArray() const { return fArray; };
    void Add(Array_1<T> const& rhs);
    Array_1<T>& operator=(const Array_1<T>& rhs);
    Array_1<T>& operator+=(const Array_1<T>& rhs);
 
    Array_1<T>& operator-=(const Array_1<T>& rhs);
 
    Array_1<T>& operator+(const Array_1<T>& rhs);
 
    Array_1<T>& operator-(const Array_1<T>& rhs);
 
    Array_1<T>& operator*(const T& val);
 
    Array_1<T>& operator/(const T& val);
 
    Array_1<T>& operator*=(const T& val);
 
    Array_1<T>& operator/=(const T& val);
 
    T FindMin(Int_t& index) const;
 
    T FindMax(Int_t& index) const;
 
    inline T Get(Int_t i) const { return fArray[i]; };
    inline void Set(Int_t index, T val) { fArray[index] = val; };
    inline T IncrementAfter(Int_t i);  //{return fArray[i]++;};
    virtual ~Array_1() {
      if (fArray) delete[] fArray;
    };
    ClassDef(Array_1, 1)
  };
  template<typename T>
  T Array_1<T>::IncrementAfter(Int_t i) {
    return fArray[i]++;
  }
  template<>
  inline Bool_t Array_1<Bool_t>::IncrementAfter(Int_t i) {
    return fArray[i];
  }
  template<typename T>
  class Array_2 : public TObject {
    Int_t fSize;
    Array_1<T>* fArray;  //[fSize]
  public:
    Array_2() : TObject(), fSize(0), fArray(NULL) {};
    Array_2(Int_t x, Int_t y);
    Array_2(const Array_2<T>& obj);
    void MakeBigger(Int_t sizeA, Int_t sizeB);
    inline Int_t GetSize() const { return fSize; }
    inline Array_1<T>* At(const Int_t i) { return &fArray[i]; };
    Array_2<T>& operator=(const Array_2<T>& rhs);
    Array_2<T>& operator+=(const Array_2<T>& rhs);
    inline T Get(Int_t i, Int_t j) const { return fArray[i].Get(j); };
    inline Array_1<T>& operator[](const int index) { return fArray[index]; };
    inline void Set(Int_t i, Int_t j, T val) { fArray[i].Set(j, val); };
    inline T IncrementAfter(Int_t i, Int_t j) { return fArray[i].IncrementAfter(j); };
    virtual ~Array_2() {
      if (fArray) delete[] fArray;
    };
    ClassDef(Array_2, 1)
  };
  template<typename T>
  class Array_3 : public TObject {
    Int_t fSize;
    Array_2<T>* fArray;  //[fSize]
  public:
    Array_3() : TObject(), fSize(0), fArray(NULL) {};
    Array_3(Int_t x, Int_t y, Int_t z);
    Array_3(const Array_3<T>& obj);
    void MakeBigger(Int_t sizeA, Int_t sizeB, Int_t sizeC);
    inline Int_t GetSize() const { return fSize; }
    inline Array_2<T>& operator[](const int index) { return fArray[index]; };
    inline Array_2<T>* At(Int_t i) const { return &fArray[i]; };
    Array_3<T>& operator=(const Array_3<T>& rhs);
    Array_3<T>& operator+=(const Array_3<T>& rhs);
    inline T Get(Int_t A, Int_t B, Int_t C) const { return fArray[A].Get(B, C); };
    inline T IncrementAfter(Int_t A, Int_t B, Int_t C) { return fArray[A].IncrementAfter(B, C); };  // do i++ and return i !
    inline void Set(Int_t A, Int_t B, Int_t C, T val) { fArray[A].Set(B, C, val); };
    virtual ~Array_3() {
      if (fArray) delete[] fArray;
    }
    ClassDef(Array_3, 1)
  };
 
  template<typename T>
  class Array_4 : public TObject {
    Int_t fSize;
    Array_3<T>* fArray;  //[fSize]
  public:
    Array_4() : TObject(), fSize(0), fArray(NULL) {};
    Array_4(Int_t x, Int_t y, Int_t z, Int_t t);
    Array_4(const Array_4<T>& obj);
    void MakeBigger(Int_t sizeA, Int_t sizeB, Int_t sizeC, Int_t sizeD);
    inline Array_3<T>& operator[](const int index) { return fArray[index]; };
    inline Array_3<T>* At(Int_t i) const { return &fArray[i]; };
    Array_4<T>& operator=(const Array_4<T>& rhs);
    Array_4<T>& operator+=(const Array_4<T>& rhs);
    inline Int_t GetSize() const { return fSize; }
    inline T Get(Int_t A, Int_t B, Int_t C, Int_t D) const { return fArray[A].Get(B, C, D); };
    inline T IncrementAfter(Int_t A, Int_t B, Int_t C, Int_t D) { return fArray[A].IncrementAfter(B, C, D); };
    inline void Set(Int_t A, Int_t B, Int_t C, Int_t D, T val) { fArray[A].Set(B, C, D, val); };
    virtual ~Array_4() {
      if (fArray) delete[] fArray;
    }
    ClassDef(Array_4, 1)
  };
}  // namespace Hal
#endif /* HALMEMORYMANAGERARRAYS_H_ */