Stack -> StackInterface

CMakeLists.txt

 cmake_minimum_required (VERSION 3.4.3)
 
+set (CMAKE_INSTALL_MESSAGE LAZY)
+
 set (CMAKE_CXX_STANDARD 14)
 
 project (corsika VERSION 8.0.0 DESCRIPTION "CORSIKA C++ project")

Framework/CMakeLists.txt

@@ -2,3 +2,4 @@
 add_subdirectory (Units)
 add_subdirectory (Geometry)
 add_subdirectory (Logging)
+add_subdirectory (StackInterface)

Framework/StackInterface/CMakeList.txt

+
+add_library (CORSIKAstack INTERFACE)
+
+target_include_directories (CORSIKAstack INTERFACE $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/Framework>
+                                                   $<INSTALL_INTERFACE:include/Framework>
+                                                   )
+
+install (FILES Stack.h StackIterator.h
+         DESTINATION include/Stack)
+

Framework/StackInterface/CMakeLists.txt

+
+add_library (CORSIKAstackinterface INTERFACE)
+
+target_include_directories (CORSIKAstackinterface INTERFACE $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/Framework>
+                                                            $<INSTALL_INTERFACE:include/Framework>
+                                                            )
+
+install (FILES Stack.h StackIterator.h
+         DESTINATION include/StackInterface)
+

Framework/StackInterface/Stack.h

+#ifndef _include_Stack_h__
+#define _include_Stack_h__
+
+#include <StackIterator.h> // to help application programmres
+
+namespace stack {
+
+  /**
+     Interface definition of a Stack object.
+   */
+  
+  template<typename DataImpl, typename Particle> 
+  class Stack : public DataImpl {
+
+  public:
+    using DataImpl::Capacity;
+    using DataImpl::Size;
+    
+    using DataImpl::Clear;
+    using DataImpl::Copy;
+    
+    using DataImpl::IncrementSize;
+    using DataImpl::DecrementSize;
+    
+  public:  
+    typedef Particle iterator;
+    typedef const Particle const_iterator;
+    
+    iterator Begin() { return iterator(*this, 0); } 
+    iterator End() { return iterator(*this, Size()); } 
+    iterator Last() { return iterator(*this, Size()-1); } 
+    
+    const_iterator CBegin() const { return const_iterator(*this, 0); } 
+    const_iterator CEnd() const { return const_iterator(*this, Size()); } 
+    const_iterator CLast() const { return const_iterator(*this, Size()-1); } 
+    
+    iterator NewParticle() { IncrementSize(); return iterator(*this, Size()-1); }
+    void DeleteLast() { DecrementSize(); }
+  };
+
+} // end namespace
+  
+#endif
+  

Framework/StackInterface/StackIterator.h

+#ifndef _include_StackIterator_h__
+#define _include_StackIterator_h__
+
+#include <iostream>
+#include <iomanip>
+
+namespace stack {
+
+  template<class Stack, class Particle> class StackIteratorInfo;
+
+  /**
+     The main interface to iterator over objects on a stack. 
+   */
+  
+  template<typename Stack, typename Particle>
+  class StackIterator : public Particle
+  {
+    friend Stack;
+    friend Particle;
+    friend StackIteratorInfo<Stack,Particle>;
+    
+  private:
+    int fIndex;
+    
+    //#warning stacks should not be copied because of this:
+    Stack* fData;
+    
+  public:
+    StackIterator() : fData(0), fIndex(0) { }
+    StackIterator(Stack& data, const int index) : fData(&data), fIndex(index) { }
+    StackIterator(const StackIterator& mit) : fData(mit.fData), fIndex(mit.fIndex) { }
+    
+    StackIterator& operator++() { ++fIndex; return *this; }
+    StackIterator operator++(int) { StackIterator tmp(*this); ++fIndex; return tmp; }
+    bool operator==(const StackIterator& rhs) { return fIndex == rhs.fIndex; }
+    bool operator!=(const StackIterator& rhs) { return fIndex != rhs.fIndex; }
+    
+    StackIterator& operator*() { return *this; }
+    const StackIterator& operator*() const { return *this; }
+    
+  protected:
+    int GetIndex() const { return fIndex; }
+    Stack& GetStack() { return *fData; }
+    const Stack& GetStack() const { return *fData; }
+    
+    inline StackIterator<Stack,Particle>& base_ref() { return static_cast<StackIterator<Stack, Particle>&>(*this); }
+    inline const StackIterator<Stack,Particle>& base_ref() const { return static_cast<const StackIterator<Stack, Particle>&>(*this); }
+  };
+
+  
+  /**
+     Internal helper class for StackIterator     
+   */
+  
+  template<class _Stack, class Particle>
+  class StackIteratorInfo {
+    
+    friend Particle;  
+  private:
+    StackIteratorInfo() {}
+    
+  protected:
+    inline _Stack& Stack() { return static_cast<StackIterator<_Stack, Particle>*>(this)->GetStack(); }
+    inline int Index() const { return static_cast<const StackIterator<_Stack, Particle>*>(this)->GetIndex(); }
+    inline const _Stack& Stack() const { return static_cast<const StackIterator<_Stack, Particle>*>(this)->GetStack(); }
+  };
+
+} // end namespace stack
+  
+#endif