/*]  Copyright (c) 2009-2010, Charles McGarvey  [**************************
**]  All rights reserved.
*
* vi:ts=4 sw=4 tw=75
*
* Distributable under the terms and conditions of the 2-clause BSD license;
* see the file COPYING for a complete text of the license.
*
**************************************************************************/

#ifndef _MOOF_PACKET_HH_
#define _MOOF_PACKET_HH_

#include <cstring>
#include <string>
#include <vector>


#ifndef PAGE_SIZE
#define PAGE_SIZE 4096
#endif


namespace Mf {
	

class Packet
{
public:

	Packet(size_t size = PAGE_SIZE);
	Packet(const char* data, size_t size);

	~Packet();

	Packet& operator<<(bool value);
	Packet& operator<<(int8_t  value);
	Packet& operator<<(int16_t value);
	Packet& operator<<(int32_t value);
	Packet& operator<<(int64_t value);
	Packet& operator<<(uint8_t  value);
	Packet& operator<<(uint16_t value);
	Packet& operator<<(uint32_t value);
	Packet& operator<<(uint64_t value);
	Packet& operator<<(float value);
	Packet& operator<<(double value);

	size_t write(const void* bytes, size_t size);

	Packet& operator>>(bool& value);
	Packet& operator>>(int8_t&  value);
	Packet& operator>>(int16_t& value);
	Packet& operator>>(int32_t& value);
	Packet& operator>>(int64_t& value);
	Packet& operator>>(uint8_t&  value);
	Packet& operator>>(uint16_t& value);
	Packet& operator>>(uint32_t& value);
	Packet& operator>>(uint64_t& value);
	Packet& operator>>(float& value);
	Packet& operator>>(double& value);

	size_t read(void* bytes, size_t size);


	const char* bytes() const
	{
		return mBuffer + mR;
	}

	size_t size() const
	{
		return mW - mR;
	}


private:

	char*	mBuffer;
	size_t	mSize;

	size_t	mR;
	size_t	mW;

	size_t	mBoolR;
	size_t	mBoolW;
	size_t	mBoolNumR;
	size_t	mBoolNumW;
};


inline Packet& operator<<(Packet& packet, const char* value)
{
	uint16_t length = strlen(value);
	packet << length;
	packet.write(value, length);
	return packet;
}

template <class T>
inline Packet& operator<<(Packet& packet, const std::basic_string<T>& value)
{
	packet << (uint16_t)value.length();
	packet.write(value.data(), value.length() * sizeof(T));
	return packet;
}

template <class T>
inline Packet& operator>>(Packet& packet, std::basic_string<T>& value)
{
	uint16_t length = 0;
	packet >> length;

	T str[length];
	size_t charsRead = packet.read(str, length * sizeof(T));
	value.assign(str, charsRead);
	return packet;
}


template <class T>
inline Packet& operator<<(Packet& packet, const std::vector<T>& value)
{
	packet << (uint16_t)value.size();
	typename std::vector<T>::const_iterator it;
	for (it = value.begin(); it != value.end(); ++it)
	{
		packet << *it;
	}
	return packet;
}

template <class T>
inline Packet& operator>>(Packet& packet, std::vector<T>& value)
{
	uint16_t size = 0;
	packet >> size;

	value.clear();
	for (uint16_t i = 0; i < size; ++i)
	{
		T item;
		packet >> item;
		value.push_back(item);
	}
	return packet;
}


} // namespace Mf

#endif // _MOOF_PACKET_HH_