/*
   Copyright (C) 2001-2006, William Joseph.
   All Rights Reserved.

   This file is part of GtkRadiant.

   GtkRadiant is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   GtkRadiant is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with GtkRadiant; if not, write to the Free Software
   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

#if !defined( INCLUDED_CONTAINER_STACK_H )
#define INCLUDED_CONTAINER_STACK_H

#include "memory/allocator.h"
#include <algorithm>

/// \brief A stack whose storage capacity is variable at run-time. Similar to std::vector.
///
/// - Pushing or popping elements is a constant-time operation (on average).
/// - The storage capacity of the stack will grow when a new element is added beyond the current capacity. Iterators are invalidated when the storage capacity grows.
/// - DefaultConstructible, Copyable, Assignable.
/// - Compatible with the containers and algorithms in the Standard Template Library (STL) - http://www.sgi.com/tech/stl/
///
/// \param Type: The type to be stored in the stack. Must provide a copy-constructor.
template<typename Type>
class Stack : public DefaultAllocator<Type>
{
typedef DefaultAllocator<Type> Allocator;

enum
{
	DEFAULT_CAPACITY = 4,
};

typedef Type* pointer;
typedef const Type* const_pointer;

public:
typedef const_pointer const_iterator;
private:

pointer m_data;
pointer m_end;
std::size_t m_capacity;


void insert( const Type& value ){
	Allocator::construct( m_end++, value );
}
void insert_overflow( const Type& value ){
	const std::size_t new_capacity = ( m_capacity ) ? m_capacity + m_capacity : std::size_t( DEFAULT_CAPACITY );
	const pointer new_data = Allocator::allocate( new_capacity );
	const pointer new_end = std::copy( m_data, m_end, new_data );

	destroy();
	Allocator::deallocate( m_data, m_capacity );

	m_capacity = new_capacity;
	m_data = new_data;
	m_end = new_end;
	insert( value );
}
void destroy(){
	for ( pointer p = m_data; p != m_end; ++p )
	{
		Allocator::destroy( p );
	}
}
void construct( const Stack& other ){
	pointer p = m_data;
	for ( const_iterator i = other.begin(); i != other.end(); ++i )
	{
		Allocator::construct( p++, *i );
	}
}

public:

Stack() :
	m_data( 0 ),
	m_end( 0 ),
	m_capacity( 0 ){
}
Stack( const Type& value ) :
	m_data( 0 ),
	m_end( 0 ),
	m_capacity( 0 ){
	push( value );
}
Stack( const Stack& other ) :
	DefaultAllocator<Type>( other ){
	m_capacity = other.m_capacity;
	m_data = Allocator::allocate( m_capacity );
	construct( other );
	m_end = m_data + other.size();
}
~Stack(){
	destroy();
	Allocator::deallocate( m_data, m_capacity );
}

const_iterator begin() const {
	return m_data;
}
const_iterator end() const {
	return m_end;
}

bool empty() const {
	return end() == begin();
}
void clear(){
	destroy();
	m_end = m_data;
}

std::size_t size() const {
	return m_end - m_data;
}
Type operator[]( const std::size_t i ) const {
	return m_data[i];
}
/// \brief Pushes \p value onto the stack at the top element. If reserved storage is insufficient for the new element, this will invalidate all iterators.
void push( const Type& value ){
	if ( size() == m_capacity ) {
		insert_overflow( value );
	}
	else
	{
		insert( value );
	}
}
/// \brief Removes the top element of the stack.
void pop(){
	Allocator::destroy( --m_end );
}
/// \brief Returns the top element of the mutable stack.
Type& top(){
	return *( m_end - 1 );
}
/// \brief Returns the top element of the non-mutable stack.
const Type& top() const {
	return *( m_end - 1 );
}
/// \brief Returns the element below the top element of the mutable stack.
Type& parent(){
	return *( m_end - 2 );
}
/// \brief Returns the element below the top element of the non-mutable stack.
const Type& parent() const {
	return *( m_end - 2 );
}
/// \brief Swaps the values of this stack and \p other.
void swap( Stack& other ){
	std::swap( m_data, other.m_data );
	std::swap( m_end, other.m_end );
	std::swap( m_capacity, other.m_capacity );
}
#if 1 // use copy-swap technique
Stack& operator=( const Stack& other ){
	Stack temp( other );
	temp.swap( *this );
	return *this;
}
#else // avoids memory allocation if capacity is already sufficient.
Stack& operator=( const Stack& other ){
	if ( &other != this ) {
		destroy();

		if ( other.size() > m_capacity ) {
			Allocator::deallocate( m_data, m_capacity );
			m_capacity = other.m_capacity;
			m_data = Allocator::allocate( m_capacity );
		}
		m_end = m_data + other.size();

		construct( other );
	}
	return *this;
}
#endif
};

/// \brief Returns true if \p self is lexicographically less than \p other.
template<typename Type>
inline bool operator<( const Stack<Type>& self, const Stack<Type>& other ){
	return std::lexicographical_compare( self.begin(), self.end(), other.begin(), other.end() );
}

namespace std
{
/// \brief Swaps the values of \p self and \p other.
/// Overloads std::swap().
template<typename Type>
inline void swap( Stack<Type>& self, Stack<Type>& other ){
	self.swap( other );
}
}

#endif
