Stack.hpp

Go to the documentation of this file.

/*
 * (c) Copyright 2018 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/stack/StackIteratorInterface.hpp>
#include <corsika/framework/stack/DefaultSecondaryProducer.hpp>
#include <corsika/framework/stack/SecondaryView.hpp>

#include <stdexcept>
#include <string>
#include <vector>
#include <utility>
#include <type_traits>

namespace corsika {

  template <typename TStackData, template <typename> typename MParticleInterface,
            template <typename T1, template <class> class T2> class MSecondaryProducer =
                DefaultSecondaryProducer>
  class Stack {

    typedef typename std::remove_reference<TStackData>::type value_type;

  public:
    typedef TStackData stack_data_type; 

    typedef SecondaryView<TStackData, MParticleInterface, MSecondaryProducer>
        stack_view_type;

    template <typename TStackIterator>
    using pi_type = MParticleInterface<TStackIterator>;

    typedef StackIteratorInterface<value_type, MParticleInterface, MSecondaryProducer,
                                   Stack>
        stack_iterator_type;

    typedef ConstStackIteratorInterface<value_type, MParticleInterface,
                                        MSecondaryProducer, Stack>
        const_stack_iterator_type;

    typedef typename stack_iterator_type::particle_interface_type particle_interface_type;
    typedef stack_iterator_type particle_type;

    Stack()
        : nDeleted_(0)
        , data_()
        , deleted_(std::vector<bool>(data_.getSize(), false)) {}

    Stack(Stack&) = delete; 

    Stack& operator=(Stack&) =
        delete; 

    template <typename UType = TStackData,
              typename = typename std::enable_if<std::is_reference<UType>::value>::type>
    Stack(TStackData vD)
        : nDeleted_(0)
        , data_(vD)
        , deleted_(std::vector<bool>(data_.getSize(), false)) {}

    template <typename... TArgs, typename UType = TStackData,
              typename = typename std::enable_if<std::is_reference<UType>::value>::type>
    Stack(TArgs... args)
        : nDeleted_(0)
        , data_(args...)
        , deleted_(std::vector<bool>(data_.getSize(), false)) {}

    unsigned int getCapacity() const { return data_.getCapacity(); }

    unsigned int getErased() const { return nDeleted_; }

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

    template <typename... TArgs>
    void clear(TArgs... args);

    stack_iterator_type begin();

    stack_iterator_type end();

    stack_iterator_type last();

    const_stack_iterator_type begin() const;

    const_stack_iterator_type end() const;

    const_stack_iterator_type last() const;

    const_stack_iterator_type cbegin() const;

    const_stack_iterator_type cend() const;

    const_stack_iterator_type clast() const;

    stack_iterator_type at(unsigned int i);

    const_stack_iterator_type at(unsigned int i) const;

    stack_iterator_type first();

    const_stack_iterator_type cfirst() const;

    stack_iterator_type getNextParticle();

    template <typename... TArgs>
    stack_iterator_type addParticle(const TArgs... v);

    void swap(stack_iterator_type a, stack_iterator_type b);

    void copy(stack_iterator_type a, stack_iterator_type b);

    void copy(const_stack_iterator_type a, stack_iterator_type b);

    void erase(stack_iterator_type p);
    void erase(particle_interface_type p);

    bool isEmpty();

    bool isErased(const stack_iterator_type& p) const;

    bool isErased(const const_stack_iterator_type& p) const;

    bool isErased(const particle_interface_type& p) const;

    bool purgeLastIfDeleted();

    void purge();

    unsigned int getSize() const;

    std::string asString() const;

  protected:
    template <typename... TArgs>
    stack_iterator_type addSecondary(stack_iterator_type& parent, const TArgs... v);

    void swap(unsigned int const a, unsigned int const b);

    void copy(unsigned int const a, unsigned int const b);

    bool isErased(unsigned int const i) const;

    void erase(unsigned int const i);

    void purge(unsigned int i);

    unsigned int getIndexFromIterator(const unsigned int vI) const;
    value_type& getStackData();

    const value_type& getStackData() const;

    friend class StackIteratorInterface<value_type, MParticleInterface,
                                        MSecondaryProducer, Stack>;
    friend class ConstStackIteratorInterface<value_type, MParticleInterface,
                                             MSecondaryProducer, Stack>;
    template <typename T1,                     //=TStackData,
              template <typename> typename M1, //=MParticleInterface,
              template <class T2, template <class> class T3> class M2>
    friend class SecondaryView;

    friend class ParticleBase<stack_iterator_type>;

  protected:
    unsigned int nDeleted_ = 0;

  private:
    TStackData data_; 
    std::vector<bool> deleted_; 
  };                            // namespace corsika

} // namespace corsika

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