Revised on 4 Mar 2004

BoundedQueue.hpp

/*
 * Copyright (C) 2003-2004
 * Slawomir Lisznianski <slisznianski@asyncnet.com>
 *
 * Permission to use, copy, modify, distribute and sell this software
 * and its documentation for any purpose is hereby granted without fee,
 * provided that the above copyright notice appear in all copies and
 * that both that copyright notice and this permission notice appear
 * in supporting documentation. Slawomir Lisznianski makes no
 * representations about the suitability of this software for any
 * purpose. It is provided "as is" without express or implied warranty.
 *
 */

#ifndef RHA_BOUNDEDQUEUE_HPP
#define RHA_BOUNDEDQUEUE_HPP

#include <stdexcept>
#include <deque>

namespace Rha
{
    struct QueueOverflowError :
      public std::runtime_error
    {
      QueueOverflowError() :
        std::runtime_error("queue overflow error")
      {}
    };

    template<class T,
             class C = std::deque<T> >
    class BoundedQueue
    {
    public:
      typedef BoundedQueue<T, C> OfType;
      typedef T                  Task;
      typedef C                  Container;

      class Configurator
      {
      public:
        // Default values.
        // VC++ 6 doesn't support in-place initialization of static const
        // per C2258 and C225.
        //
        enum Defaults {defaultUpperBound = 1000} ;

        Configurator()
        {
          init__();
        }

        unsigned int upperBound() const
        {
          return M_upperBound;
        }

        Configurator& upperBound(unsigned int limit)
        {
          M_upperBound = limit;
          return (*this);
        }

      private:
        void init__()
        {
          // Defaults.
          //
          M_upperBound = defaultUpperBound;
        }

        unsigned int M_upperBound;
      };

      BoundedQueue();

      BoundedQueue(const OfType& queue);

      BoundedQueue(const Configurator& config);

      ~BoundedQueue();

      inline void setUp();

      inline bool empty() const;

      inline bool full() const;

      inline void flush();

      inline Task& front();
      inline const Task& front() const;

      inline void push(const Task& val);

      inline void pop();
    private:
      Configurator  M_configurator;
      Container M_container;
    };
}

template<class T,
         class C>
Rha::BoundedQueue<T,
                  C>::BoundedQueue()
{ }

template<class T,
         class C>
Rha::BoundedQueue<T,
                  C>::BoundedQueue(const OfType& queue) :
  M_configurator(queue.M_configurator), M_container(queue.M_container)
{ }

template<class T,
         class C>
Rha::BoundedQueue<T,
                  C>::BoundedQueue(const Configurator& configurator) :
  M_configurator(configurator)
{ }

template<class T,
         class C>
Rha::BoundedQueue<T,
                  C>::~BoundedQueue()
{ }

template<class T,
         class C>
void
Rha::BoundedQueue<T,
                  C>::setUp()
{ }

template<class T,
         class C>
bool
Rha::BoundedQueue<T,
                  C>::empty() const
{
  return (M_container.empty());
}

template<class T,
         class C>
bool
Rha::BoundedQueue<T,
                  C>::full() const
{
  return !(M_configurator.upperBound() > M_container.size());
}

template<class T,
         class C>
void
Rha::BoundedQueue<T,
                  C>::flush()
{
  M_container.clear();
}

template<class T,
         class C>
typename Rha::BoundedQueue<T,
                             C>::Task&
Rha::BoundedQueue<T,
                  C>::front()
{
  return (M_container.front());
}

template<class T,
         class C>
const typename Rha::BoundedQueue<T,
                                   C>::Task&
Rha::BoundedQueue<T,
                  C>::front() const
{
  return (M_container.front());
}

template<class T,
         class C>
void
Rha::BoundedQueue<T,
                  C>::push(const Task& val)
{
  if (!full())
    M_container.push_back(val);
  else
    throw QueueOverflowError();
}

template<class T,
         class C>
void
Rha::BoundedQueue<T,
                  C>::pop()
{
  M_container.pop_front();
}

#endif // RHA_BOUNDEDQUEUE_HPP

---

© Copyright Slawomir Lisznianski 2003-2004. All Rights Reserved.

Permission to use, copy, modify, distribute and sell this software and its documentation for any purpose is hereby granted without fee, provided that the above copyright notice appear in all copies and that both that copyright notice and this permission notice appear in supporting documentation. Slawomir Lisznianski makes no representations about the suitability of this software for any purpose. It is provided "as is" without express or implied warranty.