AliEmcalIterableContainer.h

Go to the documentation of this file.

#ifndef ALIEMCALITERABLECONTAINER_H
#define ALIEMCALITERABLECONTAINER_H
/* Copyright(c) 1998-2016, ALICE Experiment at CERN, All rights reserved. *
 * See cxx source for full Copyright notice                               */

#include <iterator>

#include <TArrayI.h>

class AliEmcalContainer;

template <class T>
class AliEmcalIterableContainerT {
public:
  class iterator : public std::iterator<std::bidirectional_iterator_tag,
                                        TObject,std::ptrdiff_t,
                                        TObject **, TObject *>{
  public:
    iterator(const AliEmcalIterableContainerT<T> *cont, int currentpos, bool forward = true);
    iterator(const iterator &ref);
    iterator &operator=(const iterator &ref);
    virtual ~iterator(){}

    bool operator!=(const iterator &ref) const;

    iterator &operator++();
    iterator operator++(int);
    iterator &operator--();
    iterator operator--(int);

    T *operator*() const;

  private:
    iterator();

    const AliEmcalIterableContainerT<T>     *fkData;    
    int                                      fCurrent;  
    bool                                     fForward;  
  };

  AliEmcalIterableContainerT();
  AliEmcalIterableContainerT(const AliEmcalContainer *cont, bool useAccept);
  AliEmcalIterableContainerT(const AliEmcalIterableContainerT<T> &ref);
  AliEmcalIterableContainerT<T> &operator=(const AliEmcalIterableContainerT<T> &ref);

  virtual ~AliEmcalIterableContainerT() {}

  T *operator[](int index) const;

  operator int() const { return GetEntries(); }

  const AliEmcalContainer *GetContainer() const { return fkContainer; }

  int GetEntries() const;

  iterator begin() const { return iterator(this, 0, true); }

  iterator end() const { return iterator(this, GetEntries(), true); }

  iterator rbegin() const { return iterator(this, GetEntries()-1, false); }

  iterator rend() const { return iterator(this, -1, false); }

protected:
  void BuildAcceptIndices();

private:
  const AliEmcalContainer     *fkContainer;         
  TArrayI                     fAcceptIndices;       
  Bool_t                      fUseAccepted;         
};

#include "AliEmcalContainer.h"

template <class T>
AliEmcalIterableContainerT<T>::AliEmcalIterableContainerT():
  fkContainer(NULL),
  fAcceptIndices(),
  fUseAccepted(kFALSE)
{

}

template <class T>
AliEmcalIterableContainerT<T>::AliEmcalIterableContainerT(const AliEmcalContainer *cont, bool useAccept):
  fkContainer(cont),
  fAcceptIndices(),
  fUseAccepted(useAccept)
{
  if (fUseAccepted) BuildAcceptIndices();
}

template <class T>
AliEmcalIterableContainerT<T>::AliEmcalIterableContainerT(const AliEmcalIterableContainerT<T> &ref):
  fkContainer(ref.fkContainer),
  fAcceptIndices(ref.fAcceptIndices),
  fUseAccepted(ref.fUseAccepted)
{

}

template <class T>
AliEmcalIterableContainerT<T> &AliEmcalIterableContainerT<T>::operator=(const AliEmcalIterableContainerT<T>& ref) {
  if(this != &ref){
    fkContainer = ref.fkContainer;
    fAcceptIndices = ref.fAcceptIndices;
    fUseAccepted = ref.fUseAccepted;
  }
  return *this;
}

template <class T>
int AliEmcalIterableContainerT<T>::GetEntries() const {
  return fUseAccepted ? fAcceptIndices.GetSize() : fkContainer->GetNEntries();
}

template <class T>
T *AliEmcalIterableContainerT<T>::operator[](int index) const {
  if(index < 0 || index >= GetEntries()) return NULL;
  const AliEmcalContainer &contref = *fkContainer;
  return static_cast<T*>(fUseAccepted ? contref[fAcceptIndices[index]] : contref[index]);
}

template <class T>
void AliEmcalIterableContainerT<T>::BuildAcceptIndices(){
  fAcceptIndices.Set(fkContainer->GetNAcceptEntries());
  int acceptCounter = 0;
  for(int index = 0; index < fkContainer->GetNEntries(); index++){
    UInt_t rejectionReason = 0;
    if(fkContainer->AcceptObject(index, rejectionReason)) fAcceptIndices[acceptCounter++] = index;
  }
}


template <class T>
AliEmcalIterableContainerT<T>::iterator::iterator(const AliEmcalIterableContainerT<T> *cont, int currentpos, bool forward):
fkData(cont),
fCurrent(currentpos),
fForward(forward)
{

}

template <class T>
AliEmcalIterableContainerT<T>::iterator::iterator(const AliEmcalIterableContainerT<T>::iterator &ref):
     fkData(ref.fkData),
     fCurrent(ref.fCurrent),
     fForward(ref.fForward)
{

}

template <class T>
typename AliEmcalIterableContainerT<T>::iterator &AliEmcalIterableContainerT<T>::iterator::operator=(const AliEmcalIterableContainerT<T>::iterator &ref){
  if(this != &ref){
    fkData = ref.fkData;
    fCurrent = ref.fCurrent;
    fForward = ref.fForward;
  }
  return *this;
}

template <class T>
bool AliEmcalIterableContainerT<T>::iterator::operator!=(const AliEmcalIterableContainerT<T>::iterator &ref) const{
  return fCurrent != ref.fCurrent;
}

template <class T>
typename AliEmcalIterableContainerT<T>::iterator &AliEmcalIterableContainerT<T>::iterator::operator++(){
  if(fForward) fCurrent++;
  else fCurrent--;
  return *this;
}

template <class T>
typename AliEmcalIterableContainerT<T>::iterator &AliEmcalIterableContainerT<T>::iterator::operator--(){
  if(fForward) fCurrent--;
  else fCurrent++;
  return *this;
}

template <class T>
typename AliEmcalIterableContainerT<T>::iterator AliEmcalIterableContainerT<T>::iterator::operator++(int index){
  AliEmcalIterableContainerT<T>::iterator tmp(*this);
  operator++();
  return tmp;
}

template <class T>
typename AliEmcalIterableContainerT<T>::iterator AliEmcalIterableContainerT<T>::iterator::operator--(int index){
  AliEmcalIterableContainerT<T>::iterator tmp(*this);
  operator--();
  return tmp;
}

template <class T>
T *AliEmcalIterableContainerT<T>::iterator::operator*() const {
  return (*fkData)[fCurrent];
}

#endif /* ALIEMCALITERABLECONTAINER_H */