CombinedStack.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/core/Logging.hpp>
#include <corsika/framework/core/ParticleProperties.hpp>
#include <corsika/framework/stack/Stack.hpp>
#include <corsika/framework/core/PhysicalUnits.hpp>

namespace corsika {

  template <template <typename> typename TParticleInterfaceA,
            template <typename> class TParticleInterfaceB, typename TStackIterator>
  struct CombinedParticleInterface
      : public TParticleInterfaceB<TParticleInterfaceA<TStackIterator>> {

    typedef CombinedParticleInterface<TParticleInterfaceA, TParticleInterfaceB,
                                      TStackIterator>
        pi_c_type;
    typedef TParticleInterfaceA<TStackIterator> pi_a_type;
    typedef TParticleInterfaceB<TParticleInterfaceA<TStackIterator>> pi_b_type;

  protected:
    using pi_b_type::getIndex;     // choose B, A would also work
    using pi_b_type::getStackData; // choose B, A would also work

  public:
    template <typename... TArgs1>
    void setParticleData(std::tuple<TArgs1...> const vA);

    template <typename... TArgs1, typename... TArgs2>
    void setParticleData(std::tuple<TArgs1...> const vA, std::tuple<TArgs2...> const vB);

    template <typename... TArgs1>
    void setParticleData(pi_a_type& p, std::tuple<TArgs1...> const vA);

    template <typename... TArgs1, typename... TArgs2>
    void setParticleData(pi_c_type& p, std::tuple<TArgs1...> const vA,
                         std::tuple<TArgs2...> const vB);

    std::string asString() const;

  protected:
  };

  template <typename Stack1Impl, typename Stack2Impl>
  struct CombinedStackImpl : public Stack1Impl, public Stack2Impl {

  public:
    void clear();

    unsigned int getSize() const { return Stack1Impl::getSize(); }
    unsigned int getCapacity() const { return Stack1Impl::getCapacity(); }

    void copy(const unsigned int i1, const unsigned int i2);

    void swap(const unsigned int i1, const unsigned int i2);

    void incrementSize();

    void decrementSize();

  }; // end class CombinedStackImpl

  template <typename Stack1Impl, typename Stack2Impl, template <typename> typename _PI,
            template <typename T1, template <class> class T2> class _MSecondaryProducer =
                DefaultSecondaryProducer>
  using CombinedStack =
      Stack<CombinedStackImpl<Stack1Impl, Stack2Impl>, _PI, _MSecondaryProducer>;

} // namespace corsika

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