AliEmcalIterableContainer.h

Go to the documentation of this file.

#ifndef ALIEMCALITERABLECONTAINER_H
#define ALIEMCALITERABLECONTAINER_H
#if !(defined(__CINT__) || defined(__MAKECINT__))

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

#include <iterator>
#include <vector>
#include <type_traits>
#include <TArrayI.h>
#include "AliTLorentzVector.h"


#if (__GNUC__ >= 3) && !defined(__INTEL_COMPILER)
// gcc warns in level Weffc++ about non-virtual destructor
// in std::iterator. It is a false positive, therefore Weffc++
// needs to be disabled for AliEmcalIterableContainerT
#pragma GCC system_header
#endif

#if (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) >= 40600
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Weffc++"
#endif

class AliEmcalContainer;

namespace EMCALIterableContainer {

template <typename T>
class operator_star_pair {
public:
  typedef typename std::pair<AliTLorentzVector, T*> momentum_object_pair;
  typedef const momentum_object_pair& star_return_type;
  typedef const momentum_object_pair* arrow_return_type;
  typedef momentum_object_pair iterator_type;

  static star_return_type star(momentum_object_pair* ptr) { return *ptr; }
  static arrow_return_type arrow(momentum_object_pair* ptr) { return ptr; }
};

template <typename T>
class operator_star_object {
public:
  typedef typename std::pair<AliTLorentzVector, T*> momentum_object_pair;
  typedef T* star_return_type;
  typedef T** arrow_return_type;
  typedef T* iterator_type;

  static star_return_type star(momentum_object_pair* ptr) { return ptr->second; }
  static arrow_return_type arrow(momentum_object_pair* ptr) { return &(ptr->second); }
};

template <typename T, typename STAR=operator_star_object<T> >
class AliEmcalIterableContainerT final {
public:
  typedef typename std::pair<AliTLorentzVector, T*> momentum_object_pair;

  class iterator;
  friend class iterator;
  class iterator final : public std::iterator<std::bidirectional_iterator_tag, typename STAR::iterator_type, std::ptrdiff_t> {
  public:
    iterator(const AliEmcalIterableContainerT<T, STAR> *cont, int currentpos, bool forward = true);
    iterator(const iterator &ref);
    iterator &operator=(const iterator &ref);
    ~iterator(){}

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

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

    typename STAR::star_return_type operator*() { return STAR::star(&(this->fCurrentElement)); }
    typename STAR::arrow_return_type operator->() { return STAR::arrow(&(this->fCurrentElement)); }

    int current_index() const { return fkData->GetInternalIndex(fCurrent); }
    const AliTLorentzVector& get_momentum() const { return this->fCurrentElement.first; }

  private:
    iterator();

    const AliEmcalIterableContainerT<T, STAR>*fkData;          
    int                                      fCurrent;        
    bool                                     fForward;        
    momentum_object_pair                     fCurrentElement; 

    inline void update_current_element() {
      if (fCurrent < 0 || fCurrent >= fkData->GetContainer()->GetNEntries()) {
        this->fCurrentElement.first.SetPxPyPzE(0,0,0,0);
        this->fCurrentElement.second = 0;
      }
      else {
        this->fCurrentElement.second = (*fkData)[fCurrent];
        fkData->GetContainer()->GetMomentum(this->fCurrentElement.first, fkData->GetInternalIndex(fCurrent));
      }
    }
  };

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

  ~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;         

  inline int GetInternalIndex(int index) const {
    if (fUseAccepted) {
      return index < 0 || index >= fAcceptIndices.GetSize() ? -1 : fAcceptIndices[index];
    }
    else {
      return index;
    }
  }
};
}

#if (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) >= 40600
#pragma GCC diagnostic pop
#endif

#include "AliEmcalContainer.h"

namespace EMCALIterableContainer {
template <typename T, typename STAR>
AliEmcalIterableContainerT<T, STAR>::AliEmcalIterableContainerT():
  fkContainer(NULL),
  fAcceptIndices(),
  fUseAccepted(kFALSE)
{

}

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

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

}

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

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

template <typename T, typename STAR>
T *AliEmcalIterableContainerT<T, STAR>::operator[](int index) const {
  const AliEmcalContainer &contref = *fkContainer;
  int _index = GetInternalIndex(index);
  if(_index < 0 || _index >= contref.GetNEntries()) return NULL;
  return static_cast<T*>(contref[_index]);
}

template <typename T, typename STAR>
void AliEmcalIterableContainerT<T, STAR>::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 <typename T, typename STAR>
AliEmcalIterableContainerT<T, STAR>::iterator::iterator(const AliEmcalIterableContainerT<T, STAR> *cont, int currentpos, bool forward):
  fkData(cont),
  fCurrent(currentpos),
  fForward(forward),
  fCurrentElement()
{
  update_current_element();
}

template <typename T, typename STAR>
AliEmcalIterableContainerT<T, STAR>::iterator::iterator(const AliEmcalIterableContainerT<T, STAR>::iterator &ref):
  fkData(ref.fkData),
  fCurrent(ref.fCurrent),
  fForward(ref.fForward),
  fCurrentElement()
{
  update_current_element();
}

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

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

template <typename T, typename STAR>
typename AliEmcalIterableContainerT<T, STAR>::iterator &AliEmcalIterableContainerT<T, STAR>::iterator::operator++(){
  if(fForward) fCurrent++;
  else fCurrent--;

  update_current_element();

  return *this;
}

template <typename T, typename STAR>
typename AliEmcalIterableContainerT<T, STAR>::iterator &AliEmcalIterableContainerT<T, STAR>::iterator::operator--(){
  if(fForward) fCurrent--;
  else fCurrent++;

  update_current_element();

  return *this;
}

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

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

}

#endif
#endif /* ALIEMCALITERABLECONTAINER_H */