/*
Copyright (C) 2012 Jonas Penno
This program 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 3 of the License,
or any later version.
This program 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 this program. If not, see http://www.gnu.org/licenses.
The Boost C++ Libraries are distributed under the Boost Software License, Version 1.0.
See also http://www.boost.org/LICENSE_1_0.txt.
***********************************************************
** Codename Visual Dragon++ **
** Version: 1.0 Beta **
** Copyright (c) 2012 Jonas Penno **
** GNU General Public License **
** Boost C++ Libraries **
** http://cvd-project.org **
***********************************************************
*/
#include "BitConverter.hpp"
namespace Codename_Visual_Dragon
{
char BitConverter::GetHexValue(boost::int32_t Value)
{
if (Value < 10)
return (char)(Value + 0x30);
return (char)((Value - 10) + 0x41);
};
boost::int32_t BitConverter::FloatToInt32Bits(float Value)
{
return *(((boost::int32_t*)&Value));
};
boost::int64_t BitConverter::DoubleToInt64Bits(double Value)
{
return *(((boost::int64_t*)&Value));
};
char* BitConverter::GetBytes(bool Value)
{
char BoolAlpha[1] = { (Value ? ((char)1) : ((char)0)) };
return BoolAlpha;
};
char* BitConverter::GetBytes(float Value)
{
return GetBytes(*((boost::int32_t*)&Value));
};
char* BitConverter::GetBytes(double Value)
{
return GetBytes(*((boost::int64_t*)&Value));
};
char* BitConverter::GetBytes(boost::int16_t Value)
{
char* Buffer = new char[2];
*((boost::int16_t*)Buffer) = Value;
return Buffer;
};
char* BitConverter::GetBytes(boost::int32_t Value)
{
char* Buffer = new char[4];
*((boost::int32_t*)Buffer) = Value;
return Buffer;
};
char* BitConverter::GetBytes(boost::int64_t Value)
{
char* Buffer = new char[8];
*((boost::int64_t*)Buffer) = Value;
return Buffer;
};
char* BitConverter::GetBytes(boost::uint16_t Value)
{
return GetBytes((boost::int16_t)Value);
};
char* BitConverter::GetBytes(boost::uint32_t Value)
{
return GetBytes((boost::int32_t)Value);
};
char* BitConverter::GetBytes(boost::uint64_t Value)
{
return GetBytes((boost::int64_t)Value);
};
float BitConverter::Int32BitsToFloat(boost::int32_t Value)
{
return *(((float*)&Value));
};
double BitConverter::Int64BitsToDouble(boost::int64_t Value)
{
return *(((double*)&Value));
};
bool BitConverter::ToBoolean(char* Value, boost::uint32_t StartIndex)
{
if (Value == nullptr)
return 0;
if (StartIndex < 0)
return false;
if (StartIndex > (sizeof(Value) - 1))
return false;
return (Value[StartIndex] != 0);
};
float BitConverter::ToFloat(char* Value, boost::uint32_t StartIndex)
{
if (Value == nullptr)
return 0;
boost::int32_t IValue = ToInt32(Value, StartIndex);
return *(((float*)&IValue));
};
double BitConverter::ToDouble(char* Value, boost::uint32_t StartIndex)
{
if (Value == nullptr)
return 0;
boost::int64_t IValue = ToInt64(Value, StartIndex);
return *(((double*)&IValue));
};
boost::int16_t BitConverter::ToInt16(char* Value, boost::uint32_t StartIndex)
{
if (Value == nullptr)
return 0;
if (StartIndex >= sizeof(Value))
return 0;
if (StartIndex > (sizeof(Value) - 2))
return 0;
char* Buffer = &(Value[StartIndex]);
if ((StartIndex % 2) == 0)
return *(((boost::int16_t*)Buffer));
#if defined(LITTLE_ENDIAN)
return (boost::int16_t)(Buffer[0] | (Buffer[1] << 8));
#else
return (boost::int16_t)((Buffer[0] << 8) | Buffer[1]);
#endif
};
boost::int32_t BitConverter::ToInt32(char* Value, boost::uint32_t StartIndex)
{
if (Value == nullptr)
return 0;
if (StartIndex >= sizeof(Value))
return 0;
if (StartIndex > (sizeof(Value) - 4))
return 0;
char* Buffer = &(Value[StartIndex]);
if ((StartIndex % 4) == 0)
return *(((boost::int32_t*)Buffer));
#if defined(LITTLE_ENDIAN)
return (boost::int32_t)(((Buffer[0] | (Buffer[1] << 8)) | (Buffer[2] << 0x10)) | (Buffer[3] << 0x18));
#else
return (boost::int32_t)((((Buffer[0] << 0x18) | (Buffer[1] << 0x10)) | (Buffer[2] << 8)) | Buffer[3]);
#endif
};
boost::int64_t BitConverter::ToInt64(char* Value, boost::uint32_t StartIndex)
{
if (Value == nullptr)
return 0;
if (StartIndex >= sizeof(Value))
return 0;
if (StartIndex > (sizeof(Value) - 8))
return 0;
char* Buffer = &(Value[StartIndex]);
if ((StartIndex % 8) == 0)
return *(((boost::int64_t*) Buffer));
#if defined(LITTLE_ENDIAN)
boost::int32_t Num1 = (boost::int32_t)((Buffer[0] | (Buffer[1] << 8)) | (Buffer[2] << 0x10)) | (Buffer[3] << 0x18);
boost::int32_t Num2 = (boost::int32_t)((Buffer[4] | (Buffer[5] << 8)) | (Buffer[6] << 0x10)) | (Buffer[7] << 0x18);
return (((boost::int64_t)((boost::uint64_t)Num1)) | (Num2 << 0x20));
#else
boost::int32_t Num3 = (boost::int32_t)(((Buffer[0] << 0x18) | (Buffer[1] << 0x10)) | (Buffer[2] << 8)) | Buffer[3];
boost::int32_t Num4 = (boost::int32_t)(((Buffer[4] << 0x18) | (Buffer[5] << 0x10)) | (Buffer[6] << 8)) | Buffer[7];
return (((boost::int64_t)((boost::uint64_t)Num4)) | (Num3 << 0x20));
#endif
};
boost::uint16_t BitConverter::ToUInt16(char* Value, boost::uint32_t StartIndex)
{
return (boost::uint16_t)ToInt16(Value, StartIndex);
};
boost::uint32_t BitConverter::ToUInt32(char* Value, boost::uint32_t StartIndex)
{
return (boost::uint32_t)ToInt32(Value, StartIndex);
};
boost::uint64_t BitConverter::ToUInt64(char* Value, boost::uint32_t StartIndex)
{
return (boost::uint64_t)ToInt64(Value, StartIndex);
};
};
