added: convert (functions for converting) currently only int(long) -> string

added: textstream (an efficient memory stream for creating strings -- it's using MemBuffer) git-svn-id: svn://ttmath.org/publicrep/pikotools/trunk@425 e52654a7-88a9-db11-a3e9-0013d4bc506e
2012-07-03 14:58:18 +00:00
parent 64b05fe8d1
commit d2d30cf640
4 changed files with 839 additions and 134 deletions
--- a/membuffer/membuffer.h
+++ b/membuffer/membuffer.h
@@ -47,25 +47,25 @@ namespace PT


 */
-template<class ItemType, size_t stack_size, size_t heap_block_size>
+template<typename item_type, size_t stack_size, size_t heap_block_size>
 class MemBuffer
 {
 public:

-	class Iterator
+	class iterator
 	{
 	public:

-		bool operator==(const Iterator & i);
-		bool operator!=(const Iterator & i);
+		bool operator==(const iterator & i);
+		bool operator!=(const iterator & i);

-		Iterator & operator++(); 		// prefix  ++
-		Iterator   operator++(int); 	// postfix ++
+		iterator & operator++(); 		// prefix  ++
+		iterator   operator++(int); 	// postfix ++

-		Iterator & operator--(); 		// prefix  --
-		Iterator   operator--(int); 	// postfix --
+		iterator & operator--(); 		// prefix  --
+		iterator   operator--(int); 	// postfix --

-		ItemType & operator*();
+		item_type & operator*();

 	private:

@@ -77,20 +77,26 @@ public:
 	};


-	class ConstIterator
+	class const_iterator
 	{
 	public:

-		bool operator==(const ConstIterator & i);
-		bool operator!=(const ConstIterator & i);
+		const_iterator();
+		const_iterator(const const_iterator & i);
+		const_iterator(const iterator & i);
+		const_iterator & operator=(const const_iterator & i);
+		const_iterator & operator=(const iterator & i);

-		ConstIterator & operator++(); 		// prefix  ++
-		ConstIterator   operator++(int); 	// postfix ++
+		bool operator==(const const_iterator & i);
+		bool operator!=(const const_iterator & i);

-		ConstIterator & operator--(); 		// prefix  --
-		ConstIterator   operator--(int); 	// postfix --
+		const_iterator & operator++(); 		// prefix  ++
+		const_iterator   operator++(int); 	// postfix ++

-		ItemType operator*();
+		const_iterator & operator--(); 		// prefix  --
+		const_iterator   operator--(int); 	// postfix --
+
+		item_type operator*();

 	private:

@@ -105,26 +111,30 @@ public:

 	MemBuffer();
 	~MemBuffer();
-	MemBuffer(const MemBuffer<ItemType, stack_size, heap_block_size> & arg);
-	MemBuffer & operator=(const MemBuffer<ItemType, stack_size, heap_block_size> & arg);
+	MemBuffer(const MemBuffer<item_type, stack_size, heap_block_size> & arg);
+	MemBuffer & operator=(const MemBuffer<item_type, stack_size, heap_block_size> & arg);

-	void Append(ItemType item);
-	void Append(ItemType * item_array, size_t len);
-	size_t Size() const;
-	bool Empty() const;
+	void append(item_type item);
+	void append(item_type * item_array, size_t len);
+	
+	template<typename arg_item_type, size_t arg_stack_size, size_t arg_heap_block_size>
+	void append(const MemBuffer<arg_item_type, arg_stack_size, arg_heap_block_size> & arg);

-	void   Reserve(size_t len);
-	size_t Capacity() const;
-	void   Clear();						// frees memory but only to Capacity()
+	size_t size() const;
+	bool   empty() const;

-	Iterator Begin();
-	Iterator End();
+	void   reserve(size_t len);
+	size_t capacity() const;
+	void   clear();						// frees memory but only to capacity()

-	ConstIterator Begin() const;
-	ConstIterator End() const;
+	iterator begin();
+	iterator end();

-	ItemType & operator[](size_t i);
-	const ItemType operator[](size_t i) const;
+	const_iterator begin() const;
+	const_iterator end() const;
+
+	item_type & operator[](size_t i);
+	const item_type operator[](size_t i) const;


 private:
@@ -132,10 +142,10 @@ private:
 	struct MemArray
 	{
 		size_t size_used;
-		ItemType * buf;
+		item_type * buf;
 	};

-	ItemType stack_array[stack_size];
+	item_type stack_array[stack_size];
 	MemArray * dynamic_array;			// dynamic array of MemArray descriptors
 	size_t dynamic_array_index;			// index of a MemArray to which the last insertion was made
 										// size_t(-1) means the stack_array
@@ -144,21 +154,21 @@ private:

 	size_t size_used; 					// the size of all valid items
 	size_t size_allocated;				// how many memory is reserved
-	size_t size_reserved;				// memory reserved by Reserve(), it is used by Clear()
+	size_t size_reserved;				// memory reserved by reserve(), it is used by clear()

-	void AddDynamicNode();
+	void add_dynamic_node();
 };



 /*
-	Iterator
+	iterator
 */


-template<class ItemType, size_t stack_size, size_t heap_block_size>
-typename MemBuffer<ItemType, stack_size, heap_block_size>::Iterator &
-MemBuffer<ItemType, stack_size, heap_block_size>::Iterator::operator++()
+template<typename item_type, size_t stack_size, size_t heap_block_size>
+typename MemBuffer<item_type, stack_size, heap_block_size>::iterator &
+MemBuffer<item_type, stack_size, heap_block_size>::iterator::operator++()
 {
 	if( dynamic_array_index == size_t(-1) )
 	{
@@ -185,11 +195,11 @@ return *this;
 }


-template<class ItemType, size_t stack_size, size_t heap_block_size>
-typename MemBuffer<ItemType, stack_size, heap_block_size>::Iterator
-MemBuffer<ItemType, stack_size, heap_block_size>::Iterator::operator++(int)
+template<typename item_type, size_t stack_size, size_t heap_block_size>
+typename MemBuffer<item_type, stack_size, heap_block_size>::iterator
+MemBuffer<item_type, stack_size, heap_block_size>::iterator::operator++(int)
 {
-	Iterator old(*this);
+	iterator old(*this);
 	operator++();

 return old;
@@ -197,9 +207,9 @@ return old;



-template<class ItemType, size_t stack_size, size_t heap_block_size>
-typename MemBuffer<ItemType, stack_size, heap_block_size>::Iterator &
-MemBuffer<ItemType, stack_size, heap_block_size>::Iterator::operator--()
+template<typename item_type, size_t stack_size, size_t heap_block_size>
+typename MemBuffer<item_type, stack_size, heap_block_size>::iterator &
+MemBuffer<item_type, stack_size, heap_block_size>::iterator::operator--()
 {
 	if( index == 0 )
 	{
@@ -219,11 +229,11 @@ return *this;
 }


-template<class ItemType, size_t stack_size, size_t heap_block_size>
-typename MemBuffer<ItemType, stack_size, heap_block_size>::Iterator
-MemBuffer<ItemType, stack_size, heap_block_size>::Iterator::operator--(int)
+template<typename item_type, size_t stack_size, size_t heap_block_size>
+typename MemBuffer<item_type, stack_size, heap_block_size>::iterator
+MemBuffer<item_type, stack_size, heap_block_size>::iterator::operator--(int)
 {
-	Iterator old(*this);
+	iterator old(*this);
 	operator++();

 return old;
@@ -231,8 +241,8 @@ return old;



-template<class ItemType, size_t stack_size, size_t heap_block_size>
-ItemType & MemBuffer<ItemType, stack_size, heap_block_size>::Iterator::operator*()
+template<typename item_type, size_t stack_size, size_t heap_block_size>
+item_type & MemBuffer<item_type, stack_size, heap_block_size>::iterator::operator*()
 {
 	if( dynamic_array_index == size_t(-1) )
 	{
@@ -245,8 +255,8 @@ ItemType & MemBuffer<ItemType, stack_size, heap_block_size>::Iterator::operator*
 }


-template<class ItemType, size_t stack_size, size_t heap_block_size>
-bool MemBuffer<ItemType, stack_size, heap_block_size>::Iterator::operator==(const Iterator & i)
+template<typename item_type, size_t stack_size, size_t heap_block_size>
+bool MemBuffer<item_type, stack_size, heap_block_size>::iterator::operator==(const iterator & i)
 {
 	return	mem_buffer == i.mem_buffer && 
 			dynamic_array_index == i.dynamic_array_index &&
@@ -254,8 +264,8 @@ bool MemBuffer<ItemType, stack_size, heap_block_size>::Iterator::operator==(cons
 }


-template<class ItemType, size_t stack_size, size_t heap_block_size>
-bool MemBuffer<ItemType, stack_size, heap_block_size>::Iterator::operator!=(const Iterator & i)
+template<typename item_type, size_t stack_size, size_t heap_block_size>
+bool MemBuffer<item_type, stack_size, heap_block_size>::iterator::operator!=(const iterator & i)
 {
 	return	mem_buffer != i.mem_buffer ||
 			dynamic_array_index != i.dynamic_array_index ||
@@ -265,13 +275,58 @@ bool MemBuffer<ItemType, stack_size, heap_block_size>::Iterator::operator!=(cons


 /*
-	ConstIterator
+	const_iterator
 */


-template<class ItemType, size_t stack_size, size_t heap_block_size>
-typename MemBuffer<ItemType, stack_size, heap_block_size>::ConstIterator &
-MemBuffer<ItemType, stack_size, heap_block_size>::ConstIterator::operator++()
+template<typename item_type, size_t stack_size, size_t heap_block_size>
+MemBuffer<item_type, stack_size, heap_block_size>::const_iterator::const_iterator()
+{
+}
+
+
+template<typename item_type, size_t stack_size, size_t heap_block_size>
+MemBuffer<item_type, stack_size, heap_block_size>::const_iterator::const_iterator(const const_iterator & i)
+{
+	operator=(i);
+}
+
+
+template<typename item_type, size_t stack_size, size_t heap_block_size>
+MemBuffer<item_type, stack_size, heap_block_size>::const_iterator::const_iterator(const iterator & i)
+{
+	operator=(i);
+}
+
+
+template<typename item_type, size_t stack_size, size_t heap_block_size>
+typename MemBuffer<item_type, stack_size, heap_block_size>::const_iterator &
+MemBuffer<item_type, stack_size, heap_block_size>::const_iterator::operator=(const const_iterator & i)
+{
+	mem_buffer = i.mem_buffer;
+	dynamic_array_index = i.dynamic_array_index;
+	index = i.index;
+
+return *this;
+}
+
+
+template<typename item_type, size_t stack_size, size_t heap_block_size>
+typename MemBuffer<item_type, stack_size, heap_block_size>::const_iterator &
+MemBuffer<item_type, stack_size, heap_block_size>::const_iterator::operator=(const iterator & i)
+{
+	mem_buffer = i.mem_buffer;
+	dynamic_array_index = i.dynamic_array_index;
+	index = i.index;
+
+return *this;
+}
+
+
+
+template<typename item_type, size_t stack_size, size_t heap_block_size>
+typename MemBuffer<item_type, stack_size, heap_block_size>::const_iterator &
+MemBuffer<item_type, stack_size, heap_block_size>::const_iterator::operator++()
 {
 	if( dynamic_array_index == size_t(-1) )
 	{
@@ -298,11 +353,11 @@ return *this;
 }


-template<class ItemType, size_t stack_size, size_t heap_block_size>
-typename MemBuffer<ItemType, stack_size, heap_block_size>::ConstIterator
-MemBuffer<ItemType, stack_size, heap_block_size>::ConstIterator::operator++(int)
+template<typename item_type, size_t stack_size, size_t heap_block_size>
+typename MemBuffer<item_type, stack_size, heap_block_size>::const_iterator
+MemBuffer<item_type, stack_size, heap_block_size>::const_iterator::operator++(int)
 {
-	ConstIterator old(*this);
+	const_iterator old(*this);
 	operator++();

 return old;
@@ -310,9 +365,9 @@ return old;



-template<class ItemType, size_t stack_size, size_t heap_block_size>
-typename MemBuffer<ItemType, stack_size, heap_block_size>::ConstIterator &
-MemBuffer<ItemType, stack_size, heap_block_size>::ConstIterator::operator--()
+template<typename item_type, size_t stack_size, size_t heap_block_size>
+typename MemBuffer<item_type, stack_size, heap_block_size>::const_iterator &
+MemBuffer<item_type, stack_size, heap_block_size>::const_iterator::operator--()
 {
 	if( index == 0 )
 	{
@@ -332,11 +387,11 @@ return *this;
 }


-template<class ItemType, size_t stack_size, size_t heap_block_size>
-typename MemBuffer<ItemType, stack_size, heap_block_size>::ConstIterator
-MemBuffer<ItemType, stack_size, heap_block_size>::ConstIterator::operator--(int)
+template<typename item_type, size_t stack_size, size_t heap_block_size>
+typename MemBuffer<item_type, stack_size, heap_block_size>::const_iterator
+MemBuffer<item_type, stack_size, heap_block_size>::const_iterator::operator--(int)
 {
-	ConstIterator old(*this);
+	const_iterator old(*this);
 	operator++();

 return old;
@@ -344,8 +399,8 @@ return old;



-template<class ItemType, size_t stack_size, size_t heap_block_size>
-ItemType MemBuffer<ItemType, stack_size, heap_block_size>::ConstIterator::operator*()
+template<typename item_type, size_t stack_size, size_t heap_block_size>
+item_type MemBuffer<item_type, stack_size, heap_block_size>::const_iterator::operator*()
 {
 	if( dynamic_array_index == size_t(-1) )
 	{
@@ -358,8 +413,8 @@ ItemType MemBuffer<ItemType, stack_size, heap_block_size>::ConstIterator::operat
 }


-template<class ItemType, size_t stack_size, size_t heap_block_size>
-bool MemBuffer<ItemType, stack_size, heap_block_size>::ConstIterator::operator==(const ConstIterator & i)
+template<typename item_type, size_t stack_size, size_t heap_block_size>
+bool MemBuffer<item_type, stack_size, heap_block_size>::const_iterator::operator==(const const_iterator & i)
 {
 	return	mem_buffer == i.mem_buffer && 
 			dynamic_array_index == i.dynamic_array_index &&
@@ -367,8 +422,8 @@ bool MemBuffer<ItemType, stack_size, heap_block_size>::ConstIterator::operator==
 }


-template<class ItemType, size_t stack_size, size_t heap_block_size>
-bool MemBuffer<ItemType, stack_size, heap_block_size>::ConstIterator::operator!=(const ConstIterator & i)
+template<typename item_type, size_t stack_size, size_t heap_block_size>
+bool MemBuffer<item_type, stack_size, heap_block_size>::const_iterator::operator!=(const const_iterator & i)
 {
 	return	mem_buffer != i.mem_buffer ||
 			dynamic_array_index != i.dynamic_array_index ||
@@ -384,8 +439,8 @@ bool MemBuffer<ItemType, stack_size, heap_block_size>::ConstIterator::operator!=
 */


-template<class ItemType, size_t stack_size, size_t heap_block_size>
-MemBuffer<ItemType, stack_size, heap_block_size>::MemBuffer()
+template<typename item_type, size_t stack_size, size_t heap_block_size>
+MemBuffer<item_type, stack_size, heap_block_size>::MemBuffer()
 {
 	size_reserved       = 0;
 	size_used           = 0;
@@ -397,8 +452,8 @@ MemBuffer<ItemType, stack_size, heap_block_size>::MemBuffer()
 }


-template<class ItemType, size_t stack_size, size_t heap_block_size>
-MemBuffer<ItemType, stack_size, heap_block_size>::~MemBuffer()
+template<typename item_type, size_t stack_size, size_t heap_block_size>
+MemBuffer<item_type, stack_size, heap_block_size>::~MemBuffer()
 {
 	if( dynamic_array )
 	{
@@ -410,32 +465,32 @@ MemBuffer<ItemType, stack_size, heap_block_size>::~MemBuffer()
 }


-template<class ItemType, size_t stack_size, size_t heap_block_size>
-MemBuffer<ItemType, stack_size, heap_block_size>::MemBuffer(const MemBuffer<ItemType, stack_size, heap_block_size> & arg)
+template<typename item_type, size_t stack_size, size_t heap_block_size>
+MemBuffer<item_type, stack_size, heap_block_size>::MemBuffer(const MemBuffer<item_type, stack_size, heap_block_size> & arg)
 {
 	operator=(arg);
 }


-template<class ItemType, size_t stack_size, size_t heap_block_size>
-MemBuffer<ItemType, stack_size, heap_block_size> &
-MemBuffer<ItemType, stack_size, heap_block_size>::operator=(const MemBuffer<ItemType, stack_size, heap_block_size> & arg)
+template<typename item_type, size_t stack_size, size_t heap_block_size>
+MemBuffer<item_type, stack_size, heap_block_size> &
+MemBuffer<item_type, stack_size, heap_block_size>::operator=(const MemBuffer<item_type, stack_size, heap_block_size> & arg)
 {
 	if( size_used > 0 )
-		Clear();
+		clear();

-	ConstIterator i = arg.Begin();
+	const_iterator i = arg.begin();

-	for( ; i != arg.End() ; ++i)
-		Append(*i);
+	for( ; i != arg.end() ; ++i)
+		append(*i);

 return *this;
 }



-template<class ItemType, size_t stack_size, size_t heap_block_size>
-void MemBuffer<ItemType, stack_size, heap_block_size>::AddDynamicNode()
+template<typename item_type, size_t stack_size, size_t heap_block_size>
+void MemBuffer<item_type, stack_size, heap_block_size>::add_dynamic_node()
 {
 	if( dynamic_array_used >= dynamic_array_size )
 	{
@@ -451,7 +506,7 @@ void MemBuffer<ItemType, stack_size, heap_block_size>::AddDynamicNode()
 	}

 	dynamic_array[dynamic_array_used].size_used = 0;
-	dynamic_array[dynamic_array_used].buf       = new ItemType[heap_block_size];
+	dynamic_array[dynamic_array_used].buf       = new item_type[heap_block_size];

 	dynamic_array_used += 1;
 	size_allocated     += heap_block_size;
@@ -460,8 +515,8 @@ void MemBuffer<ItemType, stack_size, heap_block_size>::AddDynamicNode()



-template<class ItemType, size_t stack_size, size_t heap_block_size>
-void MemBuffer<ItemType, stack_size, heap_block_size>::Append(ItemType item)
+template<typename item_type, size_t stack_size, size_t heap_block_size>
+void MemBuffer<item_type, stack_size, heap_block_size>::append(item_type item)
 {
 	if( size_used < stack_size )
 	{
@@ -474,7 +529,7 @@ void MemBuffer<ItemType, stack_size, heap_block_size>::Append(ItemType item)
 			dynamic_array_index = 0;

 			if( dynamic_array_index >= dynamic_array_used )
-				AddDynamicNode();
+				add_dynamic_node();

 			dynamic_array[dynamic_array_index].size_used = 0;
 		}
@@ -484,7 +539,7 @@ void MemBuffer<ItemType, stack_size, heap_block_size>::Append(ItemType item)
 			dynamic_array_index += 1;

 			if( dynamic_array_index >= dynamic_array_used )
-				AddDynamicNode();
+				add_dynamic_node();

 			dynamic_array[dynamic_array_index].size_used = 0;
 		}
@@ -497,8 +552,8 @@ void MemBuffer<ItemType, stack_size, heap_block_size>::Append(ItemType item)
 }


-template<class ItemType, size_t stack_size, size_t heap_block_size>
-void MemBuffer<ItemType, stack_size, heap_block_size>::Append(ItemType * item_array, size_t len)
+template<typename item_type, size_t stack_size, size_t heap_block_size>
+void MemBuffer<item_type, stack_size, heap_block_size>::append(item_type * item_array, size_t len)
 {
 	if( size_used + len <= stack_size )
 	{
@@ -511,7 +566,7 @@ void MemBuffer<ItemType, stack_size, heap_block_size>::Append(ItemType * item_ar
 	if( dynamic_array_index != size_t(-1) &&
 		dynamic_array[dynamic_array_index].size_used + len <= heap_block_size )
 	{
-		ItemType * buf = dynamic_array[dynamic_array_index].buf;
+		item_type * buf = dynamic_array[dynamic_array_index].buf;
 		size_t bufsize = dynamic_array[dynamic_array_index].size_used;

 		for(size_t i=0 ; i<len ; ++i)
@@ -524,15 +579,27 @@ void MemBuffer<ItemType, stack_size, heap_block_size>::Append(ItemType * item_ar
 	}

 	for(size_t i=0 ; i<len ; ++i)
-		Append(item_array[i]);
+		append(item_array[i]);
+}
+
+
+
+template<typename item_type, size_t stack_size, size_t heap_block_size>
+template<typename arg_item_type, size_t arg_stack_size, size_t arg_heap_block_size>
+void MemBuffer<item_type, stack_size, heap_block_size>::append(
+		const MemBuffer<arg_item_type, arg_stack_size, arg_heap_block_size> & arg)
+{
+	typename MemBuffer<arg_item_type, arg_stack_size, arg_heap_block_size>::const_iterator i = arg.begin();
+
+	for( ; i != arg.end() ; ++i)
+		append(static_cast<item_type>(*i));
 }




-
-template<class ItemType, size_t stack_size, size_t heap_block_size>
-ItemType & MemBuffer<ItemType, stack_size, heap_block_size>::operator[](size_t i)
+template<typename item_type, size_t stack_size, size_t heap_block_size>
+item_type & MemBuffer<item_type, stack_size, heap_block_size>::operator[](size_t i)
 {
 	if( i < stack_size )
 	{
@@ -549,8 +616,8 @@ ItemType & MemBuffer<ItemType, stack_size, heap_block_size>::operator[](size_t i
 }


-template<class ItemType, size_t stack_size, size_t heap_block_size>
-const ItemType MemBuffer<ItemType, stack_size, heap_block_size>::operator[](size_t i) const
+template<typename item_type, size_t stack_size, size_t heap_block_size>
+const item_type MemBuffer<item_type, stack_size, heap_block_size>::operator[](size_t i) const
 {
 	if( i < stack_size )
 	{
@@ -567,26 +634,26 @@ const ItemType MemBuffer<ItemType, stack_size, heap_block_size>::operator[](size
 }


-template<class ItemType, size_t stack_size, size_t heap_block_size>
-size_t MemBuffer<ItemType, stack_size, heap_block_size>::Size() const
+template<typename item_type, size_t stack_size, size_t heap_block_size>
+size_t MemBuffer<item_type, stack_size, heap_block_size>::size() const
 {
 	return size_used;
 }


-template<class ItemType, size_t stack_size, size_t heap_block_size>
-bool MemBuffer<ItemType, stack_size, heap_block_size>::Empty() const
+template<typename item_type, size_t stack_size, size_t heap_block_size>
+bool MemBuffer<item_type, stack_size, heap_block_size>::empty() const
 {
 	return size_used == 0;
 }



-template<class ItemType, size_t stack_size, size_t heap_block_size>
-typename MemBuffer<ItemType, stack_size, heap_block_size>::Iterator
-MemBuffer<ItemType, stack_size, heap_block_size>::Begin()
+template<typename item_type, size_t stack_size, size_t heap_block_size>
+typename MemBuffer<item_type, stack_size, heap_block_size>::iterator
+MemBuffer<item_type, stack_size, heap_block_size>::begin()
 {
-Iterator i;
+iterator i;

 	i.mem_buffer = this;
 	i.dynamic_array_index = size_t(-1);
@@ -596,11 +663,11 @@ return i;
 }


-template<class ItemType, size_t stack_size, size_t heap_block_size>
-typename MemBuffer<ItemType, stack_size, heap_block_size>::Iterator
-MemBuffer<ItemType, stack_size, heap_block_size>::End()
+template<typename item_type, size_t stack_size, size_t heap_block_size>
+typename MemBuffer<item_type, stack_size, heap_block_size>::iterator
+MemBuffer<item_type, stack_size, heap_block_size>::end()
 {
-Iterator i;
+iterator i;

 	i.mem_buffer = this;

@@ -632,11 +699,11 @@ return i;



-template<class ItemType, size_t stack_size, size_t heap_block_size>
-typename MemBuffer<ItemType, stack_size, heap_block_size>::ConstIterator
-MemBuffer<ItemType, stack_size, heap_block_size>::Begin() const
+template<typename item_type, size_t stack_size, size_t heap_block_size>
+typename MemBuffer<item_type, stack_size, heap_block_size>::const_iterator
+MemBuffer<item_type, stack_size, heap_block_size>::begin() const
 {
-ConstIterator i;
+const_iterator i;

 	i.mem_buffer = this;
 	i.dynamic_array_index = size_t(-1);
@@ -646,11 +713,11 @@ return i;
 }


-template<class ItemType, size_t stack_size, size_t heap_block_size>
-typename MemBuffer<ItemType, stack_size, heap_block_size>::ConstIterator
-MemBuffer<ItemType, stack_size, heap_block_size>::End() const
+template<typename item_type, size_t stack_size, size_t heap_block_size>
+typename MemBuffer<item_type, stack_size, heap_block_size>::const_iterator
+MemBuffer<item_type, stack_size, heap_block_size>::end() const
 {
-ConstIterator i;
+const_iterator i;

 	i.mem_buffer = this;

@@ -682,25 +749,25 @@ return i;



-template<class ItemType, size_t stack_size, size_t heap_block_size>
-void MemBuffer<ItemType, stack_size, heap_block_size>::Reserve(size_t len)
+template<typename item_type, size_t stack_size, size_t heap_block_size>
+void MemBuffer<item_type, stack_size, heap_block_size>::reserve(size_t len)
 {
 	size_reserved = len;

 	while( size_allocated < size_reserved )
-		AddDynamicNode();
+		add_dynamic_node();
 }


-template<class ItemType, size_t stack_size, size_t heap_block_size>
-size_t MemBuffer<ItemType, stack_size, heap_block_size>::Capacity() const
+template<typename item_type, size_t stack_size, size_t heap_block_size>
+size_t MemBuffer<item_type, stack_size, heap_block_size>::capacity() const
 {
 	return size_allocated;
 }


-template<class ItemType, size_t stack_size, size_t heap_block_size>
-void MemBuffer<ItemType, stack_size, heap_block_size>::Clear()
+template<typename item_type, size_t stack_size, size_t heap_block_size>
+void MemBuffer<item_type, stack_size, heap_block_size>::clear()
 {
 	size_t index = 0;