StackIteratorInterface.hpp

/*
 * (c) Copyright 2020 CORSIKA Project, corsika-project@lists.kit.edu
 *
 * This software is distributed under the terms of the GNU General Public
 * Licence version 3 (GPL Version 3). See file LICENSE for a full version of
 * the license.
 */

#pragma once

#include <corsika/framework/stack/ParticleBase.hpp>

#include <boost/type_index.hpp>

namespace corsika::history {
  template <typename T, template <typename> typename TParticleInterface>
  class HistorySecondaryProducer; // forward decl.
}

namespace corsika {

  template <typename TStackData, template <typename> typename TParticleInterface,
            template <class T1, template <class> class T2> class MSecondaryProducer>
  class Stack; // forward decl

  template <typename TStackData, template <typename> typename TParticleInterface,
            template <class T1, template <class> class T2> class MSecondaryProducer>
  class SecondaryView; // forward decl

  template <typename TStackData, template <typename> typename TParticleInterface,
            template <class T1, template <class> class T2> class MSecondaryProducer,
            typename StackType>
  class ConstStackIteratorInterface; // forward decl

  template <typename TStackData, template <typename> typename TParticleInterface,
            template <typename T1, template <class> class T2> class MSecondaryProducer,
            typename TStackType =
                Stack<TStackData, TParticleInterface, MSecondaryProducer>>
  class StackIteratorInterface
      : public TParticleInterface<StackIteratorInterface<
            TStackData, TParticleInterface, MSecondaryProducer, TStackType>> {

  public:
    typedef TParticleInterface<corsika::StackIteratorInterface<
        TStackData, TParticleInterface, MSecondaryProducer, TStackType>>
        particle_interface_type;

    typedef TStackType stack_type;
    typedef TStackData stack_data_type;

    // it is not allowed to create a "dangling" stack iterator
    StackIteratorInterface() = delete; 

    StackIteratorInterface(StackIteratorInterface&& rhs)
        : index_(std::move(rhs.index_))
        , data_(std::move(rhs.data_)) {}

    StackIteratorInterface(StackIteratorInterface const& vR)
        : index_(vR.index_)
        , data_(vR.data_) {}

    StackIteratorInterface& operator=(StackIteratorInterface const& vR) {
      if (&vR != this) {
        index_ = vR.index_;
        data_ = vR.data_;
      }
      return *this;
    }

    StackIteratorInterface(stack_type& data, unsigned int const index)
        : index_(index)
        , data_(&data) {}

    template <typename... TArgs>
    StackIteratorInterface(stack_type& data, unsigned int const index,
                           const TArgs... args)
        : index_(index)
        , data_(&data) {

      (**this).setParticleData(args...);
    }

    template <typename... TArgs>
    StackIteratorInterface(stack_type& data, unsigned int const index,
                           StackIteratorInterface& parent, const TArgs... args)
        : index_(index)
        , data_(&data) {

      (**this).setParticleData(*parent, args...);
    }

    bool isErased() const { return getStack().isErased(*this); }

  public:
    StackIteratorInterface& operator++() {
      do {
        ++index_;
      } while (
          getStack().isErased(*this)); // this also check the allowed bounds of index_
      return *this;
    }
    StackIteratorInterface operator++(int) {
      StackIteratorInterface tmp(*this);
      do {
        ++index_;
      } while (
          getStack().isErased(*this)); // this also check the allowed bounds of index_
      return tmp;
    }
    StackIteratorInterface operator+(int delta) const {
      return StackIteratorInterface(*data_, index_ + delta);
    }
    bool operator==(StackIteratorInterface const& rhs) const {
      return index_ == rhs.index_;
    }
    bool operator!=(StackIteratorInterface const& rhs) const {
      return index_ != rhs.index_;
    }
    bool operator==(const ConstStackIteratorInterface<
                    TStackData, TParticleInterface, MSecondaryProducer,
                    stack_type>& rhs) const; // implemented below
    bool operator!=(const ConstStackIteratorInterface<
                    TStackData, TParticleInterface, MSecondaryProducer,
                    stack_type>& rhs) const; // implemented below

    particle_interface_type& operator*() {
      return static_cast<particle_interface_type&>(*this);
    }

    particle_interface_type const& operator*() const {
      return static_cast<particle_interface_type const&>(*this);
    }

  protected:
    unsigned int getIndex() const { return index_; }
    stack_type& getStack() { return *data_; }
    stack_type const& getStack() const { return *data_; }
    TStackData& getStackData() { return data_->getStackData(); }
    TStackData const& getStackData() const { return data_->getStackData(); }
    unsigned int getIndexFromIterator() const {
      return data_->getIndexFromIterator(index_);
    }

    // friends are needed for access to protected methods
    friend class Stack<TStackData, TParticleInterface,
                       MSecondaryProducer>; // for access to getIndex for Stack
    friend class Stack<TStackData&, TParticleInterface,
                       MSecondaryProducer>;            // for access to getIndex
                                                       // SecondaryView : public Stack
    friend class ParticleBase<StackIteratorInterface>; // for access to getStackDataType

    template <typename T1,                     // best fix this to: TStackData,
              template <typename> typename M1, // best fix this to: TParticleInterface,
              template <typename T, template <typename> typename T3> typename M2>
    friend class SecondaryView; // access grant for SecondaryView

    template <typename T, template <typename> typename TParticleInterface_>
    friend class corsika::history::HistorySecondaryProducer;

    friend class ConstStackIteratorInterface<TStackData, TParticleInterface,
                                             MSecondaryProducer, stack_type>;

  protected:
    unsigned int index_ = 0;

  private:
    stack_type* data_ = 0; // info: Particles and StackIterators become invalid when
                           // parent Stack is copied or deleted!

  }; // end class StackIterator

  template <typename TStackData, template <typename> typename TParticleInterface,
            template <typename T1, template <class> class T2> class MSecondaryProducer,
            typename TStackType =
                Stack<TStackData, TParticleInterface, MSecondaryProducer>>
  class ConstStackIteratorInterface
      : public TParticleInterface<ConstStackIteratorInterface<
            TStackData, TParticleInterface, MSecondaryProducer, TStackType>> {

  public:
    typedef TParticleInterface<ConstStackIteratorInterface<
        TStackData, TParticleInterface, MSecondaryProducer, TStackType>>
        particle_interface_type;

    typedef TStackType stack_type;
    typedef TStackData stack_data_type;

    // we don't want to allow dangling iterators to exist
    ConstStackIteratorInterface() = delete; 

  public:
    ConstStackIteratorInterface(ConstStackIteratorInterface&& rhs)
        : index_(std::move(rhs.index_))
        , data_(std::move(rhs.data_)) {}

    ConstStackIteratorInterface(stack_type const& data, unsigned int const index)
        : index_(index)
        , data_(&data) {}

    bool isErased() const { return getStack().isErased(*this); }

    ConstStackIteratorInterface& operator++() {
      do {
        ++index_;
      } while (
          getStack().isErased(*this)); // this also check the allowed bounds of index_
      return *this;
    }
    ConstStackIteratorInterface operator++(int) {
      ConstStackIteratorInterface tmp(*this);
      do {
        ++index_;
      } while (
          getStack().isErased(*this)); // this also check the allowed bounds of index_
      return tmp;
    }
    ConstStackIteratorInterface operator+(int const delta) const {
      return ConstStackIteratorInterface(*data_, index_ + delta);
    }
    bool operator==(ConstStackIteratorInterface const& rhs) const {
      return index_ == rhs.index_;
    }
    bool operator!=(ConstStackIteratorInterface const& rhs) const {
      return index_ != rhs.index_;
    }
    bool operator==(
        StackIteratorInterface<stack_data_type, TParticleInterface, MSecondaryProducer,
                               stack_type> const& rhs) const {
      return index_ == rhs.index_;
    }
    bool operator!=(
        StackIteratorInterface<stack_data_type, TParticleInterface, MSecondaryProducer,
                               stack_type> const& rhs) const {
      return index_ != rhs.index_;
    }

    particle_interface_type const& operator*() const {
      return static_cast<particle_interface_type const&>(*this);
    }

  protected:
    unsigned int getIndex() const { return index_; }
    stack_type const& getStack() const { return *data_; }
    stack_data_type const& getStackData() const { return data_->getStackData(); }
    unsigned int getIndexFromIterator() const {
      return data_->getIndexFromIterator(index_);
    }

    // friends are needed for access to protected methods
    friend class Stack<stack_data_type, TParticleInterface,
                       MSecondaryProducer>; // for access to GetIndex for Stack
    friend class Stack<stack_data_type&, TParticleInterface,
                       MSecondaryProducer>; // for access to GetIndex

    friend class ParticleBase<ConstStackIteratorInterface>; // for access to GetStackData

    template <typename T1,                     // best fix to: stack_data_type,
              template <typename> typename M1, // best fix to: TParticleInterface,
              template <class T2, template <class> class T3> class M2>
    friend class SecondaryView; // access for SecondaryView

    friend class StackIteratorInterface<stack_data_type, TParticleInterface,
                                        MSecondaryProducer, stack_type>;

    template <typename T, template <typename> typename TParticleInterface_>
    friend class corsika::history::HistorySecondaryProducer;

  protected:
    unsigned int index_ = 0;

  private:
    stack_type const* data_ = 0; // info: Particles and StackIterators become invalid when
                                 // parent Stack is copied or deleted!

  }; // end class ConstStackIterator

} // namespace corsika