CBuffer.h

00001 #include "mbed.h"
00002 #include "WizziDebug.h"
00003 
00004 #define LocalCircularBuffer CircularBuffer<T,BufferSize,CounterType>
00005 
00006 template<typename T, uint32_t BufferSize, typename CounterType = uint32_t>
00007 class CBuffer : private LocalCircularBuffer
00008 {
00009 public:
00010     
00011     CBuffer() : _buffered_data_size(0) {}
00012     
00013     ~CBuffer() {}
00014 
00015     CounterType get_size(void)
00016     {
00017         return BufferSize;
00018     }
00019     
00020     CounterType available_data(void)
00021     {
00022         return _buffered_data_size;
00023     }
00024     
00025     CounterType remaining_space(void)
00026     {
00027         return BufferSize - _buffered_data_size;
00028     }
00029     
00030     bool full(void)
00031     {
00032         return this->LocalCircularBuffer::full();
00033     }
00034     
00035     bool empty(void)
00036     {
00037         return this->LocalCircularBuffer::empty();
00038     }
00039     
00040     void reset(void)
00041     {
00042         _buffered_data_size = 0;
00043         this->LocalCircularBuffer::reset();
00044     }
00045     
00046     T pop(void)
00047     {
00048         T data;
00049         
00050         ASSERT(this->LocalCircularBuffer::pop(data), "CBuffer: No data in buffer to pop\r\n");
00051         _buffered_data_size--;
00052         
00053         return data;
00054     }
00055     
00056     void push(T data)
00057     {
00058         ASSERT(!this->LocalCircularBuffer::full(), "CBuffer: Buffer is full, can't push\r\n");
00059         
00060         this->LocalCircularBuffer::push(data);
00061         _buffered_data_size++;
00062     }
00063     
00064     void get(T* buf, CounterType size)
00065     {
00066         ASSERT(size, "CBuffer: Can't copy length 0\r\n");
00067         ASSERT(size <= _buffered_data_size, "CBuffer: Size too long (%d) for available data (%d)\r\n", size, _buffered_data_size);
00068         
00069         CounterType len = 0;
00070         
00071         while (len < size)
00072         {
00073             if (buf != NULL)
00074             {
00075                 this->LocalCircularBuffer::pop(buf[len]);
00076             }
00077             else
00078             {
00079                 // Pop data in dummy buffer
00080                 T dummy;
00081                 this->LocalCircularBuffer::pop(dummy);
00082             }
00083             len++;
00084         }
00085     
00086         _buffered_data_size -= size;
00087     }
00088     
00089     void add(T* buf, CounterType size)
00090     {
00091         ASSERT(size, "CBuffer: Can't add 0 bytes\r\n");
00092         ASSERT(size <= this->remaining_space(), "CBuffer: Size too long (%d) for available space (%d)\r\n", size, BufferSize - _buffered_data_size);
00093         ASSERT(buf != NULL, "CBuffer: Can't copy from NULL buffer\r\n");
00094         
00095         CounterType len = 0;
00096         
00097         while (len < size)
00098         {
00099             this->LocalCircularBuffer::push(buf[len++]);
00100         }
00101         
00102         _buffered_data_size += size;
00103     }
00104     
00105 private:
00106     volatile CounterType _buffered_data_size;
00107 };