Splitting Math into a separate subproject and adding FileIO as a PWE subproject

src/FileIO/CFileInStream.cpp

@@ -0,0 +1,112 @@
+#include "CFileInStream.h"
+
+CFileInStream::CFileInStream()
+{
+    mFStream = nullptr;
+}
+
+CFileInStream::CFileInStream(std::string File)
+{
+    mFStream = nullptr;
+    Open(File, IOUtil::BigEndian);
+}
+
+CFileInStream::CFileInStream(std::string File, IOUtil::EEndianness FileEndianness)
+{
+    mFStream = nullptr;
+    Open(File, FileEndianness);
+}
+
+CFileInStream::CFileInStream(CFileInStream& src)
+{
+    mFStream = nullptr;
+    Open(src.mName, src.mDataEndianness);
+
+    if (src.IsValid())
+        Seek(src.Tell(), SEEK_SET);
+}
+
+CFileInStream::~CFileInStream()
+{
+    if (IsValid())
+        Close();
+}
+
+void CFileInStream::Open(std::string File, IOUtil::EEndianness FileEndianness)
+{
+    if (IsValid())
+        Close();
+
+    fopen_s(&mFStream, File.c_str(), "rb");
+    mName = File;
+    mDataEndianness = FileEndianness;
+
+    if (IsValid())
+    {
+        Seek(0x0, SEEK_END);
+        mFileSize = Tell();
+        Seek(0x0, SEEK_SET);
+    }
+    else
+        mFileSize = 0;
+
+    size_t EndPath = File.find_last_of("\\/");
+    SetSourceString(File.substr(EndPath + 1, File.length() - EndPath));
+}
+
+void CFileInStream::Close()
+{
+    if (IsValid())
+        fclose(mFStream);
+    mFStream = nullptr;
+}
+
+void CFileInStream::ReadBytes(void *dst, unsigned long Count)
+{
+    if (!IsValid()) return;
+    fread(dst, 1, Count, mFStream);
+}
+
+bool CFileInStream::Seek(long Offset, long Origin)
+{
+    if (!IsValid()) return false;
+    return (fseek(mFStream, Offset, Origin) != 0);
+}
+
+bool CFileInStream::Seek64(long long Offset, long Origin)
+{
+    if (!IsValid()) return false;
+    return (_fseeki64(mFStream, Offset, Origin) != 0);
+}
+
+long CFileInStream::Tell() const
+{
+    if (!IsValid()) return 0;
+    return ftell(mFStream);
+}
+
+long long CFileInStream::Tell64() const
+{
+    if (!IsValid()) return 0;
+    return _ftelli64(mFStream);
+}
+
+bool CFileInStream::EoF() const
+{
+    return (Tell() >= mFileSize);
+}
+
+bool CFileInStream::IsValid() const
+{
+    return (mFStream != 0);
+}
+
+long CFileInStream::Size() const
+{
+    return mFileSize;
+}
+
+std::string CFileInStream::FileName() const
+{
+    return mName;
+}

src/FileIO/CFileInStream.h

@@ -0,0 +1,34 @@
+#ifndef CFILEINSTREAM_H
+#define CFILEINSTREAM_H
+
+#include "CInputStream.h"
+#include "IOUtil.h"
+
+class CFileInStream : public CInputStream
+{
+private:
+    FILE *mFStream;
+    std::string mName;
+    long mFileSize;
+
+public:
+    CFileInStream();
+    CFileInStream(std::string file);
+    CFileInStream(std::string file, IOUtil::EEndianness FileEndianness);
+    CFileInStream(CFileInStream& src);
+    ~CFileInStream();
+    void Open(std::string file, IOUtil::EEndianness FileEndianness);
+    void Close();
+
+    void ReadBytes(void *dst, unsigned long count);
+    bool Seek(long offset, long origin);
+    bool Seek64(long long offset, long origin);
+    long Tell() const;
+    long long Tell64() const;
+    bool EoF() const;
+    bool IsValid() const;
+    long Size() const;
+    std::string FileName() const;
+};
+
+#endif // CFILEINSTREAM_H

src/FileIO/CFileOutStream.cpp

@@ -0,0 +1,118 @@
+#include "CFileOutStream.h"
+
+CFileOutStream::CFileOutStream()
+{
+    mFStream = nullptr;
+    mSize = 0;
+}
+
+CFileOutStream::CFileOutStream(std::string File)
+{
+    mFStream = nullptr;
+    Open(File, IOUtil::BigEndian);
+}
+
+CFileOutStream::CFileOutStream(std::string File, IOUtil::EEndianness FileEndianness)
+{
+    mFStream = nullptr;
+    Open(File, FileEndianness);
+}
+
+CFileOutStream::CFileOutStream(CFileOutStream& src)
+{
+    mFStream = nullptr;
+    Open(src.mName, src.mDataEndianness);
+
+    if (src.IsValid())
+        Seek(src.Tell(), SEEK_SET);
+}
+
+CFileOutStream::~CFileOutStream()
+{
+    if (IsValid())
+        Close();
+}
+
+void CFileOutStream::Open(std::string File, IOUtil::EEndianness FileEndianness)
+{
+    if (IsValid())
+        Close();
+
+    fopen_s(&mFStream, File.c_str(), "wb");
+    mName = File;
+    mDataEndianness = FileEndianness;
+    mSize = 0;
+}
+
+void CFileOutStream::Update(std::string File, IOUtil::EEndianness FileEndianness)
+{
+    if (IsValid())
+        Close();
+
+    fopen_s(&mFStream, File.c_str(), "rb+");
+    mName = File;
+    mDataEndianness = FileEndianness;
+    Seek(0x0, SEEK_END);
+    mSize = Tell();
+    Seek(0x0, SEEK_SET);
+}
+
+void CFileOutStream::Close()
+{
+    if (IsValid())
+        fclose(mFStream);
+    mFStream = nullptr;
+    mSize = 0;
+}
+
+void CFileOutStream::WriteBytes(void *src, unsigned long Count)
+{
+    if (!IsValid()) return;
+    fwrite(src, 1, Count, mFStream);
+    if ((unsigned long) Tell() > mSize) mSize = Tell();
+}
+
+bool CFileOutStream::Seek(long Offset, long Origin)
+{
+    if (!IsValid()) return false;
+    return (fseek(mFStream, Offset, Origin) != 0);
+}
+
+bool CFileOutStream::Seek64(long long Offset, long Origin)
+{
+    if (!IsValid()) return false;
+    return (_fseeki64(mFStream, Offset, Origin) != 0);
+}
+
+long CFileOutStream::Tell() const
+{
+    if (!IsValid()) return 0;
+    return ftell(mFStream);
+}
+
+long long CFileOutStream::Tell64() const
+{
+    if (!IsValid()) return 0;
+    return _ftelli64(mFStream);
+}
+
+bool CFileOutStream::EoF() const
+{
+    return (Tell() == Size());
+}
+
+bool CFileOutStream::IsValid() const
+{
+    return (mFStream != 0);
+}
+
+long CFileOutStream::Size() const
+{
+    if (!IsValid()) return 0;
+    return mSize;
+}
+
+std::string CFileOutStream::FileName() const
+{
+    return mName;
+}

src/FileIO/CFileOutStream.h

@@ -0,0 +1,35 @@
+#ifndef CFILEOUTSTREAM_H
+#define CFILEOUTSTREAM_H
+
+#include "COutputStream.h"
+#include "IOUtil.h"
+
+class CFileOutStream : public COutputStream
+{
+private:
+    FILE *mFStream;
+    std::string mName;
+    unsigned long mSize;
+
+public:
+    CFileOutStream();
+    CFileOutStream(std::string file);
+    CFileOutStream(std::string file, IOUtil::EEndianness FileEndianness);
+    CFileOutStream(CFileOutStream& src);
+    ~CFileOutStream();
+    void Open(std::string file, IOUtil::EEndianness);
+    void Update(std::string file, IOUtil::EEndianness FileEndianness);
+    void Close();
+
+    void WriteBytes(void *src, unsigned long count);
+    bool Seek(long offset, long origin);
+    bool Seek64(long long offset, long origin);
+    long Tell() const;
+    long long Tell64() const;
+    bool EoF() const;
+    bool IsValid() const;
+    long Size() const;
+    std::string FileName() const;
+};
+
+#endif // CFILEOUTSTREAM_H

src/FileIO/CInputStream.cpp

@@ -0,0 +1,180 @@
+#include "CInputStream.h"
+
+CInputStream::~CInputStream()
+{
+}
+
+char CInputStream::ReadByte()
+{
+    char Val;
+    ReadBytes(&Val, 1);
+    return Val;
+}
+
+short CInputStream::ReadShort()
+{
+    short Val;
+    ReadBytes(&Val, 2);
+    if (mDataEndianness != IOUtil::SystemEndianness) IOUtil::SwapBytes(Val);
+    return Val;
+}
+
+long CInputStream::ReadLong()
+{
+    long Val;
+    ReadBytes(&Val, 4);
+    if (mDataEndianness != IOUtil::SystemEndianness) IOUtil::SwapBytes(Val);
+    return Val;
+}
+
+long long CInputStream::ReadLongLong()
+{
+    long long Val;
+    ReadBytes(&Val, 8);
+    if (mDataEndianness != IOUtil::SystemEndianness) IOUtil::SwapBytes(Val);
+    return Val;
+}
+
+float CInputStream::ReadFloat()
+{
+    float Val;
+    ReadBytes(&Val, 4);
+    if (mDataEndianness != IOUtil::SystemEndianness) IOUtil::SwapBytes(Val);
+    return Val;
+}
+
+double CInputStream::ReadDouble()
+{
+    double Val;
+    ReadBytes(&Val, 8);
+    if (mDataEndianness != IOUtil::SystemEndianness) IOUtil::SwapBytes(Val);
+    return Val;
+}
+
+std::string CInputStream::ReadString()
+{
+    std::string Str;
+    char c = 1;
+
+    while ((c != 0) && (!EoF()))
+    {
+        c = ReadByte();
+        if (c != 0) Str.push_back(c);
+    }
+
+    return Str;
+}
+
+std::string CInputStream::ReadString(unsigned long Count)
+{
+    std::string Str(Count, 0);
+
+    for (unsigned long c = 0; c < Count; c++)
+        Str[c] = ReadByte();
+
+    return Str;
+}
+
+std::wstring CInputStream::ReadWString()
+{
+    std::wstring WStr;
+    short c = 1;
+
+    while (c != 0)
+    {
+        c = ReadShort();
+        if (c != 0) WStr.push_back(c);
+    }
+
+    return WStr;
+}
+
+std::wstring CInputStream::ReadWString(unsigned long Count)
+{
+    std::wstring WStr(Count, 0);
+
+    for (unsigned long c = 0; c < Count; c++)
+        WStr[c] = ReadShort();
+
+    return WStr;
+}
+
+
+char CInputStream::PeekByte()
+{
+    char Val = ReadByte();
+    Seek(-1, SEEK_CUR);
+    return Val;
+}
+
+short CInputStream::PeekShort()
+{
+    short Val = ReadShort();
+    Seek(-2, SEEK_CUR);
+    return Val;
+}
+
+long CInputStream::PeekLong()
+{
+    long Val = ReadLong();
+    Seek(-4, SEEK_CUR);
+    return Val;
+}
+
+long long CInputStream::PeekLongLong()
+{
+    long long Val = ReadLongLong();
+    Seek(-8, SEEK_CUR);
+    return Val;
+}
+
+float CInputStream::PeekFloat()
+{
+    float Val = ReadFloat();
+    Seek(-4, SEEK_CUR);
+    return Val;
+}
+
+double CInputStream::PeekDouble()
+{
+    double Val = ReadDouble();
+    Seek(-8, SEEK_CUR);
+    return Val;
+}
+
+void CInputStream::SeekToBoundary(unsigned long Boundary)
+{
+    long Num = Boundary - (Tell() % Boundary);
+    if (Num == Boundary) return;
+    else Seek(Num, SEEK_CUR);
+}
+
+void CInputStream::SetEndianness(IOUtil::EEndianness Endianness)
+{
+    mDataEndianness = Endianness;
+}
+
+void CInputStream::SetSourceString(const std::string& source)
+{
+    mDataSource = source;
+}
+
+IOUtil::EEndianness CInputStream::GetEndianness() const
+{
+    return mDataEndianness;
+}
+
+std::string CInputStream::GetSourceString() const
+{
+    return mDataSource;
+}
+
+bool CInputStream::Seek64(long long Offset, long Origin)
+{
+    return Seek((long) Offset, Origin);
+}
+
+long long CInputStream::Tell64() const
+{
+    return (long long) Tell();
+}

src/FileIO/CInputStream.h

@@ -0,0 +1,50 @@
+#ifndef CINPUTSTREAM_H
+#define CINPUTSTREAM_H
+
+#include "IOUtil.h"
+#include <string>
+#include <vector>
+
+class CInputStream
+{
+protected:
+    IOUtil::EEndianness mDataEndianness;
+    std::string mDataSource;
+    
+public:
+    char ReadByte();
+    short ReadShort();
+    long ReadLong();
+    long long ReadLongLong();
+    float ReadFloat();
+    double ReadDouble();
+    std::string ReadString();
+    std::string ReadString(unsigned long count);
+    std::wstring ReadWString();
+    std::wstring ReadWString(unsigned long count);
+
+    char PeekByte();
+    short PeekShort();
+    long PeekLong();
+    long long PeekLongLong();
+    float PeekFloat();
+    double PeekDouble();
+
+    void SeekToBoundary(unsigned long boundary);
+    void SetEndianness(IOUtil::EEndianness endianness);
+    void SetSourceString(const std::string& source);
+    IOUtil::EEndianness GetEndianness() const;
+    std::string GetSourceString() const;
+
+    virtual ~CInputStream();
+    virtual void ReadBytes(void *dst, unsigned long count) = 0;
+    virtual bool Seek(long offset, long origin) = 0;
+    virtual bool Seek64(long long offset, long origin);
+    virtual long Tell() const = 0;
+    virtual long long Tell64() const;
+    virtual bool EoF() const = 0;
+    virtual bool IsValid() const = 0;
+    virtual long Size() const = 0;
+};
+
+#endif // CINPUTSTREAM_H

src/FileIO/CMemoryInStream.cpp

@@ -0,0 +1,102 @@
+#include "CMemoryInStream.h"
+
+CMemoryInStream::CMemoryInStream()
+{
+    mDataStart = nullptr;
+    mDataSize = 0;
+    mPos = 0;
+}
+CMemoryInStream::CMemoryInStream(void *Data, unsigned long Size, IOUtil::EEndianness DataEndianness)
+{
+    SetData(Data, Size, DataEndianness);
+}
+
+CMemoryInStream::~CMemoryInStream()
+{
+}
+
+void CMemoryInStream::SetData(void *Data, unsigned long Size, IOUtil::EEndianness DataEndianness)
+{
+    mDataStart = static_cast<char*>(Data);
+    mDataSize = Size;
+    mPos = 0;
+    mDataEndianness = DataEndianness;
+}
+
+void CMemoryInStream::ReadBytes(void *dst, unsigned long Count)
+{
+    if (!IsValid()) return;
+    memcpy(dst, mDataStart + mPos, Count);
+    mPos += Count;
+}
+
+bool CMemoryInStream::Seek(long Offset, long Origin)
+{
+    if (!IsValid()) return false;
+    switch (Origin)
+    {
+        case SEEK_SET:
+            mPos = Offset;
+            break;
+
+        case SEEK_CUR:
+            mPos += Offset;
+            break;
+
+        case SEEK_END:
+            mPos = mDataSize - Offset;
+            break;
+
+        default:
+            return false;
+    }
+
+    if (mPos < 0) {
+        mPos = 0;
+        return false;
+    }
+
+    if (mPos > mDataSize) {
+        mPos = mDataSize;
+        return false;
+    }
+
+    return true;
+}
+
+long CMemoryInStream::Tell() const
+{
+    return mPos;
+}
+
+bool CMemoryInStream::EoF() const
+{
+    return (mPos >= mDataSize);
+}
+
+bool CMemoryInStream::IsValid() const
+{
+    return (mDataStart != nullptr);
+}
+
+long CMemoryInStream::Size() const
+{
+    return mDataSize;
+}
+
+void CMemoryInStream::SetSize(unsigned long Size)
+{
+    mDataSize = Size;
+    if (mPos > mDataSize)
+        mPos = mDataSize;
+}
+
+void* CMemoryInStream::Data() const
+{
+    return mDataStart;
+}
+
+void* CMemoryInStream::DataAtPosition() const
+{
+    return mDataStart + mPos;
+}

src/FileIO/CMemoryInStream.h

@@ -0,0 +1,30 @@
+#ifndef CMEMORYINSTREAM_H
+#define CMEMORYINSTREAM_H
+
+#include "CInputStream.h"
+#include "IOUtil.h"
+
+class CMemoryInStream : public CInputStream
+{
+    char *mDataStart;
+    long mDataSize;
+    long mPos;
+
+public:
+    CMemoryInStream();
+    CMemoryInStream(void *Data, unsigned long Size, IOUtil::EEndianness dataEndianness);
+    ~CMemoryInStream();
+    void SetData(void *Data, unsigned long Size, IOUtil::EEndianness dataEndianness);
+
+    void ReadBytes(void *dst, unsigned long Count);
+    bool Seek(long offset, long Origin);
+    long Tell() const;
+    bool EoF() const;
+    bool IsValid() const;
+    long Size() const;
+    void SetSize(unsigned long Size);
+    void* Data() const;
+    void* DataAtPosition() const;
+};
+
+#endif // CMEMORYINSTREAM_H

src/FileIO/CMemoryOutStream.cpp

@@ -0,0 +1,113 @@
+#include "CMemoryOutStream.h"
+
+CMemoryOutStream::CMemoryOutStream()
+{
+    mDataStart = nullptr;
+    mDataSize = 0;
+    mPos = 0;
+    mUsed = 0;
+}
+
+CMemoryOutStream::CMemoryOutStream(void *Data, unsigned long Size, IOUtil::EEndianness DataEndianness)
+{
+    SetData(Data, Size, DataEndianness);
+}
+
+CMemoryOutStream::~CMemoryOutStream()
+{
+}
+
+void CMemoryOutStream::SetData(void *Data, unsigned long Size, IOUtil::EEndianness DataEndianness)
+{
+    mDataStart = static_cast<char*>(Data);
+    mDataSize = Size;
+    mPos = 0;
+    mUsed = 0;
+    mDataEndianness = DataEndianness;
+}
+
+void CMemoryOutStream::WriteBytes(void *src, unsigned long Count)
+{
+    if (!IsValid()) return;
+
+    memcpy(mDataStart + mPos, src, Count);
+    mPos += Count;
+    if (mPos > mUsed) mUsed = mPos;
+}
+
+bool CMemoryOutStream::Seek(long Offset, long Origin)
+{
+    if (!IsValid()) return false;
+
+    switch (Origin)
+    {
+        case SEEK_SET:
+            mPos = Offset;
+            break;
+
+        case SEEK_CUR:
+            mPos += Offset;
+            break;
+
+        case SEEK_END:
+            mPos = mDataSize - Offset;
+            break;
+
+        default:
+            return false;
+    }
+
+    if (mPos < 0) {
+        mPos = 0;
+        return false;
+    }
+
+    if (mPos > mDataSize) {
+        mPos = mDataSize;
+        return false;
+    }
+
+    return true;
+}
+
+long CMemoryOutStream::Tell() const
+{
+    return mPos;
+}
+
+bool CMemoryOutStream::EoF() const
+{
+    return (mPos >= mDataSize);
+}
+
+bool CMemoryOutStream::IsValid() const
+{
+    return (mDataStart != nullptr);
+}
+
+long CMemoryOutStream::Size() const
+{
+    return mDataSize;
+}
+
+long CMemoryOutStream::SpaceUsed() const
+{
+    return mUsed;
+}
+
+void CMemoryOutStream::SetSize(unsigned long Size)
+{
+    mDataSize = Size;
+    if (mPos > mDataSize)
+        mPos = mDataSize;
+}
+
+void* CMemoryOutStream::Data() const
+{
+    return mDataStart;
+}
+
+void* CMemoryOutStream::DataAtPosition() const
+{
+    return mDataStart + mPos;
+}

src/FileIO/CMemoryOutStream.h

@@ -0,0 +1,31 @@
+#ifndef CMEMORYOUTSTREAM_H
+#define CMEMORYOUTSTREAM_H
+
+#include "COutputStream.h"
+
+class CMemoryOutStream : public COutputStream
+{
+    char *mDataStart;
+    long mDataSize;
+    long mPos;
+    long mUsed;
+
+public:
+    CMemoryOutStream();
+    CMemoryOutStream(void *Data, unsigned long Size, IOUtil::EEndianness mDataEndianness);
+    ~CMemoryOutStream();
+    void SetData(void *Data, unsigned long Size, IOUtil::EEndianness mDataEndianness);
+
+    void WriteBytes(void *src, unsigned long count);
+    bool Seek(long offset, long origin);
+    long Tell() const;
+    bool EoF() const;
+    bool IsValid() const;
+    long Size() const;
+    long SpaceUsed() const;
+    void SetSize(unsigned long Size);
+    void* Data() const;
+    void* DataAtPosition() const;
+};
+
+#endif // CMEMORYOUTSTREAM_H

src/FileIO/COutputStream.cpp

@@ -0,0 +1,114 @@
+#include "COutputStream.h"
+
+COutputStream::~COutputStream()
+{
+}
+
+void COutputStream::WriteByte(char Val)
+{
+    WriteBytes(&Val, 1);
+}
+
+void COutputStream::WriteShort(short Val)
+{
+    if (mDataEndianness != IOUtil::SystemEndianness) IOUtil::SwapBytes(Val);
+    WriteBytes(&Val, 2);
+}
+
+void COutputStream::WriteLong(long Val)
+{
+    if (mDataEndianness != IOUtil::SystemEndianness) IOUtil::SwapBytes(Val);
+    WriteBytes(&Val, 4);
+}
+
+void COutputStream::WriteLongLong(long long Val)
+{
+    if (mDataEndianness != IOUtil::SystemEndianness) IOUtil::SwapBytes(Val);
+    WriteBytes(&Val, 8);
+}
+
+void COutputStream::WriteFloat(float Val)
+{
+    if (mDataEndianness != IOUtil::SystemEndianness) IOUtil::SwapBytes(Val);
+    WriteBytes(&Val, 4);
+}
+
+void COutputStream::WriteDouble(double Val)
+{
+    if (mDataEndianness != IOUtil::SystemEndianness) IOUtil::SwapBytes(Val);
+    WriteBytes(&Val, 8);
+}
+
+void COutputStream::WriteString(std::string Val)
+{
+    for (unsigned int i = 0; i < Val.size(); i++)
+        WriteByte(Val[i]);
+
+    if ((Val.empty()) || (Val.back() != '\0'))
+        WriteByte(0);
+}
+
+void COutputStream::WriteString(std::string Val, unsigned long Count, bool Terminate)
+{
+    for (unsigned int i = 0; i < Count; i++)
+        WriteByte(Val[i]);
+
+    if (Terminate && (Val[Count-1] != '\0'))
+        WriteByte(0);
+}
+
+void COutputStream::WriteWString(std::wstring Val)
+{
+    for (unsigned int i = 0; i < Val.size(); i++)
+        WriteShort(Val[i]);
+
+    if ((!Val.empty()) && (Val.back() != '\0'))
+        WriteShort(0);
+}
+
+void COutputStream::WriteWString(std::wstring Val, unsigned long Count, bool Terminate)
+{
+    for (unsigned int i = 0; i < Count; i++)
+        WriteShort(Val[i]);
+
+    if (Terminate && (Val[Count-1] != 0))
+        WriteShort(0);
+}
+
+void COutputStream::WriteToBoundary(unsigned long Boundary, char Fill)
+{
+    long Num = Boundary - (Tell() % Boundary);
+    if (Num == Boundary) return;
+    for (int i = 0; i < Num; i++)
+        WriteByte(Fill);
+}
+
+void COutputStream::SetEndianness(IOUtil::EEndianness Endianness)
+{
+    mDataEndianness = Endianness;
+}
+
+void COutputStream::SetDestString(const std::string &Dest)
+{
+    mDataDest = Dest;
+}
+
+IOUtil::EEndianness COutputStream::GetEndianness() const
+{
+    return mDataEndianness;
+}
+
+std::string COutputStream::GetDestString() const
+{
+    return mDataDest;
+}
+
+bool COutputStream::Seek64(long long Offset, long Origin)
+{
+    return Seek((long) Offset, Origin);
+}
+
+long long COutputStream::Tell64() const
+{
+    return (long long) (Tell());
+}

src/FileIO/COutputStream.h

@@ -0,0 +1,41 @@
+#ifndef COUTPUTSTREAM_H
+#define COUTPUTSTREAM_H
+
+#include "IOUtil.h"
+#include <string>
+
+class COutputStream
+{
+protected:
+    IOUtil::EEndianness mDataEndianness;
+    std::string mDataDest;
+
+public:
+    void WriteByte(char Val);
+    void WriteShort(short Val);
+    void WriteLong(long Val);
+    void WriteLongLong(long long Val);
+    void WriteFloat(float Val);
+    void WriteDouble(double Val);
+    void WriteString(std::string Val);
+    void WriteString(std::string Val, unsigned long Count, bool Terminate = false);
+    void WriteWString(std::wstring Val);
+    void WriteWString(std::wstring Val, unsigned long Count, bool Terminate = false);
+
+    void WriteToBoundary(unsigned long Boundary, char Fill);
+    void SetEndianness(IOUtil::EEndianness Endianness);
+    void SetDestString(const std::string& Dest);
+    IOUtil::EEndianness GetEndianness() const;
+    std::string GetDestString() const;
+
+    virtual ~COutputStream();
+    virtual void WriteBytes(void *src, unsigned long Count) = 0;
+    virtual bool Seek(long Offset, long Origin) = 0;
+    virtual bool Seek64(long long Offset, long Origin);
+    virtual long Tell() const = 0;
+    virtual long long Tell64() const;
+    virtual bool EoF() const = 0;
+    virtual bool IsValid() const = 0;
+    virtual long Size() const = 0;
+};
+#endif // COUTPUTSTREAM_H

src/FileIO/CTextInStream.cpp

@@ -0,0 +1,100 @@
+#include "CTextInStream.h"
+#include <stdarg.h>
+#include <stdio.h>
+
+CTextInStream::CTextInStream(std::string File)
+{
+    mFStream = nullptr;
+    Open(File);
+}
+
+CTextInStream::CTextInStream(CTextInStream& src)
+{
+    mFStream = nullptr;
+    Open(src.mFileName);
+
+    if (src.IsValid())
+        Seek(src.Tell(), SEEK_SET);
+}
+
+CTextInStream::~CTextInStream()
+{
+    if (IsValid())
+        Close();
+}
+
+void CTextInStream::Open(std::string File)
+{
+    if (IsValid())
+        Close();
+
+    fopen_s(&mFStream, File.c_str(), "r");
+    mFileName = File;
+
+    if (IsValid())
+    {
+        Seek(0x0, SEEK_END);
+        mFileSize = Tell();
+        Seek(0x0, SEEK_SET);
+    }
+    else
+        mFileSize = 0;
+}
+
+void CTextInStream::Close()
+{
+    if (IsValid())
+        fclose(mFStream);
+    mFStream = nullptr;
+}
+
+void CTextInStream::Scan(const char *Format, ... )
+{
+    if (!IsValid()) return;
+
+    va_list Args;
+    va_start(Args, Format);
+    vfscanf(mFStream, Format, Args);
+}
+
+char CTextInStream::GetChar()
+{
+    if (!IsValid()) return 0;
+    return (char) fgetc(mFStream);
+}
+
+std::string CTextInStream::GetString()
+{
+    if (!IsValid()) return "";
+
+    char Buf[0x1000];
+    fgets(Buf, 0x1000, mFStream);
+    return std::string(Buf);
+}
+
+long CTextInStream::Seek(long Offset, long Origin)
+{
+    if (!IsValid()) return 1;
+    return fseek(mFStream, Offset, Origin);
+}
+
+long CTextInStream::Tell() const
+{
+    if (!IsValid()) return 0;
+    return ftell(mFStream);
+}
+
+bool CTextInStream::EoF() const
+{
+    return (Tell() == mFileSize);
+}
+
+bool CTextInStream::IsValid() const
+{
+    return (mFStream != 0);
+}
+
+long CTextInStream::Size() const
+{
+    return mFileSize;
+}

src/FileIO/CTextInStream.h

@@ -0,0 +1,32 @@
+#ifndef CTEXTINSTREAM_H
+#define CTEXTINSTREAM_H
+
+#include <cstdio>
+#include <string>
+
+class CTextInStream
+{
+    FILE *mFStream;
+    std::string mFileName;
+    long mFileSize;
+
+public:
+    CTextInStream();
+    CTextInStream(std::string File);
+    CTextInStream(CTextInStream& src);
+    ~CTextInStream();
+    void Open(std::string File);
+    void Close();
+
+    void Scan(const char *Format, ... );
+    char GetChar();
+    std::string GetString();
+
+    long Seek(long Offset, long Origin);
+    long Tell() const;
+    bool EoF() const;
+    bool IsValid() const;
+    long Size() const;
+};
+
+#endif // CTEXTINSTREAM_H

src/FileIO/CTextOutStream.cpp

@@ -0,0 +1,94 @@
+#include "CTextOutStream.h"
+#include <stdarg.h>
+
+CTextOutStream::CTextOutStream()
+{
+    mFStream = nullptr;
+    mSize = 0;
+}
+
+CTextOutStream::CTextOutStream(std::string File)
+{
+    mFStream = nullptr;
+    Open(File.c_str());
+}
+
+CTextOutStream::CTextOutStream(CTextOutStream& src)
+{
+    mFStream = nullptr;
+    Open(src.mFileName);
+
+    if (src.IsValid())
+        Seek(src.Tell(), SEEK_SET);
+}
+
+CTextOutStream::~CTextOutStream()
+{
+    if (IsValid())
+        Close();
+}
+
+void CTextOutStream::Open(std::string File)
+{
+    fopen_s(&mFStream, File.c_str(), "w");
+    mFileName = File;
+    mSize = 0;
+}
+
+void CTextOutStream::Close()
+{
+    if (IsValid())
+        fclose(mFStream);
+    mFStream = nullptr;
+    mSize = 0;
+}
+
+void CTextOutStream::Print(const char *Format, ... )
+{
+    if (!IsValid()) return;
+
+    va_list Args;
+    va_start(Args, Format);
+    vfprintf(mFStream, Format, Args);
+}
+
+void CTextOutStream::WriteChar(char c)
+{
+    if (!IsValid()) return;
+    fputc(c, mFStream);
+    if ((unsigned long) Tell() > mSize) mSize = Tell();
+}
+
+void CTextOutStream::WriteString(std::string Str)
+{
+    if (!IsValid()) return;
+    fputs(Str.c_str(), mFStream);
+    if ((unsigned long) Tell() > mSize) mSize = Tell();
+}
+
+bool CTextOutStream::Seek(long Offset, long Origin)
+{
+    if (!IsValid()) return false;
+    return (fseek(mFStream, Offset, Origin) != 0);
+}
+
+long CTextOutStream::Tell() const
+{
+    if (!IsValid()) return 0;
+    return ftell(mFStream);
+}
+
+bool CTextOutStream::EoF() const
+{
+    return (Tell() == mSize);
+}
+
+bool CTextOutStream::IsValid() const
+{
+    return (mFStream != 0);
+}
+
+long CTextOutStream::Size() const
+{
+    return mSize;
+}

src/FileIO/CTextOutStream.h

@@ -0,0 +1,31 @@
+#ifndef CTEXTOUTSTREAM_H
+#define CTEXTOUTSTREAM_H
+
+#include <string>
+
+class CTextOutStream
+{
+    FILE *mFStream;
+    std::string mFileName;
+    unsigned long mSize;
+
+public:
+    CTextOutStream();
+    CTextOutStream(std::string File);
+    CTextOutStream(CTextOutStream& src);
+    ~CTextOutStream();
+    void Open(std::string file);
+    void Close();
+
+    void Print(const char *Format, ... );
+    void WriteChar(char c);
+    void WriteString(std::string Str);
+
+    bool Seek(long Offset, long Origin);
+    long Tell() const;
+    bool EoF() const;
+    bool IsValid() const;
+    long Size() const;
+};
+
+#endif // CTEXTOUTSTREAM_H

src/FileIO/CVectorOutStream.cpp

@@ -0,0 +1,132 @@
+#include "CVectorOutStream.h"
+
+CVectorOutStream::CVectorOutStream()
+{
+    mDataEndianness = IOUtil::BigEndian;
+    mPos = 0;
+    mUsed = 0;
+}
+
+CVectorOutStream::CVectorOutStream(IOUtil::EEndianness DataEndianness)
+{
+    mDataEndianness = DataEndianness;
+    mPos = 0;
+    mUsed = 0;
+}
+
+CVectorOutStream::CVectorOutStream(unsigned long InitialSize, IOUtil::EEndianness DataEndianness)
+{
+    mDataEndianness = DataEndianness;
+    mVector.resize(InitialSize);
+    mPos = 0;
+    mUsed = 0;
+}
+
+CVectorOutStream::~CVectorOutStream()
+{
+}
+
+void CVectorOutStream::WriteBytes(void *src, unsigned long Count)
+{
+    if (!IsValid()) return;
+
+    if ((mPos + Count) > mVector.size())
+        mVector.resize(mPos + Count);
+
+    memcpy(mVector.data() + mPos, src, Count);
+    mPos += Count;
+    if (mPos > mUsed) mUsed = mPos;
+}
+
+bool CVectorOutStream::Seek(long Offset, long Origin)
+{
+    if (!IsValid()) return false;
+
+    switch (Origin)
+    {
+        case SEEK_SET:
+            mPos = Offset;
+            break;
+
+        case SEEK_CUR:
+            mPos += Offset;
+            break;
+
+        case SEEK_END:
+            mPos = mUsed - Offset;
+            break;
+
+        default:
+            return false;
+    }
+
+    if (mPos < 0) {
+        mPos = 0;
+        return false;
+    }
+
+    if (mPos > mUsed)
+        mUsed = mPos;
+
+    if (mPos > (signed long) mVector.size())
+        mVector.resize(mPos);
+
+    return true;
+}
+
+long CVectorOutStream::Tell() const
+{
+    return mPos;
+}
+
+bool CVectorOutStream::EoF() const
+{
+    return false;
+}
+
+bool CVectorOutStream::IsValid() const
+{
+    return true;
+}
+
+long CVectorOutStream::Size() const
+{
+    return mUsed;
+}
+
+long CVectorOutStream::SizeRemaining() const
+{
+    return mVector.size() - mPos;
+}
+
+void* CVectorOutStream::Data()
+{
+    return mVector.data();
+}
+
+void* CVectorOutStream::DataAtPosition()
+{
+    return mVector.data() + mPos;
+}
+
+void CVectorOutStream::Expand(unsigned long Amount)
+{
+    mVector.resize(mVector.size() + Amount);
+}
+
+void CVectorOutStream::Contract()
+{
+    mVector.resize(mUsed);
+}
+
+void CVectorOutStream::Reset()
+{
+    mPos = 0;
+    mUsed = 0;
+}
+
+void CVectorOutStream::Clear()
+{
+    mVector.clear();
+    Reset();
+}

src/FileIO/CVectorOutStream.h

@@ -0,0 +1,34 @@
+#ifndef CVECTOROUTSTREAM_H
+#define CVECTOROUTSTREAM_H
+
+#include "COutputStream.h"
+#include <vector>
+
+class CVectorOutStream : public COutputStream
+{
+    std::vector<char> mVector;
+    long mPos;
+    long mUsed;
+
+public:
+    CVectorOutStream();
+    CVectorOutStream(IOUtil::EEndianness DataEndianness);
+    CVectorOutStream(unsigned long InitialSize, IOUtil::EEndianness DataEndianness);
+    ~CVectorOutStream();
+
+    void WriteBytes(void *src, unsigned long Count);
+    bool Seek(long Offset, long Origin);
+    long Tell() const;
+    bool EoF() const;
+    bool IsValid() const;
+    long Size() const;
+    long SizeRemaining() const;
+    void *Data();
+    void *DataAtPosition();
+    void Expand(unsigned long Amount);
+    void Contract();
+    void Reset();
+    void Clear();
+};
+
+#endif // CVECTOROUTSTREAM_H

src/FileIO/FileIO.h

@@ -0,0 +1,17 @@
+#ifndef FILEIO_H
+#define FILEIO_H
+
+#include "IOUtil.h"
+
+#include "CInputStream.h"
+#include "CFileInStream.h"
+#include "CMemoryInStream.h"
+#include "CTextInStream.h"
+
+#include "COutputStream.h"
+#include "CFileOutStream.h"
+#include "CMemoryOutStream.h"
+#include "CVectorOutStream.h"
+#include "CTextOutStream.h"
+
+#endif // FILEIO

src/FileIO/FileIO.pro

@@ -0,0 +1,56 @@
+#-------------------------------------------------
+#
+# Project created by QtCreator 2015-12-16T12:35:06
+#
+#-------------------------------------------------
+
+QT       -= core gui
+QMAKE_CXXFLAGS += /WX
+
+CONFIG += staticlib
+TEMPLATE = lib
+DESTDIR = $$PWD/../../build/FileIO
+
+unix {
+    target.path = /usr/lib
+    INSTALLS += target
+}
+
+CONFIG (debug, debug|release) {
+    # Debug Config
+    OBJECTS_DIR = $$PWD/../../build/FileIO/debug
+    TARGET = FileIOd
+}
+
+CONFIG (release, debug|release) {
+    # Release Config
+    OBJECTS_DIR = $$PWD/../../build/FileIO/release
+    TARGET = FileIO
+}
+
+# Header Files
+HEADERS += \
+    CFileInStream.h \
+    CFileOutStream.h \
+    CInputStream.h \
+    CMemoryInStream.h \
+    CMemoryOutStream.h \
+    COutputStream.h \
+    CTextInStream.h \
+    CTextOutStream.h \
+    CVectorOutStream.h \
+    FileIO.h \
+    IOUtil.h
+
+# Source Files
+SOURCES += \
+    CFileInStream.cpp \
+    CFileOutStream.cpp \
+    CInputStream.cpp \
+    CMemoryInStream.cpp \
+    CMemoryOutStream.cpp \
+    COutputStream.cpp \
+    CTextInStream.cpp \
+    CTextOutStream.cpp \
+    CVectorOutStream.cpp \
+    IOUtil.cpp

src/FileIO/IOUtil.cpp

@@ -0,0 +1,79 @@
+#include "IOUtil.h"
+
+namespace IOUtil
+{
+    EEndianness FindSystemEndianness()
+    {
+        // Memory layout for a 32-bit value of 1:
+        // 0x01000000 - Little Endian
+        // 0x00000001 - Big Endian
+        long EndianTest = 1;
+        if (*(char*)&EndianTest == 1) return LittleEndian;
+        else return BigEndian;
+    }
+    const EEndianness SystemEndianness = FindSystemEndianness();
+
+    void SwapBytes(short& Val)
+    {
+        Val = (((Val & 0x00FF) << 8) |
+               ((Val & 0xFF00) >> 8));
+    }
+
+    void SwapBytes(unsigned short& Val)
+    {
+        Val = (((Val & 0x00FF) << 8) |
+               ((Val & 0xFF00) >> 8));
+    }
+
+    void SwapBytes(long& Val)
+    {
+        Val = (((Val & 0x000000FF) << 24) |
+               ((Val & 0x0000FF00) <<  8) |
+               ((Val & 0x00FF0000) >>  8) |
+               ((Val & 0xFF000000) >> 24));
+    }
+
+    void SwapBytes(unsigned long& Val)
+    {
+        Val = (((Val & 0x000000FF) << 24) |
+               ((Val & 0x0000FF00) <<  8) |
+               ((Val & 0x00FF0000) >>  8) |
+               ((Val & 0xFF000000) >> 24));
+    }
+
+    void SwapBytes(long long& Val)
+    {
+        Val = (((Val & 0x00000000000000FF) << 56) |
+               ((Val & 0x000000000000FF00) << 40) |
+               ((Val & 0x0000000000FF0000) << 24) |
+               ((Val & 0x00000000FF000000) <<  8) |
+               ((Val & 0x000000FF00000000) >>  8) |
+               ((Val & 0x0000FF0000000000) >> 24) |
+               ((Val & 0x00FF000000000000) >> 40) |
+               ((Val & 0xFF00000000000000) >> 56));
+    }
+
+    void SwapBytes(unsigned long long &Val)
+    {
+        Val = (((Val & 0x00000000000000FF) << 56) |
+               ((Val & 0x000000000000FF00) << 40) |
+               ((Val & 0x0000000000FF0000) << 24) |
+               ((Val & 0x00000000FF000000) <<  8) |
+               ((Val & 0x000000FF00000000) >>  8) |
+               ((Val & 0x0000FF0000000000) >> 24) |
+               ((Val & 0x00FF000000000000) >> 40) |
+               ((Val & 0xFF00000000000000) >> 56));
+    }
+
+    void SwapBytes(float& Val)
+    {
+        long* ptr = (long*) &Val;
+        SwapBytes(*ptr);
+    }
+
+    void SwapBytes(double& Val)
+    {
+        long long* ptr = (long long*) &Val;
+        SwapBytes(*ptr);
+    }
+}

src/FileIO/IOUtil.h

@@ -0,0 +1,22 @@
+#ifndef IOUTIL_H
+#define IOUTIL_H
+
+namespace IOUtil
+{
+    enum EEndianness {
+        LittleEndian,
+        BigEndian
+    };
+    extern const EEndianness SystemEndianness;
+
+    void SwapBytes(short& Val);
+    void SwapBytes(unsigned short& Val);
+    void SwapBytes(long& Val);
+    void SwapBytes(unsigned long& Val);
+    void SwapBytes(long long& Val);
+    void SwapBytes(unsigned long long& Val);
+    void SwapBytes(float& Val);
+    void SwapBytes(double& Val);
+}
+
+#endif // IOUTIL_H