Initial commit
This commit is contained in:
279
Include/ZUtil/ZBinaryWriter.hpp
Normal file
279
Include/ZUtil/ZBinaryWriter.hpp
Normal file
@@ -0,0 +1,279 @@
|
||||
/*
|
||||
ZBinaryWriter.hpp
|
||||
Author: Patrick Baggett <ptbaggett@762studios.com>
|
||||
Created: 3/11/2013
|
||||
|
||||
Purpose:
|
||||
|
||||
Binary stream writer interface
|
||||
|
||||
License:
|
||||
|
||||
TODO
|
||||
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#ifndef _ZBINARYWRITER_HPP
|
||||
#define _ZBINARYWRITER_HPP
|
||||
|
||||
#include <SST/SST_Endian.h>
|
||||
#include <pstdint.h>
|
||||
|
||||
class ZBinaryWriter
|
||||
{
|
||||
|
||||
public:
|
||||
ZBinaryWriter(SST_ByteOrder streamOrder) :
|
||||
streamByteOrder(streamOrder)
|
||||
{
|
||||
}
|
||||
|
||||
//=====================================================================
|
||||
//SINGLE ELEMENT WRITE
|
||||
//=====================================================================
|
||||
virtual void WriteU8(uint8_t v) = 0;
|
||||
virtual void WriteU16(uint16_t v) = 0;
|
||||
virtual void WriteU32(uint32_t v) = 0;
|
||||
virtual void WriteU64(uint64_t v) = 0;
|
||||
void WriteF32(float v) { WriteU32(cast_f2i(v)); }
|
||||
void WriteF64(double v) { WriteU64(cast_d2i(v)); }
|
||||
|
||||
//=====================================================================
|
||||
//ARRAY WRITE
|
||||
//=====================================================================
|
||||
/*
|
||||
virtual public ZBinaryWriter::WriteU8Array
|
||||
|
||||
Writes an array of 8-bit unsigned values to the stream.
|
||||
|
||||
@param v - The base of the array
|
||||
@param count - Number of elements to write
|
||||
@return (void)
|
||||
*/
|
||||
virtual void WriteU8Array(const uint8_t* v, size_t count) = 0;
|
||||
|
||||
/*
|
||||
virtual public ZBinaryWriter::WriteU16Array
|
||||
|
||||
Writes an array of 16-bit unsigned values to the stream.
|
||||
|
||||
@param v - The base of the array
|
||||
@param count - Number of elements to write
|
||||
@return (void)
|
||||
*/
|
||||
virtual void WriteU16Array(const uint16_t* v, size_t count) = 0;
|
||||
|
||||
/*
|
||||
virtual public ZBinaryWriter::WriteU32Array
|
||||
|
||||
Writes an array of 32-bit unsigned values to the stream.
|
||||
|
||||
@param v - The base of the array
|
||||
@param count - Number of elements to write
|
||||
@return (void)
|
||||
*/
|
||||
virtual void WriteU32Array(const uint32_t* v, size_t count) = 0;
|
||||
|
||||
/*
|
||||
virtual public ZBinaryWriter::WriteU64Array
|
||||
|
||||
Writes an array of 64-bit unsigned values to the stream.
|
||||
|
||||
@param v - The base of the array
|
||||
@param count - Number of elements to write
|
||||
@return (void)
|
||||
*/
|
||||
virtual void WriteU64Array(const uint64_t* v, size_t count) = 0;
|
||||
|
||||
/*
|
||||
public ZBinaryWriter::WriteF32Array
|
||||
|
||||
Writes an array of 32-bit floating point values to the stream.
|
||||
|
||||
@param v - The base of the array
|
||||
@param count - Number of elements to write
|
||||
@return (void)
|
||||
*/
|
||||
void WriteF32Array(const float* v, size_t count) { WriteU32Array((uint32_t*)v, count); }
|
||||
|
||||
/*
|
||||
public ZBinaryWriter::WriteF64Array
|
||||
|
||||
Writes an array of 64-bit floating point values to the stream.
|
||||
|
||||
@param v - The base of the array
|
||||
@param count - Number of elements to write
|
||||
@return (void)
|
||||
*/
|
||||
void WriteF64Array(const double* v, size_t count) { WriteU64Array((uint64_t*)v, count); }
|
||||
|
||||
//=====================================================================
|
||||
//STREAM SEEKING / POSITIONING
|
||||
//=====================================================================
|
||||
/*
|
||||
virtual public ZBinaryReader::GetOffset
|
||||
|
||||
Gets the current (zero-based) offset into the stream from which the next read will
|
||||
be performed.
|
||||
|
||||
@return (size_t) - The offset.
|
||||
*/
|
||||
virtual size_t GetOffset() const = 0;
|
||||
|
||||
/*
|
||||
public ZBinaryReader::SeekForward
|
||||
|
||||
Advances the offset into the stream by the given number of bytes.
|
||||
No validation is performed.
|
||||
|
||||
@param amount - The amount of seek forward by.
|
||||
@return (void)
|
||||
*/
|
||||
void SeekForward(size_t amount) { SeekTo(GetOffset() + amount); }
|
||||
|
||||
/*
|
||||
public ZBinaryReader::SeekBackward
|
||||
|
||||
Rewinds the offset into the stream by the given number of bytes.
|
||||
No validation is performed.
|
||||
|
||||
@param amount - The amount of seek backward by.
|
||||
@return (void)
|
||||
*/
|
||||
void SeekBackward(size_t amount) { SeekTo(GetOffset() - amount); }
|
||||
|
||||
/*
|
||||
virtual public ZBinaryReader::SeekTo
|
||||
|
||||
Directly sets the offset into the stream from which reads will occur.
|
||||
No validation is performed.
|
||||
|
||||
@param offset - The new offset
|
||||
@return (void)
|
||||
*/
|
||||
virtual void SeekTo(size_t offset) = 0;
|
||||
|
||||
/*
|
||||
public ZBinaryReader::Rewind
|
||||
|
||||
Sets the offset to the start of the stream
|
||||
|
||||
@param offset - The new offset
|
||||
@return (void)
|
||||
*/
|
||||
void Rewind() { SeekTo(0); }
|
||||
|
||||
//=====================================================================
|
||||
//TYPED ALIASES
|
||||
//=====================================================================
|
||||
/*
|
||||
public ZBinaryWriter::WriteI8
|
||||
|
||||
Writes a single signed 8-bit value to the stream.
|
||||
|
||||
@param v - value read to write to the stream
|
||||
*/
|
||||
void WriteI8(int8_t v) { return WriteU8((uint8_t)v); }
|
||||
|
||||
/*
|
||||
public ZBinaryWriter::WriteI16
|
||||
|
||||
Writes a single signed 16-bit value to the stream.
|
||||
|
||||
@param v - value read to write to the stream
|
||||
*/
|
||||
void WriteI16(int16_t v) { return WriteU16((uint16_t)v); }
|
||||
|
||||
/*
|
||||
public ZBinaryWriter::WriteI32
|
||||
|
||||
Writes a single signed 32-bit value to the stream.
|
||||
|
||||
@param v - value read to write to the stream
|
||||
*/
|
||||
void WriteI32(int32_t v) { return WriteU32((uint32_t)v); }
|
||||
|
||||
/*
|
||||
public ZBinaryWriter::WriteI64
|
||||
|
||||
Writes a single signed 64-bit value to the stream.
|
||||
|
||||
@param v - value read to write to the stream
|
||||
*/
|
||||
void WriteI64(int64_t v) { return WriteU64((uint64_t)v); }
|
||||
|
||||
/*
|
||||
public ZBinaryWriter::WriteI8Array
|
||||
|
||||
Writes an array of 8-bit signed values to the stream.
|
||||
|
||||
@param v - The base of the array
|
||||
@param count - Number of elements to write
|
||||
@return (void)
|
||||
*/
|
||||
void WriteI8Array(const int8_t* v, size_t count) { return WriteU8Array((const uint8_t*)v, count); }
|
||||
|
||||
/*
|
||||
public ZBinaryWriter::WriteI16Array
|
||||
|
||||
Writes an array of 16-bit signed values to the stream.
|
||||
|
||||
@param v - The base of the array
|
||||
@param count - Number of elements to write
|
||||
@return (void)
|
||||
*/
|
||||
void WriteI16Array(const int16_t* v, size_t count) { return WriteU16Array((const uint16_t*)v, count); }
|
||||
|
||||
/*
|
||||
public ZBinaryWriter::WriteI32Array
|
||||
|
||||
Writes an array of 32-bit signed values to the stream.
|
||||
|
||||
@param v - The base of the array
|
||||
@param count - Number of elements to write
|
||||
@return (void)
|
||||
*/
|
||||
void WriteI32Array(const int32_t* v, size_t count) { return WriteU32Array((const uint32_t*)v, count); }
|
||||
|
||||
/*
|
||||
public ZBinaryWriter::WriteI64Array
|
||||
|
||||
Writes an array of 64-bit signed values to the stream.
|
||||
|
||||
@param v - The base of the array
|
||||
@param count - Number of elements to write
|
||||
@return (void)
|
||||
*/
|
||||
void WriteI64Array(const int64_t* v, size_t count) { return WriteU64Array((const uint64_t*)v, count); }
|
||||
|
||||
//=====================================================================
|
||||
//GETTERS / SETTERS
|
||||
//=====================================================================
|
||||
/*
|
||||
public ZBinaryReader::GetStreamByteOrder
|
||||
|
||||
Gets the byte order in which the stream (source data) is read as.
|
||||
|
||||
@return (SST_ByteOrder) - The byte order
|
||||
*/
|
||||
SST_ByteOrder GetStreamByteOrder() const { return streamByteOrder; }
|
||||
|
||||
/*
|
||||
public ZBinaryReader::SetStreamByteOrder
|
||||
|
||||
Sets the byte order in which the stream (source data) is read as.
|
||||
|
||||
@param newOrder - The new byte order
|
||||
@return (void)
|
||||
*/
|
||||
void SetStreamByteOrder(SST_ByteOrder newOrder) { streamByteOrder = newOrder; }
|
||||
|
||||
private:
|
||||
SST_ByteOrder streamByteOrder; //The current byte order the stream is being read in.
|
||||
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
Reference in New Issue
Block a user