/home/bes3soft/bes3soft/Boss/7.0.2/dist/7.0.2/Calibration/facilities/facilities-00-00-04/facilities/FIFO.h

Go to the documentation of this file.

//      $Id: FIFO.h,v 1.1.1.1 2005/10/17 06:11:40 maqm Exp $
#ifndef FIFO_h
#define FIFO_h 1

#ifdef _MSC_VER
# pragma warning(disable: 4786)
#endif

#include <vector>
#include <cassert>

//## Class: FIFO; Parameterized Class
//      Implements the FIFO class. This is not a readout
//      component, but a standard First-In-First-Out storage
//      class.

using std::vector;

template <class _T>
class FIFO : private vector<_T>  //## Inherits: _T
{
  public:
    FIFO (unsigned int depth = 0)   
        : vector<_T>(), m_depth(depth)    
    {
        if (depth > 0)  reserve ( depth );

        // if the depth of the fifo is fixed, then reserve enough space to contain it entirely
        // FIFO operates in two modes: one for a fixed depth,
        // and another for a non-fixed depth (unlimited)
    }

    FIFO (const FIFO& f)
        : vector<_T>(f), m_depth(f.m_depth)
    {
    }


      //        Push x into the FIFO. Returns true if x was successfully
      //        stored, false if not (FIFO was full).
      bool push (const _T& x)
      {
          if ((m_depth != 0) && (size() >= m_depth))    return false;

          push_back( x );

          return true;
      }

      //        Returns the current front of the FIFO buffer, if it
      //        exists. Caller must perform range checking to see that
      //        the FIFO is not empty prior to this call.
      _T pop ()
      {
          assert(size()>0);
          _T    value (*begin());
          erase(begin());
          
          // limited depth mode
          
          return value;
      }

      _T&   front   () { return vector<_T>::front(); }
      _T&   back    () { return vector<_T>::back(); }

      const _T&   front   () const      { return vector<_T>::front(); }
      const _T&   back    () const      { return vector<_T>::back(); }

      bool  empty   () const    { return (size() == 0); }

      //        Get the maximum size of this FIFO.
      unsigned int maxSize () const
      {
          return m_depth;
      }

      //        Return the current size of the FIFO buffer.
      unsigned int size () const
      {
          return vector<_T>::size();
      }

      void clear ()
      {
         vector<_T>::clear();
      }

      //        Writes the contents of the FIFO to the output stream.
      void printOn (std::ostream& out = cout)
      {
          short i = 1;
          for (vector<_T>::reverse_iterator it = rbegin(); it != rend(); ++it) {
              out << (*it)();
              if ((i % 8) == 0) out << "\n";
              else  out << "\t";
              i++;
          }
      }

      bool  full () const { return size() == m_depth; }

      bool  avail () const { return size() < m_depth; }

  private: 

      //        maximum depth for the fifo
      unsigned int m_depth;
};

#endif

---