X-Git-Url: https://git.llucax.com/software/posixx.git/blobdiff_plain/171569f214294e51065e4f9685f7e12c30912cb9..d22d22101e7dda5da951a76408ec32708072849e:/src/basic_buffer.hpp

diff --git a/src/basic_buffer.hpp b/src/basic_buffer.hpp
index 873a999..14b880c 100644
--- a/src/basic_buffer.hpp
+++ b/src/basic_buffer.hpp
@@ -4,6 +4,7 @@
 #include <stdexcept> // std::bad_alloc, std::out_of_range
 #include <limits> // std::numeric_limits
 #include <tr1/type_traits> // std::tr1::is_integral, true_type, false_type
+#include <cstdlib> // std::realloc()
 #include <cstring> // std::memcpy(), memset(), memcmp()
 #include <cassert> // assert()
 #include <cstddef> // std::size_t, ptrdiff_t
@@ -14,20 +15,20 @@ namespace posixx {
  * A low-level buffer.
  *
  * This is pretty much like using a plain C-style array using dynamic memory,
- * with a STL-ish interface.
+ * with a STL-ish interface. Only POD should be stored, since no constructors
+ * or destructors are called.
  *
  * The buffer will use Allocator (which should be a function with realloc(3)
  * semantics) for all storage management.
  */
-template< void* (*Allocator)(void*, size_t) >
+template< typename T, void* (*Allocator)(void*, size_t) = &std::realloc >
 struct basic_buffer {
 
 	// Types
 	//////////////////////////////////////////////////////////////////////
 
 	///
-	typedef unsigned char value_type; // TODO: use char to be more
-	                                  //       std::string-friendly?
+	typedef T value_type;
 
 	///
 	typedef value_type& reference;
@@ -36,7 +37,7 @@ struct basic_buffer {
 	typedef const value_type& const_reference;
 
 	///
-	typedef value_type* iterator; // TODO: make a real iterator
+	typedef value_type* iterator;
 
 	///
 	typedef const value_type* const_iterator;
@@ -54,12 +55,10 @@ struct basic_buffer {
 	typedef const pointer const_pointer;
 
 	///
-	// TODO: reverse iterator
-	//typedef typename std::reverse_iterator< iterator > reverse_iterator;
+	typedef std::reverse_iterator< iterator > reverse_iterator;
 
 	///
-	//typedef typename std::reverse_iterator< const iterator >
-	//		const_reverse_iterator;
+	typedef std::reverse_iterator< const_iterator > const_reverse_iterator;
 
 
 	// Construct/Copy/Destroy
@@ -97,7 +96,7 @@ struct basic_buffer {
 	 *
 	 * @throw std::bad_alloc
 	 */
-	basic_buffer(const basic_buffer< Allocator >& x):
+	basic_buffer(const basic_buffer< T, Allocator >& x):
 			_data(_allocate(NULL, x.size() * sizeof(value_type))),
 			_size(x.size())
 	{
@@ -128,8 +127,8 @@ struct basic_buffer {
 	 *
 	 * @throw std::bad_alloc
 	 */
-	basic_buffer< Allocator >& operator = (
-			const basic_buffer< Allocator >& x)
+	basic_buffer< T, Allocator >& operator = (
+			const basic_buffer< T, Allocator >& x)
 	{
 		if (this != &x) {
 			resize(x.size());
@@ -179,29 +178,29 @@ struct basic_buffer {
 	 * Returns a random access reverse_iterator that points to the
 	 * past-the-end value.
 	 */
-	//reverse_iterator rbegin()
-	//{ return std::reverse_iterator< iterator >(end()); }
+	reverse_iterator rbegin()
+	{ return reverse_iterator(end()); }
 
 	/**
 	 * Returns a random access const_reverse_iterator that points to the
 	 * past-the-end value.
 	 */
-	//const_reverse_iterator rbegin() const
-	//{ return std::reverse_iterator< const iterator >(end()); }
+	const_reverse_iterator rbegin() const
+	{ return const_reverse_iterator(end()); }
 
 	/**
 	 * Returns a random access reverse_iterator that points to the first
 	 * element.
 	 */
-	//reverse_iterator rend()
-	//{ return std::reverse_iterator< iterator >(begin()); }
+	reverse_iterator rend()
+	{ return reverse_iterator(begin()); }
 
 	/**
 	 * Returns a random access const_reverse_iterator that points to the
 	 * first element.
 	 */
-	//const_reverse_iterator rend() const
-	//{ return std::reverse_iterator< const iterator >(begin()); }
+	const_reverse_iterator rend() const
+	{ return const_reverse_iterator(begin()); }
 
 
 	// Capacity
@@ -408,7 +407,7 @@ struct basic_buffer {
 	 *
 	 * Invalidates all references and iterators.
 	 */
-	void swap(basic_buffer< Allocator >& x)
+	void swap(basic_buffer< T, Allocator >& x)
 	{
 		pointer tmp_data = x._data;
 		size_type tmp_size = x._size;
@@ -486,9 +485,9 @@ protected:
 /**
  * Returns true if x hass the same contents as y.
  */
-template < void* (*Allocator)(void*, std::size_t) >
-bool operator == (const basic_buffer< Allocator >& x,
-		const basic_buffer < Allocator >& y)
+template < typename T, void* (*Allocator)(void*, std::size_t) >
+bool operator == (const basic_buffer< T, Allocator >& x,
+		const basic_buffer < T, Allocator >& y)
 {
 	if (&x == &y)
 		return true;
@@ -508,9 +507,9 @@ bool operator == (const basic_buffer< Allocator >& x,
 /**
  * Returns !(x==y).
  */
-template < void* (*Allocator)(void*, std::size_t) >
-bool operator != (const basic_buffer<Allocator>& x,
-		const basic_buffer <Allocator>& y)
+template < typename T, void* (*Allocator)(void*, std::size_t) >
+bool operator != (const basic_buffer< T, Allocator >& x,
+		const basic_buffer < T, Allocator >& y)
 {
 	return !(x == y);
 }
@@ -519,9 +518,9 @@ bool operator != (const basic_buffer<Allocator>& x,
  * Returns true if the elements contained in x are lexicographically less than
  * the elements contained in y.
  */
-template < void* (*Allocator)(void*, std::size_t) >
-bool operator < (const basic_buffer< Allocator >& x,
-		const basic_buffer< Allocator >& y)
+template < typename T, void* (*Allocator)(void*, std::size_t) >
+bool operator < (const basic_buffer< T, Allocator >& x,
+		const basic_buffer< T, Allocator >& y)
 {
 	if (&x == &y)
 		return false;
@@ -541,9 +540,9 @@ bool operator < (const basic_buffer< Allocator >& x,
 /**
  * Returns y < x.
  */
-template < void* (*Allocator)(void*, std::size_t) >
-bool operator > (const basic_buffer< Allocator >& x,
-		const basic_buffer< Allocator >& y)
+template < typename T, void* (*Allocator)(void*, std::size_t) >
+bool operator > (const basic_buffer< T, Allocator >& x,
+		const basic_buffer< T, Allocator >& y)
 {
 	return y < x;
 }
@@ -551,9 +550,9 @@ bool operator > (const basic_buffer< Allocator >& x,
 /**
  * Returns !(y < x).
  */
-template < void* (*Allocator)(void*, std::size_t) >
-bool operator <= (const basic_buffer< Allocator >& x,
-		const basic_buffer< Allocator >& y)
+template < typename T, void* (*Allocator)(void*, std::size_t) >
+bool operator <= (const basic_buffer< T, Allocator >& x,
+		const basic_buffer< T, Allocator >& y)
 {
 	return !(y < x);
 }
@@ -561,9 +560,9 @@ bool operator <= (const basic_buffer< Allocator >& x,
 /**
  * Returns !(x < y).
  */
-template < void* (*Allocator)(void*, std::size_t) >
-bool operator >= (const basic_buffer< Allocator >& x,
-		const basic_buffer< Allocator >& y)
+template < typename T, void* (*Allocator)(void*, std::size_t) >
+bool operator >= (const basic_buffer< T, Allocator >& x,
+		const basic_buffer< T, Allocator >& y)
 {
 	return !(x < y);
 }
@@ -577,8 +576,8 @@ bool operator >= (const basic_buffer< Allocator >& x,
  *
  * Invalidates all references and iterators.
  */
-template < void* (*Allocator)(void*, std::size_t) >
-void swap(basic_buffer< Allocator >& x, basic_buffer< Allocator >& y)
+template < typename T, void* (*Allocator)(void*, std::size_t) >
+void swap(basic_buffer< T, Allocator >& x, basic_buffer< T, Allocator >& y)
 {
 	x.swap(y);
 }