push_and_pop_dynamic.hpp

Go to the documentation of this file.

 
/*****************************************************************************
 ** Ifdefs
 *****************************************************************************/
 
#ifndef ECL_CONTAINERS_PUSH_AND_POP_DYNAMIC_HPP_
#define ECL_CONTAINERS_PUSH_AND_POP_DYNAMIC_HPP_
 
/*****************************************************************************
 ** Includes
 *****************************************************************************/
 
#include <ecl/config/macros.hpp>
#include "push_and_pop_fixed.hpp"
 
/*****************************************************************************
 ** Namespaces
 *****************************************************************************/
 
namespace ecl
{
 
/*****************************************************************************
** Forward Declarations
*****************************************************************************/
 
namespace formatters {
 
template <typename Type, size_t N> class PushAndPopFormatter;
 
} // namespace formatters
 
/*****************************************************************************
 ** Interface
 *****************************************************************************/
template<typename Type>
class ECL_PUBLIC PushAndPop<Type,DynamicStorage>
{
public:
  typedef Type           value_type; 
  typedef Type*          iterator;   
  typedef const Type*    const_iterator;  
  typedef Type&          reference;  
  typedef const Type&    const_reference; 
  typedef std::size_t    size_type;  
  typedef std::ptrdiff_t difference_type;
  typedef std::reverse_iterator<iterator> reverse_iterator; 
  typedef std::reverse_iterator<const_iterator> const_reverse_iterator;  
  typedef formatters::PushAndPopFormatter<Type,DynamicStorage> Formatter; 
  PushAndPop() : size_fifo(0), leader(0), follower(0) {}
 
  PushAndPop( const unsigned int length )
  : size_fifo(length+1), leader(0), follower(0)
  {
    ecl_assert_throw( (size_fifo>0), StandardException(LOC, OutOfRangeError, "SimpleFIFO start with zero size buffer"));
    data.resize( size_fifo );
  }
 
  PushAndPop( const unsigned int length, const Type & d ) :
  size_fifo(length+1),
  leader(0),
  follower(0)
  {
    ecl_assert_throw( (size_fifo>0), StandardException(LOC, OutOfRangeError, "SimpleFIFO start with zero size buffer"));
    data.resize( size_fifo );
    fill( d );
  }
  virtual ~PushAndPop()
  {}
 
  /*********************
  ** Iterators
  **********************/
  /* ACHTUNG! ACHTUNG! ACHTUNG! ACHTUNG! ACHTUNG! ACHTUNG! ACHTUNG! ACHTUNG! ACHTUNG! ACHTUNG! */
  /*
   * These have not been updated to take care with the push/pop, they just point to the
   * start and end of the underlying array!
   */
  iterator begin() {
    return data.begin(); // underlying array will throw if no storage has been allocated
  }
  const_iterator begin() const {
    return data.begin(); // underlying array will throw if no storage has been allocated
  }
  iterator end() {
    return data.end(); // underlying array will throw if no storage has been allocated
  }
  const_iterator end() const {
    return data.end(); // underlying array will throw if no storage has been allocated
  }
  reverse_iterator rbegin() {
    return reverse_iterator(end());
  }
  const_reverse_iterator rbegin() const {
    return const_reverse_iterator(end());
  }
  reverse_iterator rend() {
    return reverse_iterator(begin());
  }
  const_reverse_iterator rend() const {
    return const_reverse_iterator(begin());
  }
 
 
  /*********************
  ** Accessors
  **********************/
  // Cannot do stencils easily as push and pop roll over - not guaranteed of being contiguous
 
  Type & operator[] (int idx)
  {
    return data[ ((follower+idx)%size_fifo) ];
  }
 
  const Type & operator[] (int idx) const
  {
    return data[ ((follower+idx)%size_fifo) ];
  }
 
  void operator() (const PushAndPop<Type,0> & otherOne )
  {
    leader = otherOne.leader;
    follower = otherOne.follower;
    for( int i=0; i<size_fifo; i++ )
    {
      data[i] = otherOne.data[i];
    }
  }
 
  void push_back( const Type & datum )
  {
    data[ leader++ ] = datum;
    leader %= size_fifo;
    if( leader == follower )
    {
      follower++;
      follower %= size_fifo;
      // it just rolls over
    }
  }
 
  Type pop_front()
  {
    ecl_assert_throw( (follower != leader), StandardException(LOC, OutOfRangeError, "PushAndPop follower==leader"));
    Type value = data[follower++];
    follower %= size_fifo;
    return value;
  }
 
  void fill( const Type & d )
  {
    for( unsigned int i=0; i<size_fifo; i++ ) data[i] = d;
  }
 
  void resize( unsigned int length )
  {
    size_fifo = length+1;
    ecl_assert_throw( (size_fifo>0), StandardException(LOC, OutOfRangeError, "SimpleFIFO start with zero size buffer"));
    data.resize( size_fifo );
  }
 
  unsigned int asize()
  {
    return size_fifo;
  }
 
  unsigned int size() const
  {
    if( leader > follower ) return leader - follower;
    else if( leader < follower ) return size_fifo-follower+leader;
    return 0;
  }
 
  void clear()
  {
    follower = 0;
    leader = 0;
  }
 
//protected:
  ecl::Array <Type>data;
  unsigned int size_fifo;
  int leader;
  int follower;
};
 
} // namespace ecl
 
#endif /* ECL_CONTAINERS_PUSH_AND_POP_DYNAMIC_HPP_ */