ZeusBase-Library: QueueCB.hpp Source File

Go to the documentation of this file.
00001 /*****************************************************************************
00002  * Copyright (C) 2011 by Benjamin Hadorn (b_hadorn@bluewin.ch)
00003  *****************************************************************************
00004  * Project    : Zeus Base Library
00005  * Module     : QueueCB
00006  * Package    : Zeus.ZeusBase.System
00007  * Author     : Benjamin Hadorn
00008  * Date       : 27.12.2011
00009  * System     : Zeus-Framework
00010  *****************************************************************************
00011  * Licence:                                                                  *
00012  *   This library is free software; you can redistribute it and/or modify    *
00013  *   it under the terms of the GNU Lesser General Public License as          *
00014  *   published by the Free Software Foundation; either version               *
00015  *   2.1 of the License, or (at your option) any later version.              *
00016  *                                                                           *
00017  *   This library is distributed in the hope that it will be useful,         *
00018  *   but WITHOUT ANY WARRANTY; without even the implied warranty of          *
00019  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the            *
00020  *   GNU Lesser General Public License for more details.                     *
00021  *                                                                           *
00022  *   You should have received a copy of the GNU Lesser General Public        *
00023  *   License along with this library; if not, write to the Free Software     *
00024  *   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110, USA    *
00025  *****************************************************************************/
00026 
00027 /*****************************************************************************
00028  * Changes:
00029  *  27.12.2011 bha: created zeus 2.0
00030  *****************************************************************************/
00031 
00032 #ifndef QueueCBHPP
00033 #define QueueCBHPP
00034 
00035 #ifdef _MSC_VER
00036   #pragma warning(push, 1)
00037 #endif
00038 
00039 #include <stddef.h>
00040 
00041 #ifdef _MSC_VER
00042   #pragma warning(pop)
00043 #endif
00044 
00045 #include <string.h>
00046 #include <zeusbase/System/ZObject.h>
00047 #include <zeusbase/System/Interfaces/IQueue.hpp>
00048 #include <zeusbase/System/Interfaces/IArray.hpp>
00049 
00050 BEGIN_NAMESPACE_Zeus
00051 
00052 /******************************************************************************/
00056 /******************************************************************************/
00057 template <class T> class TQueueCB : public IQueue<T>
00058 {
00059   public:
00060     TQueueCB(Int iSize = 20, EArrayCopyMode eCopyMode = etDeepCopy);
00061     TQueueCB(const T& rEmptyItem, Int iSize, EArrayCopyMode eCopyMode);
00062     TQueueCB(const TQueueCB<T>& rQueue);
00063     virtual ~TQueueCB();
00064 
00065     bool append(const T& tData);
00066     void assign(const TQueueCB<T>& rQueue);
00067     EArrayCopyMode getCopyMode() const;
00068     Int getReaderIndex () const;
00069     Int getWriterIndex () const;
00070     T& remove(bool* pError = NULL);
00071 
00072     //Methods of IQueue
00073     virtual void MQUALIFIER appendItem(const T& tData);
00074     virtual void MQUALIFIER copyToQueue(IQueue<T>& rQueue) const;
00075     virtual void MQUALIFIER copyToList(IList<T>& rList) const;
00076     virtual T MQUALIFIER removeItem();
00077     virtual Int MQUALIFIER getCount() const;
00078     virtual void MQUALIFIER flush();
00079     virtual bool MQUALIFIER isEmpty() const;
00080     virtual T& MQUALIFIER peekItem() ;
00081     virtual const T& MQUALIFIER peekItemConst() const;
00082 
00083     //operators
00084     TQueueCB<T>& operator=(const TQueueCB<T>& rQueue);
00085     TQueueCB<T>& operator=(const IQueue<T>& rQueue);
00086 
00087     
00088   protected:
00089     T& getItem(Int iIndex);
00090     const T& getItem(Int iIndex) const;
00091 
00092   private:
00094     T* m_pDataBuffer;
00096     Int m_iBufferSize;
00098     Int m_iReaderIndex;
00100     Int m_iWriterIndex;
00102     Int  m_iCount;
00104     T m_tEmpty;
00106     EArrayCopyMode m_eCopyMode;
00107 
00108     /*********************************************************************/
00109     /* COMPILER PROBLEM:
00110        Change this if a compiler fails with : m_tEmpty(T()) (see constructors)
00111 
00112     #ifdef A_COMPILER_TYPE
00113     static const T& getDefaultEmpty()
00114     {
00115         static const T Empty; // is initialized by compiler
00116         return Empty;
00117     }
00118     #endif
00119 
00120     */
00121 };
00122 
00123 
00124 /******************************************************************************/
00129 /******************************************************************************/
00130 template <class T> TQueueCB<T>::TQueueCB(Int iSize /*= 20*/, EArrayCopyMode eCopyMode /*= etDeepCopy*/)
00131  /* COMPILER PROBLEM*/
00132  /*#ifdef A_COMPILER_TYPE
00133     : m_EmptyObject(getDefaultEmpty())
00134    #else
00135     : m_EmptyObject(T())
00136    #endif
00137 */
00138   : m_tEmpty(T())
00139 {
00140   m_eCopyMode    = eCopyMode;
00141   m_iBufferSize  = iSize;
00142   m_iReaderIndex = 0;
00143   m_iWriterIndex = 0;
00144   m_iCount       = 0;
00145   m_pDataBuffer  = new T[m_iBufferSize];
00146 
00147   // DO NOT USE MEMSET. This causes memory leaks on complex objects
00148   //  memset(&m_tEmpty, 0, sizeof(T));
00149   assert(m_pDataBuffer != NULL);
00150 }
00151 
00152 /******************************************************************************/
00158 /******************************************************************************/
00159 template <class T> TQueueCB<T>::TQueueCB(const T& rEmptyItem, Int iSize, EArrayCopyMode eCopyMode)
00160   : m_tEmpty(rEmptyItem)
00161 {
00162   m_eCopyMode    = eCopyMode;
00163   m_iBufferSize  = iSize;
00164   m_iReaderIndex = 0;
00165   m_iWriterIndex = 0;
00166   m_iCount       = 0;
00167   m_pDataBuffer  = new T[m_iBufferSize];
00168 
00169   // DO NOT USE MEMSET. This causes memory leaks on complex objects
00170   //  memset(&m_tEmpty, 0, sizeof(T));
00171   assert(m_pDataBuffer != NULL);
00172 }
00173 
00174 /******************************************************************************/
00178 /******************************************************************************/
00179 template <class T> inline TQueueCB<T>::TQueueCB(const TQueueCB<T>& rQueue)
00180  : m_tEmpty(rQueue.m_tEmpty)
00181 {
00182   m_pDataBuffer  = NULL;
00183   assign(rQueue);
00184 }
00185 
00186 
00187 /******************************************************************************/
00190 /******************************************************************************/
00191 template <class T> inline TQueueCB<T>::~TQueueCB()
00192 {
00193   if (m_pDataBuffer != NULL)
00194   {
00195     delete [] m_pDataBuffer;
00196   }
00197 }
00198 
00199 /******************************************************************************/
00204 /******************************************************************************/
00205 template <class T> inline T& TQueueCB<T>::getItem(Int iIndex)
00206 {
00207   if (m_pDataBuffer != NULL && iIndex >= 0 && iIndex < m_iCount)
00208   {
00209     return m_pDataBuffer[iIndex];
00210   }
00211   else
00212   {
00213     return m_tEmpty;
00214   }
00215 }
00216 
00217 /******************************************************************************/
00222 /******************************************************************************/
00223 template <class T> inline const T& TQueueCB<T>::getItem(Int iIndex) const
00224 {
00225   if (m_pDataBuffer != NULL && iIndex >= 0 && iIndex < m_iCount)
00226   {
00227     return m_pDataBuffer[iIndex];
00228   }
00229   else
00230   {
00231     return m_tEmpty;
00232   }
00233 }
00234 
00235 /******************************************************************************/
00241 /******************************************************************************/
00242 template <class T> bool TQueueCB<T>::append(const T& tData)
00243 {
00244   bool bRetval = false;
00245   if (m_iBufferSize > m_iCount)
00246   {
00247     m_pDataBuffer[m_iWriterIndex] = tData;
00248     m_iWriterIndex = (m_iWriterIndex + 1) % m_iBufferSize;
00249     m_iCount++;
00250     bRetval = true;
00251   }
00252   return bRetval;
00253 }
00254 
00255 /******************************************************************************/
00258 /******************************************************************************/
00259 template <class T> void TQueueCB<T>::assign(const TQueueCB<T>& rQueue)
00260 {
00261   if (m_pDataBuffer != NULL)
00262   {
00263     delete [] m_pDataBuffer;
00264   }
00265 
00266   m_pDataBuffer  = new T[rQueue.m_iBufferSize];
00267   m_iBufferSize  = rQueue.m_iBufferSize;
00268   m_iReaderIndex = rQueue.m_iReaderIndex;
00269   m_iWriterIndex = rQueue.m_iWriterIndex;
00270   m_iCount       = rQueue.m_iCount;
00271   m_eCopyMode    = rQueue.m_eCopyMode;
00272 
00273   switch(m_eCopyMode)
00274   {
00275     case etDeepCopy:  //fall through
00276     default:
00277     {
00278       for(int i = 0; i < m_iBufferSize; i++)
00279       {
00280         m_pDataBuffer[i] = rQueue.m_pDataBuffer[i];
00281       }
00282     }
00283     break;
00284 
00285     case etShallowCopy:
00286     {
00287       ::memcpy(m_pDataBuffer, rQueue.m_pDataBuffer, sizeof(T)*m_iBufferSize);
00288     }
00289     break;
00290   }
00291 }
00292 
00293 /******************************************************************************/
00296 /******************************************************************************/
00297 template <class T> inline EArrayCopyMode TQueueCB<T>::getCopyMode() const
00298 {
00299   return m_eCopyMode;
00300 }
00301 
00302 /******************************************************************************/
00305 /******************************************************************************/
00306 template <class T> inline Int TQueueCB<T>::getReaderIndex () const
00307 {
00308   return m_iReaderIndex;
00309 }
00310 
00311 /******************************************************************************/
00314 /******************************************************************************/
00315 template <class T> inline Int TQueueCB<T>::getWriterIndex () const
00316 {
00317   return m_iWriterIndex;
00318 }
00319 
00320 /******************************************************************************/
00325 /******************************************************************************/
00326 template <class T> T& TQueueCB<T>::remove(bool* pError /*= NULL*/)
00327 {
00328   if (m_iCount > 0)
00329   {
00330     if (pError != NULL)
00331     {
00332       *pError = false;
00333     }
00334 
00335     Int iIndex = m_iReaderIndex;
00336     m_iReaderIndex = (m_iReaderIndex + 1) % m_iBufferSize;
00337     m_iCount--;
00338     return m_pDataBuffer[iIndex];
00339   }
00340   else
00341   {
00342     if (pError != NULL)
00343     {
00344       *pError = true;
00345     }
00346     return m_tEmpty;
00347   }
00348 }
00349 
00350 
00351 /******************************************************************************/
00354 /******************************************************************************/
00355 template <class T> inline void MQUALIFIER TQueueCB<T>::appendItem(const T& tData)
00356 {
00357   append(tData);
00358 }
00359 
00360 /******************************************************************************/
00363 /******************************************************************************/
00364 template <class T> inline void MQUALIFIER TQueueCB<T>::copyToQueue(IQueue<T>& rQueue) const
00365 {
00366   for(int i = 0; i < m_iCount; i++)
00367   {
00368     rQueue.appendItem(m_pDataBuffer[(m_iReaderIndex + i) % m_iBufferSize]);
00369   }
00370 }
00371 
00372 /******************************************************************************/
00375 /******************************************************************************/
00376 template <class T> inline void MQUALIFIER TQueueCB<T>::copyToList(IList<T>& rList) const
00377 {
00378   for(int i = 0; i < m_iCount; i++)
00379   {
00380     rList.add(m_pDataBuffer[(m_iReaderIndex + i) % m_iBufferSize]);
00381   }
00382 }
00383 
00384 /******************************************************************************/
00387 /******************************************************************************/
00388 template <class T> inline T MQUALIFIER TQueueCB<T>::removeItem()
00389 {
00390   return remove(NULL);
00391 }
00392 
00393 /******************************************************************************/
00396 /******************************************************************************/
00397 template <class T> inline Int MQUALIFIER TQueueCB<T>::getCount() const
00398 {
00399   return m_iCount;
00400 }
00401 
00402 /******************************************************************************/
00405 /******************************************************************************/
00406 template <class T> inline void MQUALIFIER TQueueCB<T>::flush()
00407 {
00408   m_iReaderIndex = 0;
00409   m_iWriterIndex = 0;
00410   m_iCount       = 0;
00411 }
00412 
00413 /******************************************************************************/
00416 /******************************************************************************/
00417 template <class T> inline bool MQUALIFIER TQueueCB<T>::isEmpty() const
00418 {
00419   return (m_iCount == 0);
00420 }
00421 
00422 /******************************************************************************/
00425 /******************************************************************************/
00426 template <class T> inline T& MQUALIFIER TQueueCB<T>::peekItem()
00427 {
00428   if (m_iCount > 0)
00429   {
00430     return m_pDataBuffer[m_iReaderIndex];
00431   }
00432   else
00433   {
00434     return m_tEmpty;
00435   }
00436 }
00437 
00438 /******************************************************************************/
00441 /******************************************************************************/
00442 template <class T> inline const T& MQUALIFIER TQueueCB<T>::peekItemConst() const
00443 {
00444   if (m_iCount > 0)
00445   {
00446     return m_pDataBuffer[m_iReaderIndex];
00447   }
00448   else
00449   {
00450     return m_tEmpty;
00451   }
00452 }
00453 
00454 
00455 /******************************************************************************/
00459 /******************************************************************************/
00460 template <class T> inline TQueueCB<T>& TQueueCB<T>::operator=(const TQueueCB<T>& rQueue)
00461 {
00462   flush();
00463   rQueue.copyToQueue(*this);
00464   return *this;
00465 }
00466 
00467 /******************************************************************************/
00471 /******************************************************************************/
00472 template <class T> inline TQueueCB<T>& TQueueCB<T>::operator=(const IQueue<T>& rQueue)
00473 {
00474   flush();
00475   rQueue.copyToQueue(*this);
00476   return *this;
00477 }
00478 
00479 END_NAMESPACE_Zeus
00480 
00481 
00482 #endif