SyncLIFO.h

Go to the documentation of this file.
00001 // -*- C++ -*-
00020 #ifndef SyncLIFO_h
00021 #define SyncLIFO_h
00022 
00023 #include <iostream>
00024 #include <vector>
00025 #include <algorithm>
00026 //#include <ace/Synch.h>
00027 #include <rtm/BufferBase.h>
00028 
00029 namespace RTC
00030 {
00031   template <class DataType>
00032   class SyncLIFO
00033     : public BufferBase<DataType>
00034   {
00035   public:
00036     SyncLIFO(int size = 3)
00037       : m_buffer(NULL), m_size(size),
00038         m_buffer_org(NULL), m_size_org(0),
00039         m_wpos(0), m_wnext(1),
00040         m_rpos(0), m_rnext(1),
00041         m_wbegin(m_wnext), m_wend(m_rpos),
00042         m_rbegin(m_rnext), m_rend(m_wpos)
00043     {
00044       if (m_buffer == NULL)
00045         {
00046           m_buffer = new DataType[m_size];
00047         }
00048     }
00049     
00050     virtual ~SyncLIFO()
00051     {
00052       if (m_buffer_org == NULL)
00053         {
00054           delete [] m_buffer;
00055         }
00056       else
00057         {
00058           delete [] m_buffer_org;
00059         }
00060     };
00061     
00062     virtual void init(const DataType& data)
00063     {
00064       if (m_buffer)
00065         {
00066           for (int i(0); i < m_size; ++i)
00067             {
00068               write(data);
00069             }
00070         }
00071     }
00072     
00073     
00074     virtual void clear()
00075     {
00076       m_wpos  = 0;
00077       m_wnext = 1;
00078       m_rpos  = 0;
00079       m_rnext = 1;
00080     }
00081     
00082     virtual bool setBuffer(DataType* buffer, int size)
00083     {
00084       if (!buffer) return false;
00085       if (size < 0) return false;
00086       
00087       m_size_org   = m_size;
00088       m_buffer_org = m_buffer;
00089       m_size       = size;
00090       m_buffer     = buffer;
00091       clear();
00092       return true;
00093     }
00094     
00095     virtual DataType* unsetBuffer()
00096     {
00097       DataType* tmp(m_buffer);
00098       m_size = m_size_org;
00099       m_buffer = m_buffer_org;
00100       return tmp;
00101     }
00102     
00103     virtual DataType* getBuffer() const
00104     {
00105       return m_buffer;
00106     }
00107     
00108     virtual long int length() const
00109     {
00110       return m_size;
00111     }
00112     
00113     virtual bool write(const DataType& data)
00114     {
00115       if (isFull())
00116         {
00117           overflow(data);
00118           return false;
00119         }
00120       put(data);
00121       pbump(1);
00122       return true;
00123     }
00124     
00125     virtual int writable()
00126     {
00127       return (m_size + m_wend - m_wbegin) % m_size;
00128     }
00129     
00130     virtual void put(const DataType& data)
00131     {
00132       m_buffer[m_wpos] = data;
00133     }
00134     
00135     virtual int putn(DataType* data, int size)
00136     {
00137       return 1; 
00138     }
00139     
00140     virtual void putNext(const DataType& data)
00141     {
00142       pbump(1);
00143       put(data);
00144     }
00145     
00146     virtual bool isFull() const
00147     {
00148       return m_wnext == m_rpos;
00149     }
00150     
00151     virtual void pbump(int n)
00152     {
00153       //      ACE_Guard<ACE_Thread_Mutex> guard(m_wmutex);
00154       m_wpos = (m_wpos + n) % m_size;
00155       m_wnext = (m_wnext + n) % m_size;
00156     }
00157     
00158     virtual void overflow(const DataType& data)
00159     {
00160     }
00161     
00162     //============================================================
00163     // 読出し関連関数
00164     //============================================================
00165     virtual bool read(DataType& data)
00166     {
00167       if (isEmpty())
00168         {
00169           this->underflow();
00170           return false;
00171         }
00172       
00173       data = get();
00174       gbump(1);
00175       return true;
00176     }
00177     
00178     virtual int readable() const
00179     {
00180       return (m_size + m_rend - m_rbegin + 1) % m_size;
00181     }
00182     
00183     virtual const DataType& get()
00184     {
00185       return m_buffer[(m_rend + m_size - 1) % m_size];
00186     }
00187     
00188     virtual void gbump(int n)
00189     {
00190       m_rpos = (m_rpos + n) % m_size;
00191       m_rnext = (m_rnext + n) % m_size;
00192     }
00193     
00194     virtual DataType& getNext()
00195     {
00196       return m_buffer[m_rnext];
00197     }
00198     
00199     virtual int getn(DataType* data, int size)
00200     {
00201       if (!data) return -1;
00202       if (size < 0) return -1;
00203       
00204       int len(size);
00205       if (size > readable())
00206         {
00207           len = readable();
00208         }
00209       //      DataType* tmp;
00210       //      tmp = (m_wpos + 1) % m_size;
00211       
00212       
00213       return size;
00214     }
00215     
00216     virtual bool isEmpty() const
00217     {
00218       return m_rpos == m_wpos;
00219     }
00220     
00221     virtual void underflow()
00222     {
00223       ;
00224     }
00225     
00226     
00227     
00228     
00229   protected:
00230     virtual DataType* wptr()
00231     {
00232       return &m_buffer[m_wpos];
00233     }
00234 
00235     virtual DataType* wnext()
00236     {
00237       return &m_buffer[m_wnext];
00238     }
00239 
00240     virtual DataType* wbegin()
00241     {
00242       return &m_buffer[m_wbegin];
00243     }
00244 
00245     virtual DataType* wend()
00246     {
00247       return &m_buffer[m_wend];
00248     }
00249 
00250     virtual DataType* rptr()
00251     {
00252       return &m_buffer[m_rpos];
00253     }
00254 
00255     virtual DataType* rnext()
00256     {
00257       return &m_buffer[m_rnext];
00258     }
00259 
00260     virtual DataType* rbegin()
00261     {
00262       return &m_buffer[m_rbegin];
00263     }
00264 
00265     virtual DataType* rend()
00266     {
00267       return &m_buffer[m_rend];
00268     }
00269 
00270 
00271     DataType* m_buffer;
00272     int m_size;
00273     
00274     DataType* m_buffer_org;
00275     int m_size_org;
00276     
00277     // 現在の書き込み位置
00278     int m_wpos;
00279     // 現在の次の書き込み位置
00280     int m_wnext;
00281     int m_rpos, m_rnext;
00282     int &m_wbegin, &m_wend;
00283     int &m_rbegin, &m_rend;
00284     
00285   }; // class SyncLIFO
00286 };
00287 
00288 #endif // SyncLIFO_h

Generated on Thu May 29 15:03:33 2008 for OpenRTM by  doxygen 1.5.3