2012-07-11 18:50:42 +00:00
|
|
|
// * This file is part of the COLOBOT source code
|
|
|
|
// * Copyright (C) 2012, Polish Portal of Colobot (PPC)
|
|
|
|
// *
|
|
|
|
// * 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
|
|
|
|
// * (at your option) 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/.
|
|
|
|
|
2012-09-09 15:51:10 +00:00
|
|
|
/**
|
2012-10-17 19:55:45 +00:00
|
|
|
* \file common/ioutils.h
|
2012-09-09 15:51:10 +00:00
|
|
|
* \brief Functions for binary I/O
|
|
|
|
*/
|
2012-07-11 18:50:42 +00:00
|
|
|
|
|
|
|
#pragma once
|
|
|
|
|
|
|
|
|
|
|
|
#include <iostream>
|
|
|
|
|
2012-07-30 20:59:18 +00:00
|
|
|
#include <cstring>
|
2012-07-11 18:50:42 +00:00
|
|
|
|
|
|
|
namespace IOUtils {
|
|
|
|
|
|
|
|
//! Writes a binary number to output stream
|
|
|
|
/**
|
2012-08-31 18:55:16 +00:00
|
|
|
* \c T is a numeric type (int, unsigned int, etc.)
|
|
|
|
* \c N is number of bytes
|
|
|
|
* Write order is little-endian
|
|
|
|
*/
|
2012-07-11 18:50:42 +00:00
|
|
|
template<int N, typename T>
|
|
|
|
void WriteBinary(T value, std::ostream &ostr)
|
|
|
|
{
|
|
|
|
for (int i = 0; i < N; ++i)
|
|
|
|
{
|
|
|
|
unsigned char byte = (value >> (i*8)) & 0xFF;
|
2012-07-30 20:59:18 +00:00
|
|
|
ostr.write(reinterpret_cast<char*>(&byte), 1);
|
2012-07-11 18:50:42 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//! Reads a binary number from input stream
|
|
|
|
/**
|
2012-08-31 18:55:16 +00:00
|
|
|
* \c T is a numeric type (int, unsigned int, etc.)
|
|
|
|
* \c N is number of bytes
|
|
|
|
* Read order is little-endian
|
|
|
|
*/
|
2012-07-11 18:50:42 +00:00
|
|
|
template<int N, typename T>
|
|
|
|
T ReadBinary(std::istream &istr)
|
|
|
|
{
|
|
|
|
T value = 0;
|
|
|
|
for (int i = 0; i < N; ++i)
|
|
|
|
{
|
|
|
|
unsigned char byte = 0;
|
2012-07-30 20:59:18 +00:00
|
|
|
istr.read(reinterpret_cast<char*>(&byte), 1);
|
2012-07-11 18:50:42 +00:00
|
|
|
value |= byte << (i*8);
|
|
|
|
}
|
|
|
|
return value;
|
|
|
|
}
|
|
|
|
|
2012-08-31 18:55:16 +00:00
|
|
|
//! Writes a binary 1-byte boolean
|
|
|
|
/**
|
|
|
|
* false is 0; true is 1.
|
|
|
|
*/
|
|
|
|
void WriteBinaryBool(float value, std::ostream &ostr)
|
|
|
|
{
|
|
|
|
unsigned char v = value ? 1 : 0;
|
|
|
|
IOUtils::WriteBinary<1, unsigned char>(v, ostr);
|
|
|
|
}
|
|
|
|
|
|
|
|
//! Reads a binary 1-byte boolean
|
|
|
|
/**
|
|
|
|
* 0 is false; other values are true.
|
|
|
|
*/
|
|
|
|
bool ReadBinaryBool(std::istream &istr)
|
|
|
|
{
|
|
|
|
int v = IOUtils::ReadBinary<1, unsigned char>(istr);
|
|
|
|
return v != 0;
|
|
|
|
}
|
|
|
|
|
2012-07-11 18:50:42 +00:00
|
|
|
//! Writes a binary 32-bit float to output stream
|
|
|
|
/**
|
2012-08-31 18:55:16 +00:00
|
|
|
* Write order is little-endian
|
|
|
|
* NOTE: code is probably not portable as there are platforms with other float representations.
|
|
|
|
*/
|
2012-07-11 18:50:42 +00:00
|
|
|
void WriteBinaryFloat(float value, std::ostream &ostr)
|
|
|
|
{
|
2012-07-30 20:59:18 +00:00
|
|
|
union { float fValue; unsigned int iValue; } u;
|
|
|
|
memset(&u, 0, sizeof(u));
|
|
|
|
u.fValue = value;
|
|
|
|
IOUtils::WriteBinary<4, unsigned int>(u.iValue, ostr);
|
2012-07-11 18:50:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
//! Reads a binary 32-bit float from input stream
|
|
|
|
/**
|
2012-08-31 18:55:16 +00:00
|
|
|
* Read order is little-endian
|
|
|
|
* NOTE: code is probably not portable as there are platforms with other float representations.
|
|
|
|
*/
|
2012-07-11 18:50:42 +00:00
|
|
|
float ReadBinaryFloat(std::istream &istr)
|
|
|
|
{
|
2012-07-30 20:59:18 +00:00
|
|
|
union { float fValue; unsigned int iValue; } u;
|
|
|
|
memset(&u, 0, sizeof(u));
|
|
|
|
u.iValue = IOUtils::ReadBinary<4, unsigned int>(istr);
|
|
|
|
return u.fValue;
|
2012-07-11 18:50:42 +00:00
|
|
|
}
|
|
|
|
|
2012-08-31 18:55:16 +00:00
|
|
|
//! Writes a variable binary string to output stream
|
|
|
|
/**
|
|
|
|
* The string is written by first writing string length
|
|
|
|
* in \c N byte binary number and then the string bytes.
|
|
|
|
*/
|
|
|
|
template<int N>
|
|
|
|
void WriteBinaryString(const std::string &value, std::ostream &ostr)
|
|
|
|
{
|
|
|
|
int length = value.size();
|
|
|
|
WriteBinary<N, int>(length, ostr);
|
|
|
|
|
|
|
|
for (int i = 0; i < length; ++i)
|
|
|
|
ostr.put(value[i]);
|
|
|
|
}
|
|
|
|
|
|
|
|
//! Reads a variable binary string from output stream
|
|
|
|
/**
|
|
|
|
* The string is read by first reading string length
|
|
|
|
* in \c N byte binary number and then the string bytes.
|
|
|
|
*/
|
|
|
|
template<int N>
|
|
|
|
std::string ReadBinaryString(std::istream &istr)
|
|
|
|
{
|
|
|
|
int length = ReadBinary<N, int>(istr);
|
|
|
|
|
|
|
|
std::string str;
|
|
|
|
char c = 0;
|
|
|
|
for (int i = 0; i < length; ++i)
|
|
|
|
{
|
|
|
|
istr.read(&c, 1);
|
|
|
|
str += c;
|
|
|
|
}
|
|
|
|
|
|
|
|
return str;
|
|
|
|
}
|
|
|
|
|
2012-07-11 18:50:42 +00:00
|
|
|
}; // namespace IOUtils
|