/** @file @brief Data.hppの実装を記述する。 */
#include <apcl/util/Data.hpp>

//-----------------------------------------------------------
#include <cassert>
#include <cstring>

//-----------------------------------------------------------
using namespace ::apcl::util;
using namespace ::std;

//-----------------------------------------------------------
Data::Data(void):
bytes_(0),
length_(0)
{
}

//-----------------------------------------------------------
Data::Data( const Data& aData ):
bytes_(0),
length_(0)
{
	init( aData.bytes() , aData.length() );
}

//-----------------------------------------------------------
Data::Data( const void* const aBytes , const u32 aLength ):
bytes_(0),
length_(0)
{
  init( aBytes , aLength );
}

//-----------------------------------------------------------
Data::~Data()
{
	_releaseBytes();
}

//-----------------------------------------------------------
void Data::init( const void* const aBytes , const u32 aLength )
{
	_releaseBytes();
  bytes_ = new byte[aLength];
	length_ = aLength;
	memcpy( bytes_ , aBytes , aLength );
}

//-----------------------------------------------------------
void Data::resize( const u32 aSize )
{
	// メモ
	byte* preBytes = bytes_;
	u32 preLength = length_;

	// 新領域確保
	if ( aSize > 0 )
		bytes_ = new byte[aSize];
	else
		bytes_ = 0;
	length_ = aSize;

	// コピー or 0セット
	if ( length_ > 0 ) 
	{
		if ( preLength > 0 )
		{// 前の内容をコピー
			const u32 size = preLength < length_ ? preLength : length_;
			memcpy( bytes_ , preBytes, size );
		}
		else 
		{// 0をセット
			memset( bytes_ , 0 , length_ );
		}
	}

	if ( length_ > preLength )
	{// 前の長さより長ければ，追加分を0で埋める。
		memset( &bytes_[preLength] , 0 , length_ - preLength );
	}

	// 前領域解放
	delete[] preBytes;

}

//-----------------------------------------------------------
void Data::push( const Data& aData )
{
	assert( aData.length() > 0 );
	resize( length_ + aData.length() );
	memcpy( &bytes_[length_] , aData.bytes() , aData.length() );
}

//-----------------------------------------------------------
void Data::pop( const u32 aLength )
{
	assert( aLength > 0 );
	assert( aLength <= length_ );
	resize( length_ - aLength );
}

//-----------------------------------------------------------
bool Data::equals( const Data& aData )const
{
	if ( length_ == aData.length() )
		return ( memcmp( bytes_ , aData.bytes() , length_ ) == 0 );
	return false;
}

//-----------------------------------------------------------
byte& Data::at( const u32 aIndex )
{
	assert( aIndex > 0 && aIndex <= length_ );
	return bytes_[aIndex];
}

//-----------------------------------------------------------
byte Data::at( const u32 aIndex )const
{
	assert( aIndex > 0 && aIndex <= length_ );
	return bytes_[aIndex];
}

//-----------------------------------------------------------
byte* Data::bytes()
{
	return bytes_;
}

//-----------------------------------------------------------
const byte* Data::bytes()const
{
	return bytes_;
}

//-----------------------------------------------------------
u32 Data::length()const
{
	return length_;
}

//-----------------------------------------------------------
const Data& Data::operator +=( const Data& aData )
{
	push( aData );
	return *this;
}

//-----------------------------------------------------------
byte& Data::operator []( const u32 aIndex )
{
	return at( aIndex );
}

//-----------------------------------------------------------
byte Data::operator []( const u32 aIndex )const
{
	return at( aIndex );
}

//-----------------------------------------------------------
bool Data::operator ==( const Data& aData )const
{
	return equals( aData );
}

//-----------------------------------------------------------
const Data& Data::operator =( const Data& aData )
{
	init( aData.bytes() , aData.length() );
	return *this;
}


//-----------------------------------------------------------
void Data::_releaseBytes()
{
	if ( bytes_ )
	{
		delete[] bytes_;
		bytes_ = 0;
		length_ = 0;
	}
}