SecondaryView.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/Stack.hpp>
#include <corsika/framework/core/Logging.hpp>

#include <stdexcept>
#include <vector>

namespace corsika {

  // forward-decl:
  template <class T1, template <class> class T2>
  class DefaultSecondaryProducer;

  template <typename TStackDataType, template <typename> typename TParticleInterface,
            template <typename T1, template <class> class T2> class MSecondaryProducer =
                DefaultSecondaryProducer>
  class SecondaryView
      : public Stack<TStackDataType&, TParticleInterface, MSecondaryProducer>,
        public MSecondaryProducer<TStackDataType, TParticleInterface> {

  public:
    typedef SecondaryView<TStackDataType, TParticleInterface, MSecondaryProducer>
        view_type;
    typedef Stack<TStackDataType&, TParticleInterface, MSecondaryProducer>
        inner_stack_reference_type;

    typedef Stack<TStackDataType, TParticleInterface, MSecondaryProducer>
        inner_stack_value_type;

  public:
    typedef StackIteratorInterface<typename std::remove_reference<TStackDataType>::type,
                                   TParticleInterface, MSecondaryProducer,
                                   inner_stack_value_type>
        stack_value_iterator;

    typedef ConstStackIteratorInterface<
        typename std::remove_reference<TStackDataType>::type, TParticleInterface,
        MSecondaryProducer, inner_stack_value_type>
        const_stack_value_iterator;

    typedef StackIteratorInterface<typename std::remove_reference<TStackDataType>::type,
                                   TParticleInterface, MSecondaryProducer, view_type>
        stack_view_iterator;

    typedef ConstStackIteratorInterface<
        typename std::remove_reference<TStackDataType>::type, TParticleInterface,
        MSecondaryProducer, view_type>
        const_stack_view_iterator;

    using ParticleType = stack_view_iterator;
    using ParticleInterfaceType = typename stack_view_iterator::particle_interface_type;

    template <typename... TArgs>
    SecondaryView(TArgs... args) = delete;
    SecondaryView() = delete;

    SecondaryView(stack_value_iterator& particle)
        : Stack<TStackDataType&, TParticleInterface, MSecondaryProducer>(
              particle.getStackData())
        , MSecondaryProducer<TStackDataType, TParticleInterface>{particle}
        , inner_stack_(particle.getStack())
        , projectile_index_(particle.getIndex()) {
      CORSIKA_LOG_TRACE("SecondaryView::SecondaryView(particle&)");
    }
    SecondaryView(stack_value_iterator&& particle)
        : Stack<TStackDataType&, TParticleInterface, MSecondaryProducer>(
              particle.getStackData())
        , MSecondaryProducer<TStackDataType, TParticleInterface>{particle}
        , inner_stack_(particle.getStack())
        , projectile_index_(particle.getIndex()) {
      CORSIKA_LOG_TRACE("SecondaryView::SecondaryView(particle&&)");
    }
    SecondaryView(view_type& view, stack_view_iterator& projectile)
        : Stack<TStackDataType&, TParticleInterface,
                MSecondaryProducer>{view.getStackData()}
        , MSecondaryProducer<TStackDataType, TParticleInterface>{stack_value_iterator{
              view.inner_stack_, view.getIndexFromIterator(projectile.getIndex())}}
        , inner_stack_{view.inner_stack_}
        , projectile_index_{view.getIndexFromIterator(projectile.getIndex())} {
      CORSIKA_LOG_TRACE("SecondaryView::SecondaryView(view, projectile)");
    }

    stack_value_iterator parent()
        const { // todo: check if this can't be Conststack_value_iterator
      return stack_value_iterator(inner_stack_, projectile_index_);
    }

    stack_value_iterator asNewParent() const {
      return stack_value_iterator(inner_stack_, projectile_index_);
    }

    stack_view_iterator getProjectile() {
      // NOTE: 0 is special marker here for PROJECTILE, see getIndexFromIterator
      return stack_view_iterator(*this, 0);
    }

    const_stack_view_iterator getProjectile() const {
      // NOTE: 0 is special marker here for PROJECTILE, see getIndexFromIterator
      return const_stack_view_iterator(*this, 0);
    }

    template <typename... Args>
    stack_view_iterator addSecondary(const Args... v);

    unsigned int getSize() const { return indices_.size(); }

    unsigned int getEntries() const {
      return getSize() - inner_stack_reference_type::getErased();
    }

    bool isEmpty() const { return getEntries() == 0; }

    // NOTE: the "+1" is since "0" is special marker here for PROJECTILE, see
    // getIndexFromIterator
    stack_view_iterator begin();

    stack_view_iterator end() { return stack_view_iterator(*this, getSize() + 1); }

    stack_view_iterator last();

    const_stack_view_iterator begin() const;

    const_stack_view_iterator end() const {
      return const_stack_view_iterator(*this, getSize() + 1);
    }

    const_stack_view_iterator last() const;

    const_stack_view_iterator cbegin() const;

    const_stack_view_iterator cend() const {
      return const_stack_view_iterator(*this, getSize());
    }

    const_stack_view_iterator clast() const;

    stack_view_iterator at(unsigned int i) { return stack_view_iterator(*this, i); }

    const_stack_view_iterator at(unsigned int i) const {
      return const_stack_view_iterator(*this, i);
    }

    stack_view_iterator first() { return stack_view_iterator{*this, 0}; }

    const_stack_view_iterator cfirst() const {
      return const_stack_view_iterator{*this, 0};
    }

    void swap(stack_view_iterator a, stack_view_iterator b);

    void copy(stack_view_iterator a, stack_view_iterator b);

    void copy(const_stack_view_iterator a, stack_view_iterator b);

    void erase(stack_view_iterator p);

    stack_view_iterator getNextParticle() {
      while (purgeLastIfDeleted()) {}
      return last();
    }

    bool isErased(const stack_view_iterator& p) const {
      return isErased(p.getIndex() - 1);
    }

    bool isErased(const const_stack_view_iterator& p) const {
      return isErased(p.getIndex() - 1);
    }
    bool isErased(const ParticleInterfaceType& p) const {
      return isErased(p.getIterator());
    }

    bool isDeleted(const const_stack_view_iterator& p) const {
      return isDeleted(p.getIndex() - 1);
    }
    bool purgeLastIfDeleted();

    void purge();

    std::string asString() const;

  protected:
    friend class StackIteratorInterface<
        typename std::remove_reference<TStackDataType>::type, TParticleInterface,
        MSecondaryProducer, view_type>;

    friend class ConstStackIteratorInterface<
        typename std::remove_reference<TStackDataType>::type, TParticleInterface,
        MSecondaryProducer, view_type>;

    friend class ParticleBase<stack_view_iterator>;

    template <typename... Args>
    stack_view_iterator addSecondary(stack_view_iterator& proj, const Args... v);

    // forward to inner stack
    // this also checks the allowed bounds of 'i'
    bool isErased(unsigned int i) const {
      if (i >= indices_.size()) return false;
      return inner_stack_.isErased(getIndexFromIterator(i + 1));
    }

    unsigned int getIndexFromIterator(const unsigned int vI) const {
      // this is too much: CORSIKA_LOG_TRACE("SecondaryView::getIndexFromIterator({})={}",
      // vI, (vI?indices_[vI-1]:projectile_index_));
      if (vI == 0) return projectile_index_;
      return indices_[vI - 1];
    }

  private:
    inner_stack_value_type& inner_stack_;
    unsigned int projectile_index_;
    std::vector<unsigned int> indices_;
  };

  /*
    See Issue 161

    unfortunately clang does not support this in the same way (yet) as
    gcc, so we have to distinguish here. If clang cataches up, we
    could remove the #if here and elsewhere. The gcc code is much more
    generic and universal.
  */
#if not defined(__clang__) && defined(__GNUC__) || defined(__GNUG__)
  template <typename TStack,
            template <class TStack_, template <class> class pi_type_>
            class MSecondaryProducer = corsika::DefaultSecondaryProducer,
            template <typename> typename pi_type_ = TStack::template pi_type>
  struct MakeView {
    using type = corsika::SecondaryView<typename TStack::stack_data_type, pi_type_,
                                        MSecondaryProducer>;
  };
#endif

} // namespace corsika

#include <corsika/detail/framework/stack/SecondaryView.inl>