Buffer for general purpose use. Templated for most datatypes

Dependents:   BufferedSoftSerial 09_PT1000 10_PT1000 11_PT1000 ... more

Example

 #include "mbed.h"
 #include "Buffer.h"

 Buffer <char> buf;

 int main()
 {
     buf = 'a';
     buf.put('b');
     char *head = buf.head();
     puts(head);

     char whats_in_there[2] = {0};
     int pos = 0;

     while(buf.available())
     {   
         whats_in_there[pos++] = buf;
     }
     printf("%c %c\n", whats_in_there[0], whats_in_there[1]);
     buf.clear();
     error("done\n\n\n");
 }

Files at this revision

API Documentation at this revision

Comitter:
sam_grove
Date:
Mon Mar 07 21:10:13 2016 +0000
Parent:
5:7b754354b99c
Commit message:
Update class name to MyBuffer to avoid conflicting names with a class in the mbed library

Changed in this revision

Buffer.cpp Show diff for this revision Revisions of this file
Buffer.h Show diff for this revision Revisions of this file
MyBuffer.cpp Show annotated file Show diff for this revision Revisions of this file
MyBuffer.h Show annotated file Show diff for this revision Revisions of this file
diff -r 7b754354b99c -r 89564915f2a7 Buffer.cpp
--- a/Buffer.cpp	Wed Jan 07 18:34:56 2015 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,76 +0,0 @@
-
-/**
- * @file    Buffer.cpp
- * @brief   Software Buffer - Templated Ring Buffer for most data types
- * @author  sam grove
- * @version 1.0
- * @see     
- *
- * Copyright (c) 2013
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
- 
-#include "Buffer.h"
-
-template <class T>
-Buffer<T>::Buffer(uint32_t size)
-{
-    _buf = new T [size];
-    _size = size;
-    clear();
-    
-    return;
-}
-
-template <class T>
-Buffer<T>::~Buffer()
-{
-    delete [] _buf;
-    
-    return;
-}
-
-template <class T>
-uint32_t Buffer<T>::getSize() 
-{ 
-    return this->_size; 
-}
-
-template <class T>
-void Buffer<T>::clear(void)
-{
-    _wloc = 0;
-    _rloc = 0;
-    memset(_buf, 0, _size);
-    
-    return;
-}
-
-template <class T>
-uint32_t Buffer<T>::peek(char c)
-{
-    return 1;
-}
-
-// make the linker aware of some possible types
-template class Buffer<uint8_t>;
-template class Buffer<int8_t>;
-template class Buffer<uint16_t>;
-template class Buffer<int16_t>;
-template class Buffer<uint32_t>;
-template class Buffer<int32_t>;
-template class Buffer<uint64_t>;
-template class Buffer<int64_t>;
-template class Buffer<char>;
-template class Buffer<wchar_t>;
diff -r 7b754354b99c -r 89564915f2a7 Buffer.h
--- a/Buffer.h	Wed Jan 07 18:34:56 2015 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,163 +0,0 @@
-
-/**
- * @file    Buffer.h
- * @brief   Software Buffer - Templated Ring Buffer for most data types
- * @author  sam grove
- * @version 1.0
- * @see     
- *
- * Copyright (c) 2013
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
- 
-#ifndef BUFFER_H
-#define BUFFER_H
-
-#include <stdint.h>
-#include <string.h>
-
-/** A templated software ring buffer
- *
- * Example:
- * @code
- *  #include "mbed.h"
- *  #include "Buffer.h"
- *
- *  Buffer <char> buf;
- *
- *  int main()
- *  {
- *      buf = 'a';
- *      buf.put('b');
- *      char *head = buf.head();
- *      puts(head);
- *
- *      char whats_in_there[2] = {0};
- *      int pos = 0;
- *
- *      while(buf.available())
- *      {   
- *          whats_in_there[pos++] = buf;
- *      }
- *      printf("%c %c\n", whats_in_there[0], whats_in_there[1]);
- *      buf.clear();
- *      error("done\n\n\n");
- *  }
- * @endcode
- */
-
-template <typename T>
-class Buffer
-{
-private:
-    T   *_buf;
-    volatile uint32_t   _wloc;
-    volatile uint32_t   _rloc;
-    uint32_t            _size;
-
-public:
-    /** Create a Buffer and allocate memory for it
-     *  @param size The size of the buffer
-     */
-    Buffer(uint32_t size = 0x100);
-    
-    /** Get the size of the ring buffer
-     * @return the size of the ring buffer
-     */
-     uint32_t getSize();
-    
-    /** Destry a Buffer and release it's allocated memory
-     */
-    ~Buffer();
-    
-    /** Add a data element into the buffer
-     *  @param data Something to add to the buffer
-     */
-    void put(T data);
-    
-    /** Remove a data element from the buffer
-     *  @return Pull the oldest element from the buffer
-     */
-    T get(void);
-    
-    /** Get the address to the head of the buffer
-     *  @return The address of element 0 in the buffer
-     */
-    T *head(void);
-    
-    /** Reset the buffer to 0. Useful if using head() to parse packeted data
-     */
-    void clear(void);
-    
-    /** Determine if anything is readable in the buffer
-     *  @return 1 if something can be read, 0 otherwise
-     */
-    uint32_t available(void);
-    
-    /** Overloaded operator for writing to the buffer
-     *  @param data Something to put in the buffer
-     *  @return
-     */
-    Buffer &operator= (T data)
-    {
-        put(data);
-        return *this;
-    }
-    
-    /** Overloaded operator for reading from the buffer
-     *  @return Pull the oldest element from the buffer 
-     */  
-    operator int(void)
-    {
-        return get();
-    }
-    
-     uint32_t peek(char c);
-    
-};
-
-template <class T>
-inline void Buffer<T>::put(T data)
-{
-    _buf[_wloc++] = data;
-    _wloc %= (_size-1);
-    
-    return;
-}
-
-template <class T>
-inline T Buffer<T>::get(void)
-{
-    T data_pos = _buf[_rloc++];
-    _rloc %= (_size-1);
-    
-    return data_pos;
-}
-
-template <class T>
-inline T *Buffer<T>::head(void)
-{
-    T *data_pos = &_buf[0];
-    
-    return data_pos;
-}
-
-template <class T>
-inline uint32_t Buffer<T>::available(void)
-{
-    return (_wloc == _rloc) ? 0 : 1;
-}
-
-#endif
-
diff -r 7b754354b99c -r 89564915f2a7 MyBuffer.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/MyBuffer.cpp	Mon Mar 07 21:10:13 2016 +0000
@@ -0,0 +1,76 @@
+
+/**
+ * @file    Buffer.cpp
+ * @brief   Software Buffer - Templated Ring Buffer for most data types
+ * @author  sam grove
+ * @version 1.0
+ * @see     
+ *
+ * Copyright (c) 2013
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+ 
+#include "MyBuffer.h"
+
+template <class T>
+MyBuffer<T>::MyBuffer(uint32_t size)
+{
+    _buf = new T [size];
+    _size = size;
+    clear();
+    
+    return;
+}
+
+template <class T>
+MyBuffer<T>::~MyBuffer()
+{
+    delete [] _buf;
+    
+    return;
+}
+
+template <class T>
+uint32_t MyBuffer<T>::getSize() 
+{ 
+    return this->_size; 
+}
+
+template <class T>
+void MyBuffer<T>::clear(void)
+{
+    _wloc = 0;
+    _rloc = 0;
+    memset(_buf, 0, _size);
+    
+    return;
+}
+
+template <class T>
+uint32_t MyBuffer<T>::peek(char c)
+{
+    return 1;
+}
+
+// make the linker aware of some possible types
+template class MyBuffer<uint8_t>;
+template class MyBuffer<int8_t>;
+template class MyBuffer<uint16_t>;
+template class MyBuffer<int16_t>;
+template class MyBuffer<uint32_t>;
+template class MyBuffer<int32_t>;
+template class MyBuffer<uint64_t>;
+template class MyBuffer<int64_t>;
+template class MyBuffer<char>;
+template class MyBuffer<wchar_t>;
diff -r 7b754354b99c -r 89564915f2a7 MyBuffer.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/MyBuffer.h	Mon Mar 07 21:10:13 2016 +0000
@@ -0,0 +1,163 @@
+
+/**
+ * @file    Buffer.h
+ * @brief   Software Buffer - Templated Ring Buffer for most data types
+ * @author  sam grove
+ * @version 1.0
+ * @see     
+ *
+ * Copyright (c) 2013
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+ 
+#ifndef MYBUFFER_H
+#define MYBUFFER_H
+
+#include <stdint.h>
+#include <string.h>
+
+/** A templated software ring buffer
+ *
+ * Example:
+ * @code
+ *  #include "mbed.h"
+ *  #include "MyBuffer.h"
+ *
+ *  MyBuffer <char> buf;
+ *
+ *  int main()
+ *  {
+ *      buf = 'a';
+ *      buf.put('b');
+ *      char *head = buf.head();
+ *      puts(head);
+ *
+ *      char whats_in_there[2] = {0};
+ *      int pos = 0;
+ *
+ *      while(buf.available())
+ *      {   
+ *          whats_in_there[pos++] = buf;
+ *      }
+ *      printf("%c %c\n", whats_in_there[0], whats_in_there[1]);
+ *      buf.clear();
+ *      error("done\n\n\n");
+ *  }
+ * @endcode
+ */
+
+template <typename T>
+class MyBuffer
+{
+private:
+    T   *_buf;
+    volatile uint32_t   _wloc;
+    volatile uint32_t   _rloc;
+    uint32_t            _size;
+
+public:
+    /** Create a Buffer and allocate memory for it
+     *  @param size The size of the buffer
+     */
+    MyBuffer(uint32_t size = 0x100);
+    
+    /** Get the size of the ring buffer
+     * @return the size of the ring buffer
+     */
+     uint32_t getSize();
+    
+    /** Destry a Buffer and release it's allocated memory
+     */
+    ~MyBuffer();
+    
+    /** Add a data element into the buffer
+     *  @param data Something to add to the buffer
+     */
+    void put(T data);
+    
+    /** Remove a data element from the buffer
+     *  @return Pull the oldest element from the buffer
+     */
+    T get(void);
+    
+    /** Get the address to the head of the buffer
+     *  @return The address of element 0 in the buffer
+     */
+    T *head(void);
+    
+    /** Reset the buffer to 0. Useful if using head() to parse packeted data
+     */
+    void clear(void);
+    
+    /** Determine if anything is readable in the buffer
+     *  @return 1 if something can be read, 0 otherwise
+     */
+    uint32_t available(void);
+    
+    /** Overloaded operator for writing to the buffer
+     *  @param data Something to put in the buffer
+     *  @return
+     */
+    MyBuffer &operator= (T data)
+    {
+        put(data);
+        return *this;
+    }
+    
+    /** Overloaded operator for reading from the buffer
+     *  @return Pull the oldest element from the buffer 
+     */  
+    operator int(void)
+    {
+        return get();
+    }
+    
+     uint32_t peek(char c);
+    
+};
+
+template <class T>
+inline void MyBuffer<T>::put(T data)
+{
+    _buf[_wloc++] = data;
+    _wloc %= (_size-1);
+    
+    return;
+}
+
+template <class T>
+inline T MyBuffer<T>::get(void)
+{
+    T data_pos = _buf[_rloc++];
+    _rloc %= (_size-1);
+    
+    return data_pos;
+}
+
+template <class T>
+inline T *MyBuffer<T>::head(void)
+{
+    T *data_pos = &_buf[0];
+    
+    return data_pos;
+}
+
+template <class T>
+inline uint32_t MyBuffer<T>::available(void)
+{
+    return (_wloc == _rloc) ? 0 : 1;
+}
+
+#endif
+