00001
00020 #ifndef SyncLIFO_h
00021 #define SyncLIFO_h
00022
00023 #include <iostream>
00024 #include <vector>
00025 #include <algorithm>
00026
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
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
00210
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 };
00286 };
00287
00288 #endif // SyncLIFO_h