#ifndef INCLUDE_UTIL_H
#define INCLUDE_UTIL_H

// util.h
// Revision 24-apr-2009

#include <string>
#include <sstream>
#include <stdexcept>
#include <iostream>

#include <stdlib.h>

#ifdef __BORLANDC__
#pragma warn -8027
#endif

namespace util {

inline std::string stringlset (const std::string & value,
	std::string::size_type l)
{
	const std::string::size_type lvalue= value.size ();
	if (lvalue < l)
		return value + std::string (l - lvalue, ' ');
	else if (lvalue > l)
		return value.substr (0, l);
	else
		return value;
}

inline std::string stringrset (const std::string & value,
	std::string::size_type l)
{
	const std::string::size_type lvalue= value.size ();
	if (lvalue < l)
		return std::string (l - lvalue, ' ') + value;
	else if (lvalue > l)
		return value.substr (0, l);
	else
		return value;
}

template <class DEST, class ORG, class EX>
DEST checked_cast (ORG org, EX ex)
{
	DEST dest= static_cast <DEST> (org);
	if (static_cast <ORG> (dest) != org)
		throw ex;
	return dest;
}

template <class C, size_t N>
size_t dim_array (C (&) [N])
{ return N; }

template <class C, size_t N>
size_t dim_array (const C (&) [N])
{ return N; }

template <class C>
class auto_buffer
{
public:
	auto_buffer (size_t ns) :
		p (new C [ns]),
		s (ns)
	{ }
	auto_buffer () : p (0) { }
	~auto_buffer ()
	{ delete [] p; }
	void release () { p= 0; }
	void alloc (size_t ns)
	{
		delete [] p;
		p= new C [ns];
		s= ns;
	}
	operator C * () { return p; }
	typedef C * iterator;
	iterator begin () { return p; }
	iterator end () { return p + s; }
	// We define data for commodity, and better legibility
	// than begin where not used as iterator.
	C * data () { return p; }
private:
	auto_buffer (const auto_buffer &); // Forbidden
	auto_buffer & operator = (const auto_buffer &); // Forbidden
	C * p;
	size_t s;
};

template <class C>
class auto_alloc
{
public:
	auto_alloc (size_t size) :
		p (static_cast <C *> (malloc (size * sizeof (C) ) ) )
	{
		if (p == 0)
			throw std::bad_alloc ();
	}
	~auto_alloc ()
	{ free (p); }
	void release () { p= 0; }
	operator C * () { return p; }
	C * data () { return p; } // Commodity when cast is needed
private:
	auto_alloc (const auto_alloc &); // Forbidden
	auto_alloc & operator = (const auto_alloc &); // Forbidden
	C * p;
};

// This template is intended for use as a pointer to a
// private implementation that translates the constness of
// the operations in the main class to the implementation.

template <class C>
class pimpl_ptr
{
public:
	pimpl_ptr (C * ptr) :
		p (ptr)
	{ }
	~pimpl_ptr ()
	{
		delete p;
	}

	// Bypass the acces control
	C * get () const
	{ return p; }

	// The dereference operator that preserves constness.
	C & operator * ()
	{ return * p; }
	const C & operator * () const
	{ return * p; }
	C * operator -> ()
	{ return p; }
	const C * operator -> () const
	{
		return p;
	}
private:
	pimpl_ptr (const pimpl_ptr &); // Forbidden
	pimpl_ptr & operator = (const pimpl_ptr &); // Forbidden
	C * const p;
};

template <class C>
std::string to_string (const C & c)
{
	std::ostringstream oss;
	oss << c;
	return oss.str ();
}

// Functions used to avoid warnings about unused parameters.

template <class T>
inline void touch (const T & t)
{
	(void) t;
}
template <class T1, class T2>
inline void touch (const T1 & t1, const T2 & t2)
{
	(void) t1; (void) t2;
}
template <class T1, class T2, class T3>
inline void touch (const T1 & t1, const T2 & t2, const T3 & t3)
{
	(void) t1; (void) t2; (void) t3;
}
template <class T1, class T2, class T3, class T4>
inline void touch (const T1 & t1, const T2 & t2, const T3 & t3,
	const T4 & t4)
{
	(void) t1; (void) t2; (void) t3;
	(void) t4;
}
template <class T1, class T2, class T3, class T4, class T5>
inline void touch (const T1 & t1, const T2 & t2, const T3 & t3,
	const T4 & t4, const T5 & t5)
{
	(void) t1; (void) t2; (void) t3;
	(void) t4; (void) t5;
}
template <class T1, class T2, class T3, class T4, class T5, class T6>
inline void touch (const T1 & t1, const T2 & t2, const T3 & t3,
	const T4 & t4, const T5 & t5, const T6 & t6)
{
	(void) t1; (void) t2; (void) t3;
	(void) t4; (void) t5; (void) t6;
}

} // namespace

#endif

// End of util.h