iter-stack.hpp

Go to the documentation of this file.

/*
  ITER-STACK.hpp  -  a stack which can be popped by iterating 

   Copyright (C)
     2012,            Hermann Vosseler <Ichthyostega@web.de>

  **Lumiera** is free software; you can redistribute it and/or modify it
  under the terms of the GNU General Public License as published by the
  Free Software Foundation; either version 2 of the License, or (at your
  option) any later version. See the file COPYING for further details.

*/

#ifndef LIB_ITER_STACK_H
#define LIB_ITER_STACK_H


#include "lib/error.hpp"
#include "lib/iter-adapter.hpp"
#include "lib/nocopy.hpp"
#include "lib/util.hpp"

#include <deque>
#include <utility>


namespace lib {
  
  using util::unConst;
  
  namespace iter {
    
    template<class TY>
    struct IterDequeStorage
      : std::deque<TY>
      {
        /* === Iteration control API for IterStateWrapper == */
        
        bool
        checkPoint()  const
          {
            return not this->empty();
          }
        
        TY &
        yield()  const
          {
            REQUIRE (not this->empty());
            return unConst(this)->back();
          }
        
        void
        iterNext()
          {
            REQUIRE (not this->empty());
            this->pop_back();
          }
      };
  } // namespace lib::iter
  
  
  
  template<class TY>
  struct IterStack
    : IterStateWrapper<iter::IterDequeStorage<TY>>
    {
      
      // using default create and copy operations
      
      IterStack&
      push (TY const& elm)
        {
          this->stateCore().push_back (elm);
          return *this;
        }
      
      IterStack&
      push (TY&& elm)
        {
          this->stateCore().emplace_back (std::move (elm));
          return *this;
        }
      
      IterStack&
      insert (TY const& elm)
        {
          return push(elm);
        }
      
      
      TY
      pop()
        {
          this->__throw_if_empty();
          TY topElement (std::move (this->stateCore().back()));
          this->stateCore().pop_back();
          return topElement;
        }
      
      void
      clear()
        {
          this->stateCore().clear();
        }
      
      
      /* == diagnostics == */
      
      size_t
      size()  const
        {
          return unConst(this)->stateCore().size();
        }
      
      bool
      empty() const
        {
          return 0 == size();
        }
    };
  
  
  
  
  template<class TY>
  struct IterQueue
    : IterStateWrapper<iter::IterDequeStorage<TY>>
    {
      
      // using default create and copy operations
      
      IterQueue&
      feed (TY const& elm)
        {
          this->stateCore().push_front (elm);
          return *this;
        }
      
      IterQueue&
      feed (TY&& elm)
        {
          this->stateCore().emplace_front (std::move (elm));
          return *this;
        }
      
      IterQueue&
      insert (TY const& elm)
        {
          return feed(elm);
        }
      
      TY
      pop()
        {
          this->__throw_if_empty();
          TY firstElement (std::move (this->stateCore().back()));
          this->stateCore().pop_back();
          return firstElement;
        }
      
      
      /* == diagnostics == */
      
      size_t
      size()  const
        {
          return unConst(this)->stateCore().size();
        }
      
      bool
      empty() const
        {
          return 0 == size();
        }
      
      
      struct Builder
        : util::NonCopyable
        {
          Builder(IterQueue& initialElements)
            : queue_(initialElements)
            { }
           // standard copy operations allowed
          
          template<typename IT>
          IterQueue &
          usingSequence (IT src)
            {
              for ( ; src; ++src )
                queue_.feed (*src);
              return queue_;
            }
          
          IterQueue &
          wrapping (TY const& elm)
            {
              queue_.feed (elm);
              return queue_;
            }
          
        private:
          IterQueue& queue_;
        };
      
      friend IterQueue::Builder
      build (IterQueue& initial)
      {
        return Builder(initial);
      }
    };
  
  
  template<typename T>
  inline IterQueue<T>
  elements (T const& elm)
  {
    return IterQueue<T>().feed(elm);
  }
  
  template<typename T>
  inline IterQueue<T>
  elements (T const& e0, T const& e1)
  {
    return IterQueue<T>().feed(e0).feed(e1);
  }
  
  template<typename T>
  inline IterQueue<T>
  elements (T const& e0, T const& e1, T const& e2)
  {
    return IterQueue<T>().feed(e0).feed(e1).feed(e2);
  }
  
  template<typename T>
  inline IterQueue<T>
  elements (T const& e0, T const& e1, T const& e2, T const& e3)
  {
    return IterQueue<T>().feed(e0).feed(e1).feed(e2).feed(e3);
  }
  
  template<typename T>
  inline IterQueue<T>
  elements (T const& e0, T const& e1, T const& e2, T const& e3, T const& e4)
  {
    return IterQueue<T>().feed(e0).feed(e1).feed(e2).feed(e3).feed(e4);
  }
  
  
  
} // namespace lib
#endif