King_DuckZ/DoorKeeper
1
0
Fork 0
Code Issues Pull requests Releases Wiki Activity

Clean up and handle endianness.

Browse source
This commit is contained in:
King_DuckZ 2015-06-04 20:59:07 +02:00
parent f1a6cac62b
commit 12db1d9638
2 changed files with 93 additions and 21 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

16
include/doorkeeper/helpers/tylermapsource.hpp
View file

@ -12,6 +12,10 @@
#include <ciso646>
#include <exception>
#if !defined(NDEBUG) && !defined(WITH_TYLERMAP_WRITER)
# define WITH_TYLERMAP_WRITER
#endif
namespace dkh {
template <typename T, uint32_t D>
class TylerMapSource : public dk::BaseMapSource<T, D> {
@ -43,6 +47,18 @@ namespace dkh {
std::unique_ptr<std::istream> m_stream;
};
#if defined(WITH_TYLERMAP_WRITER)
class TylerMapWriter {
public:
TylerMapWriter ( void ) = delete;
TylerMapWriter ( const TylerMapWriter& ) = delete;
TylerMapWriter ( TylerMapWriter&& ) = default;
private:
std::unique_ptr<std::ostream> m_stream;
};
#endif
class InvalidMapFileException : public std::exception {
};

98
src/tylermapsource.cpp
View file

@ -1,4 +1,5 @@
#include "doorkeeper/helpers/tylermapsource.hpp"
#include <limits>
#if defined(__GNUC__)
# include <endian.h>
@ -31,34 +32,94 @@ namespace dkh {
namespace {
const uint32_t g_signature = 0x52504B44; //DKPR
uint32_t read_uint32 (std::istream& parStream, uint32_t parMax=0xFFFFFFFF) {
uint32_t retval;
#if __BYTE_ORDER == __LITTLE_ENDIAN
parStream.read(reinterpret_cast<char*>(&retval), sizeof(uint32_t));
#else
# error "Unknown endianness, please write the implementation"
template <typename T> T lil_endian_to_machine ( T parIn ) a_pure;
template<> uint32_t lil_endian_to_machine ( uint32_t parIn ) a_pure;
template<> uint16_t lil_endian_to_machine ( uint16_t parIn ) a_pure;
template<> uint8_t lil_endian_to_machine ( uint8_t parIn ) a_pure;
template<> implem::TylerMapHeader lil_endian_to_machine ( implem::TylerMapHeader parIn ) a_pure;
#if defined(WITH_TYLERMAP_WRITER)
template <typename T> T machine_to_lil_endian ( T parIn ) a_pure;
template<> uint32_t machine_to_lil_endian ( uint32_t parIn ) a_pure;
template<> uint16_t machine_to_lil_endian ( uint16_t parIn ) a_pure;
template<> uint8_t machine_to_lil_endian ( uint8_t parIn ) a_pure;
template<> implem::TylerMapHeader machine_to_lil_endian ( implem::TylerMapHeader parIn ) a_pure;
#endif
template<> uint32_t lil_endian_to_machine (uint32_t parIn) { return le32toh(parIn); }
template<> uint16_t lil_endian_to_machine (uint16_t parIn) { return le16toh(parIn); }
template<> uint8_t lil_endian_to_machine (uint8_t parIn) { return parIn; }
template<> implem::TylerMapHeader lil_endian_to_machine (implem::TylerMapHeader parIn) {
parIn.signature = lil_endian_to_machine(parIn.signature);
parIn.file_size = lil_endian_to_machine(parIn.file_size);
parIn.version_major = lil_endian_to_machine(parIn.version_major);
parIn.version_minor = lil_endian_to_machine(parIn.version_minor);
parIn.layer_count = lil_endian_to_machine(parIn.layer_count);
parIn.map_type = lil_endian_to_machine(parIn.map_type);
parIn.map_info_type = lil_endian_to_machine(parIn.map_info_type);
parIn.dimensions = lil_endian_to_machine(parIn.dimensions);
return parIn;
}
#if defined(WITH_TYLERMAP_WRITER)
template<> uint32_t machine_to_lil_endian (uint32_t parIn) { return htole32(parIn); }
template<> uint16_t machine_to_lil_endian (uint16_t parIn) { return htole16(parIn); }
template<> uint8_t machine_to_lil_endian (uint8_t parIn) { return parIn; }
template<> implem::TylerMapHeader machine_to_lil_endian (implem::TylerMapHeader parIn) {
parIn.signature = machine_to_lil_endian(parIn.signature);
parIn.file_size = machine_to_lil_endian(parIn.file_size);
parIn.version_major = machine_to_lil_endian(parIn.version_major);
parIn.version_minor = machine_to_lil_endian(parIn.version_minor);
parIn.layer_count = machine_to_lil_endian(parIn.layer_count);
parIn.map_type = machine_to_lil_endian(parIn.map_type);
parIn.map_info_type = machine_to_lil_endian(parIn.map_info_type);
parIn.dimensions = machine_to_lil_endian(parIn.dimensions);
return parIn;
}
#endif
template <typename T>
T read_int (std::istream& parStream, T parMax=std::numeric_limits<T>::max()) {
T retval;
parStream.read(reinterpret_cast<char*>(&retval), sizeof(T));
retval = lil_endian_to_machine(retval);
if (retval > parMax)
throw InvalidMapFileException();
return retval;
}
std::string& read_string (std::istream& parStream, std::string& parString, uint32_t parLength) {
std::string& read_string (std::istream& parStream, std::string& parString) {
const uint32_t max_string_length = 1024 * 2;
const uint32_t len = std::min(read_int<uint32_t>(parStream), max_string_length);
std::istream_iterator<char> itstream(parStream);
parString.resize(parLength);
std::copy_n(itstream, parLength, std::insert_iterator<std::string>(parString, parString.begin()));
parString.resize(len);
std::copy_n(itstream, len, std::insert_iterator<std::string>(parString, parString.begin()));
return parString;
}
#if defined(WITH_TYLERMAP_WRITER)
template <typename T>
void write_int (std::ostream& parStream, T parValue) {
parValue = machine_to_lil_endian(parValue);
parStream.write(reinterpret_cast<const char*>(&parValue), sizeof(T));
}
void write_string (std::ostream& parStream, const std::string& parString) {
const uint32_t len = static_cast<uint32_t>(parString.size());
write_int<uint32_t>(parStream, len);
parStream.write(parString.c_str(), parString.size());
}
#endif
} //unnamed namespace
namespace implem {
void read_header (std::istream& parStream, TylerMapHeader& parHeader) {
#if __BYTE_ORDER == __LITTLE_ENDIAN
parStream.read(reinterpret_cast<char*>(&parHeader), sizeof(TylerMapHeader));
#else
# error "Unknown endianness, please write the implementation"
#endif
parHeader = lil_endian_to_machine(parHeader);
if (g_signature != parHeader.signature)
throw InvalidMapFileException();
}
@ -66,18 +127,13 @@ namespace dkh {
void read_comments (std::istream& parStream, std::string& parVendor, CommentMap& parComments) {
//Technically there is no limit on strings other than the uint32
//max value, but wth
const uint32_t max_string_length = 1024 * 2;
const uint32_t max_entries = 200;
{
const uint32_t vendor_length = read_uint32(parStream, max_string_length);
read_string(parStream, parVendor, vendor_length);
}
const uint32_t list_length = read_uint32(parStream, max_entries);
read_string(parStream, parVendor);
const uint32_t list_length = read_int<uint32_t>(parStream, max_entries);
std::string full_string;
for (uint32_t z = 0; z < list_length; ++z) {
const uint32_t string_length = read_uint32(parStream, max_string_length);
read_string(parStream, full_string, string_length);
read_string(parStream, full_string);
auto equal_pos = full_string.find('=');
if (std::string::npos == equal_pos)
throw InvalidMapFileException();