mirror of https://github.com/libAthena/athena.git
Doc updates
This commit is contained in:
Jack Andersen
parent
1e1adeb2fb
commit
89fa92308f
|
|
@ -34,6 +34,7 @@ struct WStringAsString;
|
|||
|
||||
/**
|
||||
* @brief Base DNA class used against 'atdna'
|
||||
* @tparam DNAE Default-endianness for contained DNA values
|
||||
*
|
||||
* Athena bundles a build-tool called 'atdna'. This tool functions
|
||||
* just like the 'clang' compiler, except it emits a full .cpp implementation
|
||||
|
|
@ -43,36 +44,88 @@ struct WStringAsString;
|
|||
template <Endian DNAE>
|
||||
struct DNA
|
||||
{
|
||||
/**
|
||||
* @brief Common virtual read function for all DNA types
|
||||
*/
|
||||
virtual void read(IStreamReader&)=0;
|
||||
/**
|
||||
* @brief Common virtual write function for all DNA types
|
||||
*/
|
||||
virtual void write(IStreamWriter&) const=0;
|
||||
|
||||
/**
|
||||
* @brief Template type signaling atdna to capture the value where it's used
|
||||
* @tparam T The type of the value. Can be any numeric type or atVec* type
|
||||
* @tparam VE Endianness of the value
|
||||
*/
|
||||
template <typename T, Endian VE = DNAE>
|
||||
using Value = T;
|
||||
|
||||
/**
|
||||
* @brief Template type wrapping std::vector and signaling atdna to manipulate it where it's used
|
||||
* @tparam T The type of contained elements. Can be any numeric type, atVec* type, or another DNA subclass
|
||||
* @tparam cntVar C++ expression wrapped in DNA_COUNT macro to determine number of elements for vector
|
||||
* @tparam VE Endianness of the contained values
|
||||
*/
|
||||
template <typename T, size_t cntVar, Endian VE = DNAE>
|
||||
using Vector = std::vector<T>;
|
||||
|
||||
/**
|
||||
* @brief Template type wrapping std::unique_ptr<atUint8[]> and signaling atdna to read a
|
||||
* raw byte-buffer where it's used
|
||||
* @tparam sizeVar C++ expression wrapped in DNA_COUNT macro to determine number of bytes for buffer
|
||||
*/
|
||||
template <size_t sizeVar>
|
||||
using Buffer = struct Athena::io::Buffer<sizeVar, DNAE>;
|
||||
|
||||
/**
|
||||
* @brief Template type wrapping std::string and signaling atdna to read string data where it's used
|
||||
* @tparam sizeVar C++ expression wrapped in DNA_COUNT macro to determine number of characters for string
|
||||
* -1 literal indicates null-terminated string
|
||||
*/
|
||||
template <atInt32 sizeVar = -1>
|
||||
using String = struct Athena::io::String<sizeVar, DNAE>;
|
||||
|
||||
/**
|
||||
* @brief Template type wrapping std::wstring and signaling atdna to read wstring data where it's used
|
||||
* @tparam sizeVar C++ expression wrapped in DNA_COUNT macro to determine number of characters for wstring
|
||||
* -1 literal indicates null-terminated wstring
|
||||
*/
|
||||
template <atInt32 sizeVar = -1, Endian VE = DNAE>
|
||||
using WString = struct Athena::io::WString<sizeVar, VE>;
|
||||
|
||||
/**
|
||||
* @brief Template type wrapping std::string and signaling atdna to read wstring data where it's used
|
||||
* @tparam sizeVar C++ expression wrapped in DNA_COUNT macro to determine number of characters for string
|
||||
* -1 literal indicates null-terminated string
|
||||
*/
|
||||
template <atInt32 sizeVar = -1>
|
||||
using WStringAsString = struct Athena::io::WStringAsString<sizeVar, DNAE>;
|
||||
|
||||
/**
|
||||
* @brief Meta Template signaling atdna to insert a stream seek where it's used
|
||||
* @tparam offset C++ expression wrapped in DNA_COUNT macro to determine number of bytes to seek
|
||||
* @tparam direction SeekOrigin to seek relative to
|
||||
*/
|
||||
template <off_t offset, SeekOrigin direction>
|
||||
struct Seek {};
|
||||
|
||||
/**
|
||||
* @brief Meta Template signaling atdna to insert an aligning stream seek where it's used
|
||||
* @tparam align Number of bytes to align to
|
||||
*/
|
||||
template <size_t align>
|
||||
struct Align {};
|
||||
|
||||
/**
|
||||
* @brief Meta Template preventing atdna from emitting read/write implementations
|
||||
*/
|
||||
struct Delete {};
|
||||
};
|
||||
|
||||
/**
|
||||
* @brief Concrete buffer type used by DNA::Buffer
|
||||
*/
|
||||
template <size_t sizeVar, Endian VE>
|
||||
struct Buffer : public DNA<VE>, public std::unique_ptr<atUint8[]>
|
||||
{
|
||||
|
|
@ -88,6 +141,9 @@ struct Buffer : public DNA<VE>, public std::unique_ptr<atUint8[]>
|
|||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* @brief Concrete string type used by DNA::String
|
||||
*/
|
||||
template <atInt32 sizeVar, Endian VE>
|
||||
struct String : public DNA<VE>, public std::string
|
||||
{
|
||||
|
|
@ -102,6 +158,9 @@ struct String : public DNA<VE>, public std::string
|
|||
{this->swap(__str); return *this;}
|
||||
};
|
||||
|
||||
/**
|
||||
* @brief Concrete wstring type used by DNA::WString
|
||||
*/
|
||||
template <atInt32 sizeVar, Endian VE>
|
||||
struct WString : public DNA<VE>, public std::wstring
|
||||
{
|
||||
|
|
@ -122,6 +181,9 @@ struct WString : public DNA<VE>, public std::wstring
|
|||
{this->swap(__str); return *this;}
|
||||
};
|
||||
|
||||
/**
|
||||
* @brief Concrete converting-wstring type used by DNA::WStringAsString
|
||||
*/
|
||||
template <atInt32 sizeVar, Endian VE>
|
||||
struct WStringAsString : public DNA<VE>, public std::string
|
||||
{
|
||||
|
|
|
|||
|
|
@ -15,86 +15,86 @@ class IStreamReader : public IStream
|
|||
public:
|
||||
virtual ~IStreamReader() {}
|
||||
|
||||
/*! \brief Sets the Endianness of the stream
|
||||
/** @brief Sets the Endianness of the stream
|
||||
*
|
||||
* \param endian The Endianness to set \sa Endian
|
||||
* @param endian The Endianness to set
|
||||
*/
|
||||
inline void setEndian(Endian endian)
|
||||
{m_endian = endian;}
|
||||
|
||||
/*! \brief Returns the current Endianness of the stream
|
||||
/** @brief Returns the current Endianness of the stream
|
||||
*
|
||||
* \return Endian The current Stream Endianness
|
||||
* @return The current Stream Endianness
|
||||
*/
|
||||
inline Endian endian() const
|
||||
{return m_endian;}
|
||||
|
||||
/*! \brief Returns whether the stream is BigEndian
|
||||
/** @brief Returns whether the stream is BigEndian
|
||||
*
|
||||
* \return bool True for BigEndian; False for LittleEndian
|
||||
* @return bool True for BigEndian; False for LittleEndian
|
||||
*/
|
||||
inline bool isBigEndian() const
|
||||
{return (m_endian == Endian::BigEndian);}
|
||||
|
||||
/*! \brief Returns whether the stream is LittleEndian
|
||||
/** @brief Returns whether the stream is LittleEndian
|
||||
*
|
||||
* \return bool True for LittleEndian; False for BigEndian
|
||||
* @return True for LittleEndian; False for BigEndian
|
||||
*/
|
||||
inline bool isLittleEndian()const
|
||||
{return (m_endian == Endian::LittleEndian);}
|
||||
|
||||
|
||||
/*! \brief Sets the buffers position relative to the specified position.<br />
|
||||
/** @brief Sets the buffers position relative to the specified position.<br />
|
||||
* It seeks relative to the current position by default.
|
||||
* \param position where in the buffer to seek
|
||||
* \param origin The Origin to seek \sa SeekOrigin
|
||||
* @param position where in the buffer to seek
|
||||
* @param origin The Origin to seek relative to
|
||||
*/
|
||||
virtual void seek(atInt64 pos, SeekOrigin origin = SeekOrigin::Current)=0;
|
||||
|
||||
/*! \brief Sets the buffers position relative to the next 32-byte aligned position.<br />
|
||||
/** @brief Sets the buffers position relative to the next 32-byte aligned position.<br />
|
||||
*/
|
||||
inline void seekAlign32() {seek(ROUND_UP_32(position()), SeekOrigin::Begin);}
|
||||
|
||||
/*! \brief Returns whether or not the stream is at the end.
|
||||
/** @brief Returns whether or not the stream is at the end.
|
||||
*
|
||||
* \return bool True if at end; False otherwise.
|
||||
* @return True if at end; False otherwise.
|
||||
*/
|
||||
inline bool atEnd() const
|
||||
{return position() >= length();}
|
||||
|
||||
/*! \brief Returns the current position in the stream.
|
||||
/** @brief Returns the current position in the stream.
|
||||
*
|
||||
* \return Int64 The current position in the stream.
|
||||
* @return The current position in the stream.
|
||||
*/
|
||||
virtual atUint64 position() const=0;
|
||||
|
||||
/*! \brief Returns whether or not the stream is at the end.
|
||||
/** @brief Returns whether or not the stream is at the end.
|
||||
*
|
||||
* \return bool True if at end; False otherwise.
|
||||
* @return True if at end; False otherwise.
|
||||
*/
|
||||
virtual atUint64 length() const=0;
|
||||
|
||||
/*! \brief Reads a byte at the current position and advances the current position
|
||||
/** @brief Reads a byte at the current position and advances the current position
|
||||
*
|
||||
* \return Int8 The value at the current position
|
||||
* @return The value at the current position
|
||||
*/
|
||||
inline atInt8 readByte() {atInt8 val; readUBytesToBuf(&val, 1); return val;}
|
||||
template <class T>
|
||||
inline atInt8 readVal(typename std::enable_if<std::is_same<T, atInt8>::value>::type* = 0)
|
||||
{return readByte();}
|
||||
|
||||
/*! \brief Reads a byte at the current position and advances the current position
|
||||
/** @brief Reads a byte at the current position and advances the current position
|
||||
*
|
||||
* \return Uint8 The value at the current position
|
||||
* @return The value at the current position
|
||||
*/
|
||||
inline atUint8 readUByte() {return readByte();}
|
||||
template <class T>
|
||||
inline atUint8 readVal(typename std::enable_if<std::is_same<T, atUint8>::value>::type* = 0)
|
||||
{return readUByte();}
|
||||
|
||||
/*! \brief Reads a byte at the current position and advances the current position.
|
||||
/** @brief Reads a byte at the current position and advances the current position.
|
||||
*
|
||||
* \return Uint8* The buffer at the current position from the given length.
|
||||
* @return The buffer at the current position from the given length.
|
||||
*/
|
||||
inline std::unique_ptr<atInt8[]> readBytes(atUint64 length)
|
||||
{
|
||||
|
|
@ -103,9 +103,9 @@ public:
|
|||
return std::unique_ptr<atInt8[]>(buf);
|
||||
}
|
||||
|
||||
/*! \brief Reads a byte at the current position and advances the current position.
|
||||
/** @brief Reads a byte at the current position and advances the current position.
|
||||
*
|
||||
* \return Int8* The buffer at the current position from the given length.
|
||||
* @return The buffer at the current position from the given length.
|
||||
*/
|
||||
inline std::unique_ptr<atUint8[]> readUBytes(atUint64 length)
|
||||
{
|
||||
|
|
@ -117,13 +117,10 @@ public:
|
|||
inline atUint64 readBytesToBuf(void* buf, atUint64 len) {return readUBytesToBuf(buf, len);}
|
||||
virtual atUint64 readUBytesToBuf(void* buf, atUint64 len)=0;
|
||||
|
||||
/*! \brief Reads a Int16 and swaps to proper endianness depending on platform
|
||||
* and Stream settings, and advances the current position
|
||||
/** @brief Reads a Int16 and swaps to endianness specified by setEndian depending on platform
|
||||
* and advances the current position
|
||||
*
|
||||
* \sa Endian
|
||||
*
|
||||
* \return Int16 The value at the current address
|
||||
* \throw IOException when address is out of range
|
||||
* @return The value at the current address
|
||||
*/
|
||||
inline atInt16 readInt16()
|
||||
{
|
||||
|
|
@ -135,6 +132,11 @@ public:
|
|||
inline atInt16 readVal(typename std::enable_if<std::is_same<T, atInt16>::value>::type* = 0)
|
||||
{return readInt16();}
|
||||
|
||||
/** @brief Reads a Int16 and swaps against little endianness depending on platform
|
||||
* and advances the current position
|
||||
*
|
||||
* @return The value at the current address
|
||||
*/
|
||||
inline atInt16 readInt16Little()
|
||||
{
|
||||
atInt16 val;
|
||||
|
|
@ -145,6 +147,11 @@ public:
|
|||
inline atInt16 readValLittle(typename std::enable_if<std::is_same<T, atInt16>::value>::type* = 0)
|
||||
{return readInt16Little();}
|
||||
|
||||
/** @brief Reads a Int16 and swaps against big endianness depending on platform
|
||||
* and advances the current position
|
||||
*
|
||||
* @return The value at the current address
|
||||
*/
|
||||
inline atInt16 readInt16Big()
|
||||
{
|
||||
atInt16 val;
|
||||
|
|
@ -155,13 +162,10 @@ public:
|
|||
inline atInt16 readValBig(typename std::enable_if<std::is_same<T, atInt16>::value>::type* = 0)
|
||||
{return readInt16Big();}
|
||||
|
||||
/*! \brief Reads a Uint16 and swaps to proper endianness depending on platform
|
||||
* and Stream settings, and advances the current position
|
||||
/** @brief Reads a Uint16 and swaps to endianness specified by setEndian depending on platform
|
||||
* and advances the current position
|
||||
*
|
||||
* \sa Endian
|
||||
*
|
||||
* \return Uint16 The value at the current address
|
||||
* \throw IOException when address is out of range
|
||||
* @return The value at the current address
|
||||
*/
|
||||
inline atUint16 readUint16()
|
||||
{return readInt16();}
|
||||
|
|
@ -169,6 +173,11 @@ public:
|
|||
inline atUint16 readVal(typename std::enable_if<std::is_same<T, atUint16>::value>::type* = 0)
|
||||
{return readUint16();}
|
||||
|
||||
/** @brief Reads a Uint16 and swaps against little endianness depending on platform
|
||||
* and advances the current position
|
||||
*
|
||||
* @return The value at the current address
|
||||
*/
|
||||
inline atUint16 readUint16Little()
|
||||
{
|
||||
atUint16 val;
|
||||
|
|
@ -179,6 +188,11 @@ public:
|
|||
inline atUint16 readValLittle(typename std::enable_if<std::is_same<T, atUint16>::value>::type* = 0)
|
||||
{return readUint16Little();}
|
||||
|
||||
/** @brief Reads a Uint16 and swaps against big endianness depending on platform
|
||||
* and advances the current position
|
||||
*
|
||||
* @return The value at the current address
|
||||
*/
|
||||
inline atUint16 readUint16Big()
|
||||
{
|
||||
atUint16 val;
|
||||
|
|
@ -189,13 +203,10 @@ public:
|
|||
inline atUint16 readValBig(typename std::enable_if<std::is_same<T, atUint16>::value>::type* = 0)
|
||||
{return readUint16Big();}
|
||||
|
||||
/*! \brief Reads a Int32 and swaps to proper endianness depending on platform
|
||||
* and Stream settings, and advances the current position
|
||||
/** @brief Reads a Int32 and swaps to endianness specified by setEndian depending on platform
|
||||
* and advances the current position
|
||||
*
|
||||
* \sa Endian
|
||||
*
|
||||
* \return Int32 The value at the current address
|
||||
* \throw IOException when address is out of range
|
||||
* @return The value at the current address
|
||||
*/
|
||||
inline atInt32 readInt32()
|
||||
{
|
||||
|
|
@ -207,6 +218,11 @@ public:
|
|||
inline atInt32 readVal(typename std::enable_if<std::is_same<T, atInt32>::value>::type* = 0)
|
||||
{return readInt32();}
|
||||
|
||||
/** @brief Reads a Int32 and swaps against little endianness depending on platform
|
||||
* and advances the current position
|
||||
*
|
||||
* @return The value at the current address
|
||||
*/
|
||||
inline atInt32 readInt32Little()
|
||||
{
|
||||
atInt32 val;
|
||||
|
|
@ -217,6 +233,11 @@ public:
|
|||
inline atInt32 readValLittle(typename std::enable_if<std::is_same<T, atInt32>::value>::type* = 0)
|
||||
{return readInt32Little();}
|
||||
|
||||
/** @brief Reads a Int32 and swaps against big endianness depending on platform
|
||||
* and advances the current position
|
||||
*
|
||||
* @return The value at the current address
|
||||
*/
|
||||
inline atInt32 readInt32Big()
|
||||
{
|
||||
atInt32 val;
|
||||
|
|
@ -227,13 +248,10 @@ public:
|
|||
inline atInt32 readValBig(typename std::enable_if<std::is_same<T, atInt32>::value>::type* = 0)
|
||||
{return readInt32Big();}
|
||||
|
||||
/*! \brief Reads a Uint32 and swaps to proper endianness depending on platform
|
||||
* and Stream settings, and advances the current position
|
||||
/** @brief Reads a Uint32 and swaps to endianness specified by setEndian depending on platform
|
||||
* and advances the current position
|
||||
*
|
||||
* \sa Endian
|
||||
*
|
||||
* \return Uint32 The value at the current address
|
||||
* \throw IOException when address is out of range
|
||||
* @return The value at the current address
|
||||
*/
|
||||
inline atUint32 readUint32()
|
||||
{return readInt32();}
|
||||
|
|
@ -241,6 +259,11 @@ public:
|
|||
inline atUint32 readVal(typename std::enable_if<std::is_same<T, atUint32>::value>::type* = 0)
|
||||
{return readUint32();}
|
||||
|
||||
/** @brief Reads a Uint32 and swaps against little endianness depending on platform
|
||||
* and advances the current position
|
||||
*
|
||||
* @return The value at the current address
|
||||
*/
|
||||
inline atUint32 readUint32Little()
|
||||
{
|
||||
atUint32 val;
|
||||
|
|
@ -251,6 +274,11 @@ public:
|
|||
inline atInt32 readValLittle(typename std::enable_if<std::is_same<T, atUint32>::value>::type* = 0)
|
||||
{return readUint32Little();}
|
||||
|
||||
/** @brief Reads a Uint32 and swaps against big endianness depending on platform
|
||||
* and advances the current position
|
||||
*
|
||||
* @return The value at the current address
|
||||
*/
|
||||
inline atUint32 readUint32Big()
|
||||
{
|
||||
atUint32 val;
|
||||
|
|
@ -261,13 +289,10 @@ public:
|
|||
inline atUint32 readValBig(typename std::enable_if<std::is_same<T, atUint32>::value>::type* = 0)
|
||||
{return readUint32Big();}
|
||||
|
||||
/*! \brief Reads a Int64 and swaps to proper endianness depending on platform
|
||||
* and Stream settings, and advances the current position
|
||||
/** @brief Reads a Int64 and swaps to endianness specified by setEndian depending on platform
|
||||
* and advances the current position
|
||||
*
|
||||
* \sa Endian
|
||||
*
|
||||
* \return Int64 The value at the current address
|
||||
* \throw IOException when address is out of range
|
||||
* @return The value at the current address
|
||||
*/
|
||||
inline atInt64 readInt64()
|
||||
{
|
||||
|
|
@ -279,6 +304,11 @@ public:
|
|||
inline atInt64 readVal(typename std::enable_if<std::is_same<T, atInt64>::value>::type* = 0)
|
||||
{return readInt64();}
|
||||
|
||||
/** @brief Reads a Int64 and swaps against little endianness depending on platform
|
||||
* and advances the current position
|
||||
*
|
||||
* @return The value at the current address
|
||||
*/
|
||||
inline atInt64 readInt64Little()
|
||||
{
|
||||
atInt64 val;
|
||||
|
|
@ -289,6 +319,11 @@ public:
|
|||
inline atInt64 readValLittle(typename std::enable_if<std::is_same<T, atInt64>::value>::type* = 0)
|
||||
{return readInt64Little();}
|
||||
|
||||
/** @brief Reads a Int64 and swaps against big endianness depending on platform
|
||||
* and advances the current position
|
||||
*
|
||||
* @return The value at the current address
|
||||
*/
|
||||
inline atInt64 readInt64Big()
|
||||
{
|
||||
atInt64 val;
|
||||
|
|
@ -299,13 +334,10 @@ public:
|
|||
inline atInt64 readValBig(typename std::enable_if<std::is_same<T, atInt64>::value>::type* = 0)
|
||||
{return readInt64Big();}
|
||||
|
||||
/*! \brief Reads a Uint64 and swaps to proper endianness depending on platform
|
||||
* and Stream settings, and advances the current position
|
||||
/** @brief Reads a Uint64 and swaps to endianness specified by setEndian depending on platform
|
||||
* and advances the current position
|
||||
*
|
||||
* \sa Endian
|
||||
*
|
||||
* \return Uint64 The value at the current address
|
||||
* \throw IOException when address is out of range
|
||||
* @return The value at the current address
|
||||
*/
|
||||
inline atUint64 readUint64()
|
||||
{return readInt64();}
|
||||
|
|
@ -313,6 +345,11 @@ public:
|
|||
inline atUint64 readVal(typename std::enable_if<std::is_same<T, atUint64>::value>::type* = 0)
|
||||
{return readUint64();}
|
||||
|
||||
/** @brief Reads a Uint64 and swaps against little endianness depending on platform
|
||||
* and advances the current position
|
||||
*
|
||||
* @return The value at the current address
|
||||
*/
|
||||
inline atUint64 readUint64Little()
|
||||
{
|
||||
atUint64 val;
|
||||
|
|
@ -323,6 +360,11 @@ public:
|
|||
inline atUint64 readValLittle(typename std::enable_if<std::is_same<T, atUint64>::value>::type* = 0)
|
||||
{return readUint64Little();}
|
||||
|
||||
/** @brief Reads a Uint64 and swaps against big endianness depending on platform
|
||||
* and advances the current position
|
||||
*
|
||||
* @return The value at the current address
|
||||
*/
|
||||
inline atUint64 readUint64Big()
|
||||
{
|
||||
atUint64 val;
|
||||
|
|
@ -333,13 +375,10 @@ public:
|
|||
inline atUint64 readValBig(typename std::enable_if<std::is_same<T, atUint64>::value>::type* = 0)
|
||||
{return readUint64Big();}
|
||||
|
||||
/*! \brief Reads a float and swaps to proper endianness depending on platform
|
||||
* and Stream settings, and advances the current position
|
||||
/** @brief Reads a float and swaps to endianness specified by setEndian depending on platform
|
||||
* and advances the current position
|
||||
*
|
||||
* \sa Endian
|
||||
*
|
||||
* \return float The value at the current address
|
||||
* \throw IOException when address is out of range
|
||||
* @return The value at the current address
|
||||
*/
|
||||
inline float readFloat()
|
||||
{
|
||||
|
|
@ -351,6 +390,11 @@ public:
|
|||
inline float readVal(typename std::enable_if<std::is_same<T, float>::value>::type* = 0)
|
||||
{return readFloat();}
|
||||
|
||||
/** @brief Reads a float and swaps against little endianness depending on platform
|
||||
* and advances the current position
|
||||
*
|
||||
* @return The value at the current address
|
||||
*/
|
||||
inline float readFloatLittle()
|
||||
{
|
||||
float val;
|
||||
|
|
@ -361,6 +405,11 @@ public:
|
|||
inline float readValLittle(typename std::enable_if<std::is_same<T, float>::value>::type* = 0)
|
||||
{return readFloatLittle();}
|
||||
|
||||
/** @brief Reads a float and swaps against big endianness depending on platform
|
||||
* and advances the current position
|
||||
*
|
||||
* @return The value at the current address
|
||||
*/
|
||||
inline float readFloatBig()
|
||||
{
|
||||
float val;
|
||||
|
|
@ -371,13 +420,10 @@ public:
|
|||
inline float readValBig(typename std::enable_if<std::is_same<T, float>::value>::type* = 0)
|
||||
{return readFloatBig();}
|
||||
|
||||
/*! \brief Reads a double and swaps to proper endianness depending on platform
|
||||
* and Stream settings, and advances the current position
|
||||
/** @brief Reads a double and swaps to endianness specified by setEndian depending on platform
|
||||
* and advances the current position
|
||||
*
|
||||
* \sa Endian
|
||||
*
|
||||
* \return double The value at the current address
|
||||
* \throw IOException when address is out of range
|
||||
* @return The value at the current address
|
||||
*/
|
||||
inline double readDouble()
|
||||
{
|
||||
|
|
@ -389,6 +435,11 @@ public:
|
|||
inline double readVal(typename std::enable_if<std::is_same<T, double>::value>::type* = 0)
|
||||
{return readDouble();}
|
||||
|
||||
/** @brief Reads a double and swaps against little endianness depending on platform
|
||||
* and advances the current position
|
||||
*
|
||||
* @return The value at the current address
|
||||
*/
|
||||
inline double readDoubleLittle()
|
||||
{
|
||||
double val;
|
||||
|
|
@ -399,6 +450,11 @@ public:
|
|||
inline double readValLittle(typename std::enable_if<std::is_same<T, double>::value>::type* = 0)
|
||||
{return readDoubleLittle();}
|
||||
|
||||
/** @brief Reads a double and swaps against big endianness depending on platform
|
||||
* and advances the current position
|
||||
*
|
||||
* @return The value at the current address
|
||||
*/
|
||||
inline double readDoubleBig()
|
||||
{
|
||||
double val;
|
||||
|
|
@ -409,10 +465,9 @@ public:
|
|||
inline double readValBig(typename std::enable_if<std::is_same<T, double>::value>::type* = 0)
|
||||
{return readDoubleBig();}
|
||||
|
||||
/*! \brief Reads a bool and advances the current position
|
||||
/** @brief Reads a bool and advances the current position
|
||||
*
|
||||
* \return bool The value at the current address
|
||||
* \throw IOException when address is out of range
|
||||
* @return The value at the current address
|
||||
*/
|
||||
inline bool readBool()
|
||||
{
|
||||
|
|
@ -424,10 +479,10 @@ public:
|
|||
inline bool readVal(typename std::enable_if<std::is_same<T, bool>::value>::type* = 0)
|
||||
{return readBool();}
|
||||
|
||||
/*! \brief Reads an atVec2f (8 bytes) and advances the current position
|
||||
/** @brief Reads an atVec2f (8 bytes), swaps to endianness specified by setEndian depending on platform
|
||||
* and advances the current position
|
||||
*
|
||||
* \return atVec2f The value at the current address
|
||||
* \throw IOException when address is out of range
|
||||
* @return The value at the current address
|
||||
*/
|
||||
inline atVec2f readVec2f()
|
||||
{
|
||||
|
|
@ -449,6 +504,11 @@ public:
|
|||
inline atVec2f readVal(typename std::enable_if<std::is_same<T, atVec2f>::value>::type* = 0)
|
||||
{return readVec2f();}
|
||||
|
||||
/** @brief Reads an atVec2f (8 bytes), swaps against little endianness depending on platform
|
||||
* and advances the current position
|
||||
*
|
||||
* @return The value at the current address
|
||||
*/
|
||||
inline atVec2f readVec2fLittle()
|
||||
{
|
||||
atVec2f val;
|
||||
|
|
@ -461,6 +521,11 @@ public:
|
|||
inline atVec2f readValLittle(typename std::enable_if<std::is_same<T, atVec2f>::value>::type* = 0)
|
||||
{return readVec2fLittle();}
|
||||
|
||||
/** @brief Reads an atVec2f (8 bytes), swaps against big endianness depending on platform
|
||||
* and advances the current position
|
||||
*
|
||||
* @return The value at the current address
|
||||
*/
|
||||
inline atVec2f readVec2fBig()
|
||||
{
|
||||
atVec2f val;
|
||||
|
|
@ -473,10 +538,10 @@ public:
|
|||
inline atVec2f readValBig(typename std::enable_if<std::is_same<T, atVec2f>::value>::type* = 0)
|
||||
{return readVec2fBig();}
|
||||
|
||||
/*! \brief Reads an atVec3f (12 bytes) and advances the current position
|
||||
/** @brief Reads an atVec3f (12 bytes), swaps to endianness specified by setEndian depending on platform
|
||||
* and advances the current position
|
||||
*
|
||||
* \return atVec3f The value at the current address
|
||||
* \throw IOException when address is out of range
|
||||
* @return The value at the current address
|
||||
*/
|
||||
inline atVec3f readVec3f()
|
||||
{
|
||||
|
|
@ -500,6 +565,11 @@ public:
|
|||
inline atVec3f readVal(typename std::enable_if<std::is_same<T, atVec3f>::value>::type* = 0)
|
||||
{return readVec3f();}
|
||||
|
||||
/** @brief Reads an atVec3f (12 bytes), swaps against little endianness depending on platform
|
||||
* and advances the current position
|
||||
*
|
||||
* @return The value at the current address
|
||||
*/
|
||||
inline atVec3f readVec3fLittle()
|
||||
{
|
||||
atVec3f val;
|
||||
|
|
@ -513,6 +583,11 @@ public:
|
|||
inline atVec3f readValLittle(typename std::enable_if<std::is_same<T, atVec3f>::value>::type* = 0)
|
||||
{return readVec3fLittle();}
|
||||
|
||||
/** @brief Reads an atVec3f (12 bytes), swaps against big endianness depending on platform
|
||||
* and advances the current position
|
||||
*
|
||||
* @return The value at the current address
|
||||
*/
|
||||
inline atVec3f readVec3fBig()
|
||||
{
|
||||
atVec3f val;
|
||||
|
|
@ -526,10 +601,10 @@ public:
|
|||
inline atVec3f readValBig(typename std::enable_if<std::is_same<T, atVec3f>::value>::type* = 0)
|
||||
{return readVec3fBig();}
|
||||
|
||||
/*! \brief Reads an atVec4f (16 bytes) and advances the current position
|
||||
/** @brief Reads an atVec4f (16 bytes), swaps to endianness specified by setEndian depending on platform
|
||||
* and advances the current position
|
||||
*
|
||||
* \return atVec4f The value at the current address
|
||||
* \throw IOException when address is out of range
|
||||
* @return The value at the current address
|
||||
*/
|
||||
inline atVec4f readVec4f()
|
||||
{
|
||||
|
|
@ -555,6 +630,11 @@ public:
|
|||
inline atVec4f readVal(typename std::enable_if<std::is_same<T, atVec4f>::value>::type* = 0)
|
||||
{return readVec4f();}
|
||||
|
||||
/** @brief Reads an atVec4f (16 bytes), swaps against little endianness depending on platform
|
||||
* and advances the current position
|
||||
*
|
||||
* @return The value at the current address
|
||||
*/
|
||||
inline atVec4f readVec4fLittle()
|
||||
{
|
||||
atVec4f val;
|
||||
|
|
@ -569,6 +649,11 @@ public:
|
|||
inline atVec4f readValLittle(typename std::enable_if<std::is_same<T, atVec4f>::value>::type* = 0)
|
||||
{return readVec4fLittle();}
|
||||
|
||||
/** @brief Reads an atVec4f (16 bytes), swaps against big endianness depending on platform
|
||||
* and advances the current position
|
||||
*
|
||||
* @return The value at the current address
|
||||
*/
|
||||
inline atVec4f readVec4fBig()
|
||||
{
|
||||
atVec4f val;
|
||||
|
|
@ -583,11 +668,11 @@ public:
|
|||
inline atVec4f readValBig(typename std::enable_if<std::is_same<T, atVec4f>::value>::type* = 0)
|
||||
{return readVec4fBig();}
|
||||
|
||||
/*! \brief Reads a wide-char string, converts to UTF8 and advances the position in the file
|
||||
/** @brief Reads a wide-char string (using endianness from setEndian),
|
||||
* converts to UTF8 and advances the position in the file
|
||||
*
|
||||
* \param fixedLen If non-negative, this is a fixed-length string read
|
||||
* \return std::string The value at the current address
|
||||
* \throw IOException when address is out of range
|
||||
* @param fixedLen If non-negative, this is a fixed-length string read
|
||||
* @return The read string
|
||||
*/
|
||||
inline std::string readWStringAsString(atInt32 fixedLen = -1)
|
||||
{
|
||||
|
|
@ -621,6 +706,12 @@ public:
|
|||
return retval;
|
||||
}
|
||||
|
||||
/** @brief Reads a wide-char string (against little-endian),
|
||||
* converts to UTF8 and advances the position in the file
|
||||
*
|
||||
* @param fixedLen If non-negative, this is a fixed-length string read
|
||||
* @return The read string
|
||||
*/
|
||||
inline std::string readWStringAsStringLittle(atInt32 fixedLen = -1)
|
||||
{
|
||||
std::string retval;
|
||||
|
|
@ -653,6 +744,12 @@ public:
|
|||
return retval;
|
||||
}
|
||||
|
||||
/** @brief Reads a wide-char string (against big-endian),
|
||||
* converts to UTF8 and advances the position in the file
|
||||
*
|
||||
* @param fixedLen If non-negative, this is a fixed-length string read
|
||||
* @return The read string
|
||||
*/
|
||||
inline std::string readWStringAsStringBig(atInt32 fixedLen = -1)
|
||||
{
|
||||
std::string retval;
|
||||
|
|
@ -685,11 +782,10 @@ public:
|
|||
return retval;
|
||||
}
|
||||
|
||||
/*! \brief Reads a string and advances the position in the file
|
||||
/** @brief Reads a string and advances the position in the file
|
||||
*
|
||||
* \param fixedLen If non-negative, this is a fixed-length string read
|
||||
* \return std::string The value at the current address
|
||||
* \throw IOException when address is out of range
|
||||
* @param fixedLen If non-negative, this is a fixed-length string read
|
||||
* @return The read string
|
||||
*/
|
||||
inline std::string readString(atInt32 fixedLen = -1)
|
||||
{
|
||||
|
|
@ -716,11 +812,10 @@ public:
|
|||
inline std::string readVal(typename std::enable_if<std::is_same<T, std::string>::value>::type* = 0)
|
||||
{return readString();}
|
||||
|
||||
/*! \brief Reads a wstring and advances the position in the file
|
||||
/** @brief Reads a wstring and advances the position in the file
|
||||
*
|
||||
* \param fixedLen If non-negative, this is a fixed-length string read
|
||||
* \return std::wstring The value at the current address
|
||||
* \throw IOException when address is out of range
|
||||
* @param fixedLen If non-negative, this is a fixed-length string read
|
||||
* @return The read wstring
|
||||
*/
|
||||
inline std::wstring readWString(atInt32 fixedLen = -1)
|
||||
{
|
||||
|
|
@ -747,6 +842,12 @@ public:
|
|||
inline std::wstring readVal(typename std::enable_if<std::is_same<T, std::wstring>::value>::type* = 0)
|
||||
{return readWString();}
|
||||
|
||||
/** @brief Reads a wstring assuming little-endian characters
|
||||
* and advances the position in the file
|
||||
*
|
||||
* @param fixedLen If non-negative, this is a fixed-length string read
|
||||
* @return The read wstring
|
||||
*/
|
||||
inline std::wstring readWStringLittle(atInt32 fixedLen = -1)
|
||||
{
|
||||
std::wstring ret;
|
||||
|
|
@ -772,6 +873,12 @@ public:
|
|||
inline std::wstring readValLittle(typename std::enable_if<std::is_same<T, std::wstring>::value>::type* = 0)
|
||||
{return readWStringLittle();}
|
||||
|
||||
/** @brief Reads a wstring assuming big-endian characters
|
||||
* and advances the position in the file
|
||||
*
|
||||
* @param fixedLen If non-negative, this is a fixed-length string read
|
||||
* @return The read wstring
|
||||
*/
|
||||
inline std::wstring readWStringBig(atInt32 fixedLen = -1)
|
||||
{
|
||||
std::wstring ret;
|
||||
|
|
@ -797,6 +904,13 @@ public:
|
|||
inline std::wstring readValBig(typename std::enable_if<std::is_same<T, std::wstring>::value>::type* = 0)
|
||||
{return readWStringBig();}
|
||||
|
||||
/** @brief Performs automatic std::vector enumeration reads using numeric type T
|
||||
*
|
||||
* @param vector The std::vector to clear and populate using read data
|
||||
* @param count The number of elements to read into vector
|
||||
*
|
||||
* Endianness is set with setEndian
|
||||
*/
|
||||
template<class T>
|
||||
void enumerate(std::vector<T>& vector, size_t count,
|
||||
typename std::enable_if<std::is_arithmetic<T>::value ||
|
||||
|
|
@ -810,6 +924,13 @@ public:
|
|||
vector.emplace_back(readVal<T>());
|
||||
}
|
||||
|
||||
/** @brief Performs automatic std::vector enumeration reads using numeric type T
|
||||
*
|
||||
* @param vector The std::vector to clear and populate using read data
|
||||
* @param count The number of elements to read into vector
|
||||
*
|
||||
* Endianness is little
|
||||
*/
|
||||
template<class T>
|
||||
void enumerateLittle(std::vector<T>& vector, size_t count,
|
||||
typename std::enable_if<std::is_arithmetic<T>::value ||
|
||||
|
|
@ -823,6 +944,13 @@ public:
|
|||
vector.emplace_back(readValLittle<T>());
|
||||
}
|
||||
|
||||
/** @brief Performs automatic std::vector enumeration reads using numeric type T
|
||||
*
|
||||
* @param vector The std::vector to clear and populate using read data
|
||||
* @param count The number of elements to read into vector
|
||||
*
|
||||
* Endianness is big
|
||||
*/
|
||||
template<class T>
|
||||
void enumerateBig(std::vector<T>& vector, size_t count,
|
||||
typename std::enable_if<std::is_arithmetic<T>::value ||
|
||||
|
|
@ -836,6 +964,11 @@ public:
|
|||
vector.emplace_back(readValBig<T>());
|
||||
}
|
||||
|
||||
/** @brief Performs automatic std::vector enumeration reads using non-numeric type T
|
||||
*
|
||||
* @param vector The std::vector to clear and populate using read data
|
||||
* @param count The number of elements to read into vector
|
||||
*/
|
||||
template<class T>
|
||||
void enumerate(std::vector<T>& vector, size_t count,
|
||||
typename std::enable_if<!std::is_arithmetic<T>::value &&
|
||||
|
|
@ -852,6 +985,13 @@ public:
|
|||
}
|
||||
}
|
||||
|
||||
/** @brief Performs lambda-assisted std::vector enumeration reads using type T
|
||||
*
|
||||
* @param vector The std::vector to clear and populate using read data
|
||||
* @param count The number of elements to read into vector
|
||||
* @param readf Function (e.g. a lambda) that reads *one* element and
|
||||
* assigns the value through the second argument
|
||||
*/
|
||||
template<class T>
|
||||
void enumerate(std::vector<T>& vector, size_t count, std::function<void(IStreamReader&, T&)> readf)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -12,97 +12,95 @@ class IStreamWriter : public IStream
|
|||
{
|
||||
public:
|
||||
virtual ~IStreamWriter() {}
|
||||
/*! \brief Sets the Endianness of the stream
|
||||
/** @brief Sets the Endianness of the stream
|
||||
*
|
||||
* \param endian The Endianness to set \sa Endian
|
||||
* @param endian The Endianness to set
|
||||
*/
|
||||
inline void setEndian(Endian endian)
|
||||
{m_endian = endian;}
|
||||
|
||||
/*! \brief Returns the current Endianness of the stream
|
||||
/** @brief Returns the current Endianness of the stream
|
||||
*
|
||||
* \return Endian The current Stream Endianness
|
||||
* @return The current Stream Endianness
|
||||
*/
|
||||
inline Endian endian() const
|
||||
{return m_endian;}
|
||||
|
||||
/*! \brief Returns whether the stream is BigEndian
|
||||
/** @brief Returns whether the stream is BigEndian
|
||||
*
|
||||
* \return bool True for BigEndian; False for LittleEndian
|
||||
* @return True for BigEndian; False for LittleEndian
|
||||
*/
|
||||
inline bool isBigEndian() const
|
||||
{return (m_endian == Endian::BigEndian);}
|
||||
|
||||
/*! \brief Returns whether the stream is LittleEndian
|
||||
/** @brief Returns whether the stream is LittleEndian
|
||||
*
|
||||
* \return bool True for LittleEndian; False for BigEndian
|
||||
* @return True for LittleEndian; False for BigEndian
|
||||
*/
|
||||
inline bool isLittleEndian() const
|
||||
{return (m_endian == Endian::LittleEndian);}
|
||||
|
||||
/*! \brief Sets the buffers position relative to the specified position.<br />
|
||||
/** @brief Sets the buffers position relative to the specified position.<br />
|
||||
* It seeks relative to the current position by default.
|
||||
* \param position where in the buffer to seek
|
||||
* \param origin The Origin to seek \sa SeekOrigin
|
||||
* @param position where in the buffer to seek
|
||||
* @param origin The location to seek relative to
|
||||
*/
|
||||
virtual void seek(atInt64 pos, SeekOrigin origin = SeekOrigin::Current)=0;
|
||||
|
||||
/*! \brief Sets the buffers position relative to the next 32-byte aligned position.<br />
|
||||
/** @brief Sets the buffers position relative to the next 32-byte aligned position.<br />
|
||||
*/
|
||||
inline void seekAlign32() {seek(ROUND_UP_32(position()), SeekOrigin::Begin);}
|
||||
|
||||
/*! \brief Returns whether or not the stream is at the end.
|
||||
/** @brief Returns whether or not the stream is at the end.
|
||||
*
|
||||
* \return bool True if at end; False otherwise.
|
||||
* @return True if at end; False otherwise.
|
||||
*/
|
||||
inline bool atEnd() const {return position() >= length();}
|
||||
|
||||
/*! \brief Returns the current position in the stream.
|
||||
/** @brief Returns the current position in the stream.
|
||||
*
|
||||
* \return Int64 The current position in the stream.
|
||||
* @return The current position in the stream.
|
||||
*/
|
||||
virtual atUint64 position() const=0;
|
||||
|
||||
/*! \brief Returns whether or not the stream is at the end.
|
||||
/** @brief Returns whether or not the stream is at the end.
|
||||
*
|
||||
* \return bool True if at end; False otherwise.
|
||||
* @return True if at end; False otherwise.
|
||||
*/
|
||||
virtual atUint64 length() const=0;
|
||||
|
||||
/*! \brief Writes a byte at the current position and advances the position by one byte.
|
||||
* \param byte The value to write
|
||||
/** @brief Writes a byte at the current position and advances the position by one byte.
|
||||
* @param val The value to write
|
||||
*/
|
||||
inline void writeUByte(atUint8 val) {writeUBytes(&val, 1);}
|
||||
inline void writeVal(atUint8 val) {return writeUByte(val);}
|
||||
|
||||
/*! \brief Writes a byte at the current position and advances the position by one byte.
|
||||
* \param byte The value to write
|
||||
* \throw IOException
|
||||
/** @brief Writes a byte at the current position and advances the position by one byte.
|
||||
* @param val The value to write
|
||||
*/
|
||||
inline void writeByte(atInt8 val) {writeUByte(val);}
|
||||
inline void writeVal(atInt8 val) {return writeByte(val);}
|
||||
|
||||
/*! \brief Writes the given buffer with the specified length, buffers can be bigger than the length
|
||||
/** @brief Writes the given buffer with the specified length, buffers can be bigger than the length
|
||||
* however it's undefined behavior to try and write a buffer which is smaller than the given length.
|
||||
*
|
||||
* \param data The buffer to write
|
||||
* \param length The amount to write
|
||||
* @param data The buffer to write
|
||||
* @param length The amount to write
|
||||
*/
|
||||
virtual void writeUBytes(const atUint8* data, atUint64 len)=0;
|
||||
|
||||
/*! \brief Writes the given buffer with the specified length, buffers can be bigger than the length
|
||||
/** @brief Writes the given buffer with the specified length, buffers can be bigger than the length
|
||||
* however it's undefined behavior to try and write a buffer which is smaller than the given length.
|
||||
*
|
||||
* \param data The buffer to write
|
||||
* \param length The amount to write
|
||||
* @param data The buffer to write
|
||||
* @param length The amount to write
|
||||
*/
|
||||
inline void writeBytes(const atInt8* data, atUint64 len) {writeUBytes((atUint8*)data, len);}
|
||||
|
||||
/*! \brief Writes an Int16 to the buffer and advances the buffer.
|
||||
/** @brief Writes an Int16 to the buffer and advances the buffer.
|
||||
* It also swaps the bytes depending on the platform and Stream settings.
|
||||
*
|
||||
* \sa Endian
|
||||
* \param val The value to write to the buffer
|
||||
* @param val The value to write to the buffer
|
||||
*/
|
||||
inline void writeInt16(atInt16 val)
|
||||
{
|
||||
|
|
@ -114,6 +112,11 @@ public:
|
|||
}
|
||||
inline void writeVal(atInt16 val) {return writeInt16(val);}
|
||||
|
||||
/** @brief Writes an Int16 to the buffer and advances the buffer.
|
||||
* It also swaps the bytes against little depending on the platform.
|
||||
*
|
||||
* @param val The value to write to the buffer
|
||||
*/
|
||||
inline void writeInt16Little(atInt16 val)
|
||||
{
|
||||
utility::LittleInt16(val);
|
||||
|
|
@ -121,6 +124,11 @@ public:
|
|||
}
|
||||
inline void writeValLittle(atInt16 val) {return writeInt16Little(val);}
|
||||
|
||||
/** @brief Writes an Int16 to the buffer and advances the buffer.
|
||||
* It also swaps the bytes against big depending on the platform.
|
||||
*
|
||||
* @param val The value to write to the buffer
|
||||
*/
|
||||
inline void writeInt16Big(atInt16 val)
|
||||
{
|
||||
utility::BigInt16(val);
|
||||
|
|
@ -128,26 +136,34 @@ public:
|
|||
}
|
||||
inline void writeValBig(atInt16 val) {return writeInt16Big(val);}
|
||||
|
||||
/*! \brief Writes an Uint16 to the buffer and advances the buffer.
|
||||
/** @brief Writes an Uint16 to the buffer and advances the buffer.
|
||||
* It also swaps the bytes depending on the platform and Stream settings
|
||||
*
|
||||
* \sa Endian
|
||||
* \param val The value to write to the buffer
|
||||
* @param val The value to write to the buffer
|
||||
*/
|
||||
inline void writeUint16(atUint16 val) {writeInt16(val);}
|
||||
inline void writeVal(atUint16 val) {return writeUint16(val);}
|
||||
|
||||
/** @brief Writes an Uint16 to the buffer and advances the buffer.
|
||||
* It also swaps the bytes against little depending on the platform
|
||||
*
|
||||
* @param val The value to write to the buffer
|
||||
*/
|
||||
inline void writeUint16Little(atUint16 val) {writeInt16Little(val);}
|
||||
inline void writeValLittle(atUint16 val) {return writeUint16Little(val);}
|
||||
|
||||
/** @brief Writes an Uint16 to the buffer and advances the buffer.
|
||||
* It also swaps the bytes against big depending on the platform
|
||||
*
|
||||
* @param val The value to write to the buffer
|
||||
*/
|
||||
inline void writeUint16Big(atUint16 val) {writeInt16Big(val);}
|
||||
inline void writeValBig(atUint16 val) {return writeUint16Big(val);}
|
||||
|
||||
/*! \brief Writes an Int32 to the buffer and advances the buffer.
|
||||
/** @brief Writes an Int32 to the buffer and advances the buffer.
|
||||
* It also swaps the bytes depending on the platform and Stream settings.
|
||||
*
|
||||
* \sa Endian
|
||||
* \param val The value to write to the buffer
|
||||
* @param val The value to write to the buffer
|
||||
*/
|
||||
inline void writeInt32(atInt32 val)
|
||||
{
|
||||
|
|
@ -159,6 +175,11 @@ public:
|
|||
}
|
||||
inline void writeVal(atInt32 val) {return writeInt32(val);}
|
||||
|
||||
/** @brief Writes an Int32 to the buffer and advances the buffer.
|
||||
* It also swaps the bytes against little depending on the platform.
|
||||
*
|
||||
* @param val The value to write to the buffer
|
||||
*/
|
||||
inline void writeInt32Little(atInt32 val)
|
||||
{
|
||||
utility::LittleInt32(val);
|
||||
|
|
@ -166,6 +187,11 @@ public:
|
|||
}
|
||||
inline void writeValLittle(atInt32 val) {return writeInt32Little(val);}
|
||||
|
||||
/** @brief Writes an Int32 to the buffer and advances the buffer.
|
||||
* It also swaps the bytes against big depending on the platform.
|
||||
*
|
||||
* @param val The value to write to the buffer
|
||||
*/
|
||||
inline void writeInt32Big(atInt32 val)
|
||||
{
|
||||
utility::BigInt32(val);
|
||||
|
|
@ -173,26 +199,34 @@ public:
|
|||
}
|
||||
inline void writeValBig(atInt32 val) {return writeInt32Big(val);}
|
||||
|
||||
/*! \brief Writes an Uint32 to the buffer and advances the buffer.
|
||||
/** @brief Writes an Uint32 to the buffer and advances the buffer.
|
||||
* It also swaps the bytes depending on the platform and Stream settings.
|
||||
*
|
||||
* \sa Endian
|
||||
* \param val The value to write to the buffer
|
||||
* @param val The value to write to the buffer
|
||||
*/
|
||||
inline void writeUint32(atUint32 val) {writeInt32(val);}
|
||||
inline void writeVal(atUint32 val) {return writeUint32(val);}
|
||||
|
||||
/** @brief Writes an Uint32 to the buffer and advances the buffer.
|
||||
* It also swaps the bytes against little depending on the platform.
|
||||
*
|
||||
* @param val The value to write to the buffer
|
||||
*/
|
||||
inline void writeUint32Little(atUint32 val) {writeInt32Little(val);}
|
||||
inline void writeValLittle(atUint32 val) {return writeUint32Little(val);}
|
||||
|
||||
/** @brief Writes an Uint32 to the buffer and advances the buffer.
|
||||
* It also swaps the bytes against big depending on the platform.
|
||||
*
|
||||
* @param val The value to write to the buffer
|
||||
*/
|
||||
inline void writeUint32Big(atUint32 val) {writeInt32Big(val);}
|
||||
inline void writeValBig(atUint32 val) {return writeUint32Big(val);}
|
||||
|
||||
/*! \brief Writes an Int64 to the buffer and advances the buffer.
|
||||
/** @brief Writes an Int64 to the buffer and advances the buffer.
|
||||
* It also swaps the bytes depending on the platform and Stream settings.
|
||||
*
|
||||
* \sa Endian
|
||||
* \param val The value to write to the buffer
|
||||
* @param val The value to write to the buffer
|
||||
*/
|
||||
inline void writeInt64(atInt64 val)
|
||||
{
|
||||
|
|
@ -204,6 +238,11 @@ public:
|
|||
}
|
||||
inline void writeVal(atInt64 val) {return writeInt64(val);}
|
||||
|
||||
/** @brief Writes an Int64 to the buffer and advances the buffer.
|
||||
* It also swaps the bytes against little depending on the platform.
|
||||
*
|
||||
* @param val The value to write to the buffer
|
||||
*/
|
||||
inline void writeInt64Little(atInt64 val)
|
||||
{
|
||||
utility::LittleInt64(val);
|
||||
|
|
@ -211,6 +250,11 @@ public:
|
|||
}
|
||||
inline void writeValLittle(atInt64 val) {return writeInt64Little(val);}
|
||||
|
||||
/** @brief Writes an Int64 to the buffer and advances the buffer.
|
||||
* It also swaps the bytes against big depending on the platform.
|
||||
*
|
||||
* @param val The value to write to the buffer
|
||||
*/
|
||||
inline void writeInt64Big(atInt64 val)
|
||||
{
|
||||
utility::BigInt64(val);
|
||||
|
|
@ -218,26 +262,34 @@ public:
|
|||
}
|
||||
inline void writeValBig(atInt64 val) {return writeInt64Big(val);}
|
||||
|
||||
/*! \brief Writes an Uint64 to the buffer and advances the buffer.
|
||||
/** @brief Writes an Uint64 to the buffer and advances the buffer.
|
||||
* It also swaps the bytes depending on the platform and Stream settings.
|
||||
*
|
||||
* \sa Endian
|
||||
* \param val The value to write to the buffer
|
||||
* @param val The value to write to the buffer
|
||||
*/
|
||||
inline void writeUint64(atUint64 val) {writeInt64(val);}
|
||||
inline void writeVal(atUint64 val) {return writeUint64(val);}
|
||||
|
||||
/** @brief Writes an Uint64 to the buffer and advances the buffer.
|
||||
* It also swaps the bytes against little depending on the platform.
|
||||
*
|
||||
* @param val The value to write to the buffer
|
||||
*/
|
||||
inline void writeUint64Little(atUint64 val) {writeInt64Little(val);}
|
||||
inline void writeValLittle(atUint64 val) {return writeUint64Little(val);}
|
||||
|
||||
/** @brief Writes an Uint64 to the buffer and advances the buffer.
|
||||
* It also swaps the bytes against big depending on the platform.
|
||||
*
|
||||
* @param val The value to write to the buffer
|
||||
*/
|
||||
inline void writeUint64Big(atUint64 val) {writeInt64Big(val);}
|
||||
inline void writeValBig(atUint64 val) {return writeUint64Big(val);}
|
||||
|
||||
/*! \brief Writes an float to the buffer and advances the buffer.
|
||||
/** @brief Writes an float to the buffer and advances the buffer.
|
||||
* It also swaps the bytes depending on the platform and Stream settings.
|
||||
*
|
||||
* \sa Endian
|
||||
* \param val The value to write to the buffer
|
||||
* @param val The value to write to the buffer
|
||||
*/
|
||||
inline void writeFloat(float val)
|
||||
{
|
||||
|
|
@ -249,6 +301,11 @@ public:
|
|||
}
|
||||
inline void writeVal(float val) {return writeFloat(val);}
|
||||
|
||||
/** @brief Writes an float to the buffer and advances the buffer.
|
||||
* It also swaps the bytes against little depending on the platform.
|
||||
*
|
||||
* @param val The value to write to the buffer
|
||||
*/
|
||||
inline void writeFloatLittle(float val)
|
||||
{
|
||||
utility::LittleFloat(val);
|
||||
|
|
@ -256,6 +313,11 @@ public:
|
|||
}
|
||||
inline void writeValLittle(float val) {return writeFloatLittle(val);}
|
||||
|
||||
/** @brief Writes an float to the buffer and advances the buffer.
|
||||
* It also swaps the bytes against big depending on the platform.
|
||||
*
|
||||
* @param val The value to write to the buffer
|
||||
*/
|
||||
inline void writeFloatBig(float val)
|
||||
{
|
||||
utility::BigFloat(val);
|
||||
|
|
@ -263,11 +325,10 @@ public:
|
|||
}
|
||||
inline void writeValBig(float val) {return writeFloatBig(val);}
|
||||
|
||||
/*! \brief Writes an double to the buffer and advances the buffer.
|
||||
/** @brief Writes an double to the buffer and advances the buffer.
|
||||
* It also swaps the bytes depending on the platform and Stream settings.
|
||||
*
|
||||
* \sa Endian
|
||||
* \param val The value to write to the buffer
|
||||
* @param val The value to write to the buffer
|
||||
*/
|
||||
inline void writeDouble(double val)
|
||||
{
|
||||
|
|
@ -279,6 +340,11 @@ public:
|
|||
}
|
||||
inline void writeVal(double val) {return writeDouble(val);}
|
||||
|
||||
/** @brief Writes an double to the buffer and advances the buffer.
|
||||
* It also swaps the bytes against little depending on the platform.
|
||||
*
|
||||
* @param val The value to write to the buffer
|
||||
*/
|
||||
inline void writeDoubleLittle(double val)
|
||||
{
|
||||
utility::LittleDouble(val);
|
||||
|
|
@ -286,6 +352,11 @@ public:
|
|||
}
|
||||
inline void writeValLittle(double val) {return writeDoubleLittle(val);}
|
||||
|
||||
/** @brief Writes an double to the buffer and advances the buffer.
|
||||
* It also swaps the bytes against big depending on the platform.
|
||||
*
|
||||
* @param val The value to write to the buffer
|
||||
*/
|
||||
inline void writeDoubleBig(double val)
|
||||
{
|
||||
utility::BigDouble(val);
|
||||
|
|
@ -293,20 +364,18 @@ public:
|
|||
}
|
||||
inline void writeValBig(double val) {return writeDoubleBig(val);}
|
||||
|
||||
/*! \brief Writes an bool to the buffer and advances the buffer.
|
||||
/** @brief Writes an bool to the buffer and advances the buffer.
|
||||
* It also swaps the bytes depending on the platform and Stream settings.
|
||||
*
|
||||
* \sa Endian
|
||||
* \param val The value to write to the buffer
|
||||
* @param val The value to write to the buffer
|
||||
*/
|
||||
inline void writeBool(bool val) {writeUBytes((atUint8*)&val, 1);}
|
||||
inline void writeVal(bool val) {return writeBool(val);}
|
||||
|
||||
/*! \brief Writes an atVec2f (8 bytes) to the buffer and advances the buffer.
|
||||
/** @brief Writes an atVec2f (8 bytes) to the buffer and advances the buffer.
|
||||
* It also swaps the bytes depending on the platform and Stream settings.
|
||||
*
|
||||
* \sa Endian
|
||||
* \param vec The value to write to the buffer
|
||||
* @param vec The value to write to the buffer
|
||||
*/
|
||||
inline void writeVec2f(atVec2f vec)
|
||||
{
|
||||
|
|
@ -324,6 +393,11 @@ public:
|
|||
}
|
||||
inline void writeVal(atVec2f val) {return writeVec2f(val);}
|
||||
|
||||
/** @brief Writes an atVec2f (8 bytes) to the buffer and advances the buffer.
|
||||
* It also swaps the bytes against little depending on the platform.
|
||||
*
|
||||
* @param vec The value to write to the buffer
|
||||
*/
|
||||
inline void writeVec2fLittle(atVec2f vec)
|
||||
{
|
||||
utility::LittleFloat(vec.vec[0]);
|
||||
|
|
@ -332,6 +406,11 @@ public:
|
|||
}
|
||||
inline void writeValLittle(atVec2f val) {return writeVec2fLittle(val);}
|
||||
|
||||
/** @brief Writes an atVec2f (8 bytes) to the buffer and advances the buffer.
|
||||
* It also swaps the bytes against big depending on the platform.
|
||||
*
|
||||
* @param vec The value to write to the buffer
|
||||
*/
|
||||
inline void writeVec2fBig(atVec2f vec)
|
||||
{
|
||||
utility::BigFloat(vec.vec[0]);
|
||||
|
|
@ -340,11 +419,10 @@ public:
|
|||
}
|
||||
inline void writeValBig(atVec2f val) {return writeVec2fBig(val);}
|
||||
|
||||
/*! \brief Writes an atVec3f (12 bytes) to the buffer and advances the buffer.
|
||||
/** @brief Writes an atVec3f (12 bytes) to the buffer and advances the buffer.
|
||||
* It also swaps the bytes depending on the platform and Stream settings.
|
||||
*
|
||||
* \sa Endian
|
||||
* \param vec The value to write to the buffer
|
||||
* @param vec The value to write to the buffer
|
||||
*/
|
||||
inline void writeVec3f(atVec3f vec)
|
||||
{
|
||||
|
|
@ -364,6 +442,11 @@ public:
|
|||
}
|
||||
inline void writeVal(atVec3f val) {return writeVec3f(val);}
|
||||
|
||||
/** @brief Writes an atVec3f (12 bytes) to the buffer and advances the buffer.
|
||||
* It also swaps the bytes against little depending on the platform.
|
||||
*
|
||||
* @param vec The value to write to the buffer
|
||||
*/
|
||||
inline void writeVec3fLittle(atVec3f vec)
|
||||
{
|
||||
utility::LittleFloat(vec.vec[0]);
|
||||
|
|
@ -373,6 +456,11 @@ public:
|
|||
}
|
||||
inline void writeValLittle(atVec3f val) {return writeVec3fLittle(val);}
|
||||
|
||||
/** @brief Writes an atVec3f (12 bytes) to the buffer and advances the buffer.
|
||||
* It also swaps the bytes against big depending on the platform.
|
||||
*
|
||||
* @param vec The value to write to the buffer
|
||||
*/
|
||||
inline void writeVec3fBig(atVec3f vec)
|
||||
{
|
||||
utility::BigFloat(vec.vec[0]);
|
||||
|
|
@ -382,11 +470,10 @@ public:
|
|||
}
|
||||
inline void writeValBig(atVec3f val) {return writeVec3fBig(val);}
|
||||
|
||||
/*! \brief Writes an atVec4f (16 bytes) to the buffer and advances the buffer.
|
||||
/** @brief Writes an atVec4f (16 bytes) to the buffer and advances the buffer.
|
||||
* It also swaps the bytes depending on the platform and Stream settings.
|
||||
*
|
||||
* \sa Endian
|
||||
* \param vec The value to write to the buffer
|
||||
* @param vec The value to write to the buffer
|
||||
*/
|
||||
inline void writeVec4f(atVec4f vec)
|
||||
{
|
||||
|
|
@ -408,6 +495,11 @@ public:
|
|||
}
|
||||
inline void writeVal(atVec4f val) {return writeVec4f(val);}
|
||||
|
||||
/** @brief Writes an atVec4f (16 bytes) to the buffer and advances the buffer.
|
||||
* It also swaps the bytes against little depending on the platform.
|
||||
*
|
||||
* @param vec The value to write to the buffer
|
||||
*/
|
||||
inline void writeVec4fLittle(atVec4f vec)
|
||||
{
|
||||
utility::LittleFloat(vec.vec[0]);
|
||||
|
|
@ -418,6 +510,11 @@ public:
|
|||
}
|
||||
inline void writeValLittle(atVec4f val) {return writeVec4fLittle(val);}
|
||||
|
||||
/** @brief Writes an atVec4f (16 bytes) to the buffer and advances the buffer.
|
||||
* It also swaps the bytes against big depending on the platform.
|
||||
*
|
||||
* @param vec The value to write to the buffer
|
||||
*/
|
||||
inline void writeVec4fBig(atVec4f vec)
|
||||
{
|
||||
utility::BigFloat(vec.vec[0]);
|
||||
|
|
@ -428,12 +525,13 @@ public:
|
|||
}
|
||||
inline void writeValBig(atVec4f val) {return writeVec4fBig(val);}
|
||||
|
||||
/*! \brief Converts a UTF8 string to a wide-char string in the buffer and advances the buffer.
|
||||
/** @brief Converts a UTF8 string to a wide-char string in the buffer and advances the buffer.
|
||||
* It also swaps the bytes depending on the platform and Stream settings.
|
||||
*
|
||||
* \sa Endian
|
||||
* \param str The string to write to the buffer
|
||||
* \param fixedLen If not -1, the number of characters to zero-fill string to
|
||||
* @param str The string to write to the buffer
|
||||
* @param fixedLen If not -1, the number of characters to zero-fill string to
|
||||
*
|
||||
* Endianness is set with setEndian
|
||||
*/
|
||||
inline void writeStringAsWString(const std::string& str, atInt32 fixedLen = -1)
|
||||
{
|
||||
|
|
@ -483,6 +581,14 @@ public:
|
|||
}
|
||||
}
|
||||
|
||||
/** @brief Converts a UTF8 string to a wide-char string in the buffer and advances the buffer.
|
||||
* It also swaps the bytes depending on the platform and Stream settings.
|
||||
*
|
||||
* @param str The string to write to the buffer
|
||||
* @param fixedLen If not -1, the number of characters to zero-fill string to
|
||||
*
|
||||
* Endianness is little
|
||||
*/
|
||||
inline void writeStringAsWStringLittle(const std::string& str, atInt32 fixedLen = -1)
|
||||
{
|
||||
std::string tmpStr = "\xEF\xBB\xBF" + str;
|
||||
|
|
@ -531,6 +637,14 @@ public:
|
|||
}
|
||||
}
|
||||
|
||||
/** @brief Converts a UTF8 string to a wide-char string in the buffer and advances the buffer.
|
||||
* It also swaps the bytes depending on the platform and Stream settings.
|
||||
*
|
||||
* @param str The string to write to the buffer
|
||||
* @param fixedLen If not -1, the number of characters to zero-fill string to
|
||||
*
|
||||
* Endianness is big
|
||||
*/
|
||||
inline void writeStringAsWStringBig(const std::string& str, atInt32 fixedLen = -1)
|
||||
{
|
||||
std::string tmpStr = "\xEF\xBB\xBF" + str;
|
||||
|
|
@ -579,11 +693,10 @@ public:
|
|||
}
|
||||
}
|
||||
|
||||
/*! \brief Writes an string to the buffer and advances the buffer.
|
||||
/** @brief Writes an string to the buffer and advances the buffer.
|
||||
*
|
||||
* \sa Endian
|
||||
* \param str The string to write to the buffer
|
||||
* \param fixedLen If not -1, the number of characters to zero-fill string to
|
||||
* @param str The string to write to the buffer
|
||||
* @param fixedLen If not -1, the number of characters to zero-fill string to
|
||||
*/
|
||||
inline void writeString(const std::string& str, atInt32 fixedLen = -1)
|
||||
{
|
||||
|
|
@ -614,11 +727,12 @@ public:
|
|||
}
|
||||
inline void writeVal(const std::string& val) {return writeString(val);}
|
||||
|
||||
/*! \brief Writes an wstring to the buffer and advances the buffer.
|
||||
/** @brief Writes an wstring to the buffer and advances the buffer.
|
||||
*
|
||||
* \sa Endian
|
||||
* \param str The string to write to the buffer
|
||||
* \param fixedLen If not -1, the number of characters to zero-fill string to
|
||||
* @param str The string to write to the buffer
|
||||
* @param fixedLen If not -1, the number of characters to zero-fill string to
|
||||
*
|
||||
* Endianness is set with setEndian
|
||||
*/
|
||||
inline void writeWString(const std::wstring& str, atInt32 fixedLen = -1)
|
||||
{
|
||||
|
|
@ -649,6 +763,13 @@ public:
|
|||
}
|
||||
inline void writeVal(const std::wstring& val) {return writeWString(val);}
|
||||
|
||||
/** @brief Writes an wstring to the buffer and advances the buffer.
|
||||
*
|
||||
* @param str The string to write to the buffer
|
||||
* @param fixedLen If not -1, the number of characters to zero-fill string to
|
||||
*
|
||||
* Endianness is little
|
||||
*/
|
||||
inline void writeWStringLittle(const std::wstring& str, atInt32 fixedLen = -1)
|
||||
{
|
||||
if (fixedLen < 0)
|
||||
|
|
@ -678,6 +799,13 @@ public:
|
|||
}
|
||||
inline void writeValLittle(const std::wstring& val) {return writeWStringLittle(val);}
|
||||
|
||||
/** @brief Writes an wstring to the buffer and advances the buffer.
|
||||
*
|
||||
* @param str The string to write to the buffer
|
||||
* @param fixedLen If not -1, the number of characters to zero-fill string to
|
||||
*
|
||||
* Endianness is big
|
||||
*/
|
||||
inline void writeWStringBig(const std::wstring& str, atInt32 fixedLen = -1)
|
||||
{
|
||||
if (fixedLen < 0)
|
||||
|
|
@ -712,6 +840,11 @@ public:
|
|||
inline void fill(atInt8 val, atUint64 length)
|
||||
{fill((atUint8)val, length);}
|
||||
|
||||
/** @brief Performs automatic std::vector enumeration writes using numeric type T
|
||||
* @param vector The std::vector read from when writing data
|
||||
*
|
||||
* Endianness is set with setEndian
|
||||
*/
|
||||
template <class T>
|
||||
void enumerate(const std::vector<T>& vector,
|
||||
typename std::enable_if<std::is_arithmetic<T>::value ||
|
||||
|
|
@ -723,6 +856,11 @@ public:
|
|||
writeVal(item);
|
||||
}
|
||||
|
||||
/** @brief Performs automatic std::vector enumeration writes using numeric type T
|
||||
* @param vector The std::vector read from when writing data
|
||||
*
|
||||
* Endianness is little
|
||||
*/
|
||||
template <class T>
|
||||
void enumerateLittle(const std::vector<T>& vector,
|
||||
typename std::enable_if<std::is_arithmetic<T>::value ||
|
||||
|
|
@ -734,6 +872,11 @@ public:
|
|||
writeValLittle(item);
|
||||
}
|
||||
|
||||
/** @brief Performs automatic std::vector enumeration writes using numeric type T
|
||||
* @param vector The std::vector read from when writing data
|
||||
*
|
||||
* Endianness is big
|
||||
*/
|
||||
template <class T>
|
||||
void enumerateBig(const std::vector<T>& vector,
|
||||
typename std::enable_if<std::is_arithmetic<T>::value ||
|
||||
|
|
@ -745,6 +888,9 @@ public:
|
|||
writeValBig(item);
|
||||
}
|
||||
|
||||
/** @brief Performs automatic std::vector enumeration writes using non-numeric type T
|
||||
* @param vector The std::vector read from when writing data
|
||||
*/
|
||||
template <class T>
|
||||
void enumerate(const std::vector<T>& vector,
|
||||
typename std::enable_if<!std::is_arithmetic<T>::value &&
|
||||
|
|
|
|||
Loading…
Reference in New Issue