BinaryParsing.h

// Copyright eeGeo Ltd (2012-2014), All Rights Reserved

#pragma once

#include "Types.h"
#include "VectorMath.h"
#include "Bounds.h"
#include <streambuf>
#include <cstdio>
#include <istream>
#include <string>
#include <vector>

namespace Eegeo 
{
    namespace Resources
    {
        namespace BinaryParsing
        {
            class membuf : public std::basic_streambuf<char>, protected Eegeo::NonCopyable
            {
            public:
                membuf(char* p, size_t n) {
                    setg(p, p, p + n);
                }
                
                char* getCurrent() const
                {
                    return gptr();
                }
    
            protected:
                virtual pos_type seekoff( off_type off, std::ios_base::seekdir dir,
                             std::ios_base::openmode which = std::ios_base::in | std::ios_base::out )
                {
                    //Eegeo_ASSERT(which == std::ios_base::in);

                    if (dir == std::ios::cur)
                    {
                        setg(eback(), gptr() + off, egptr());
                    }
                    else if (dir == std::ios::beg)
                    {
                        setg(eback(), eback() + off, egptr());
                    }
                    else if (dir == std::ios::end)
                    {
                        setg(eback(), egptr() - off, egptr());
                    }

                    if (gptr() < eback())
                        return -1;
                    if (gptr() > egptr())
                        return -1;
                    return gptr() - eback();
                }
    
                virtual pos_type seekpos( pos_type off,
                                         std::ios_base::openmode which = std::ios_base::in | std::ios_base::out )
                {
                    return seekoff(off, std::ios::beg, which);
                };

            };

            bool StreamIsAligned(std::istream& stream, int alignment, bool alignedReads);

            void AlignStream(std::istream& reader, int alignment, bool alignedReads);

            namespace
            {
                template <class T>
                T ParseT(std::istream& reader, bool alignedReads)
                {
                    AlignStream(reader, sizeof(T), alignedReads);
                    T result;
                    reader.read((char*)&result, sizeof(T));
                    return result;
                }

                template <>
                inline Eegeo::v2 ParseT<Eegeo::v2>(std::istream& reader, bool alignedReads)
                {
                    AlignStream(reader, sizeof(float), alignedReads);
                    Eegeo::v2 result;
                    reader.read((char*)&result, sizeof(Eegeo::v2));
                    return result;
                }

                template <>
                inline Eegeo::v3 ParseT<Eegeo::v3>(std::istream& reader, bool alignedReads)
                {
                    AlignStream(reader, sizeof(float), alignedReads);
                    Eegeo::v3 result;
                    reader.read((char*)&result, sizeof(Eegeo::v3));
                    return result;
                }

                template <>
                inline Eegeo::v4 ParseT<Eegeo::v4>(std::istream& reader, bool alignedReads)
                {
                    AlignStream(reader, sizeof(float), alignedReads);
                    Eegeo::v4 result;
                    reader.read((char*)&result, sizeof(Eegeo::v4));
                    return result;
                }

                template <>
                inline Eegeo::m44 ParseT<Eegeo::m44>(std::istream& reader, bool alignedReads)
                {
                    AlignStream(reader, sizeof(float), alignedReads);
                    Eegeo::m44 result;
                    reader.read((char*)&result, sizeof(Eegeo::m44));
                    return result;
                }

                template <>
                inline Eegeo::Geometry::DoubleBounds3D ParseT<Eegeo::Geometry::DoubleBounds3D>(std::istream& reader, bool alignedReads)
                {
                    AlignStream(reader, sizeof(double), alignedReads);
                    Eegeo::Geometry::DoubleBounds3D result;
                    reader.read((char*)&result, sizeof(Eegeo::Geometry::DoubleBounds3D));
                    return result;
                }
            }

            class BinaryParser
            {
            public:
                BinaryParser(const bool alignedReads);

                template <class T>
                T Parse(std::istream& reader, size_t *parseSize) const
                {
                    AlignStream(reader, sizeof(T));
                    T result; 
                    reader.read((char*)&result, sizeof(T));
                    
                    *parseSize += sizeof(T);
                    
                    return result;
                }
                
                template <class T>
                T Parse(std::istream& reader) const
                {
                    return ParseT<T>(reader, m_alignedReads);
                }

                template <class T, size_t N>
                void Parse(std::istream& reader, T (&result)[N]) const
                {
                    AlignStream(reader, sizeof(T));
                    reader.read((char*)&result, sizeof(T) * N);
                }
                                
                template <class T>
                void ParseShortString(std::istream& reader, std::string& outputString) const
                {
                    size_t length = Parse<T>(reader);

                    AlignStream(reader, sizeof(char));
                    outputString.resize(length);
                    reader.read((char*)&outputString[0], length * sizeof(char));
                }

                std::string ParseFourCC(std::istream& reader) const;

                u32 Read7BitEncodedInt(std::istream& reader) const;
                std::string ParseString(std::istream& reader) const;
                std::vector<std::string> ParseStringArray(std::istream& reader) const;

                bool StreamIsAligned(std::istream& stream, int alignment) const
                {
                    return BinaryParsing::StreamIsAligned(stream, alignment, m_alignedReads);
                }

                void AlignStream(std::istream& stream, int alignment) const
                {
                    BinaryParsing::AlignStream(stream, alignment, m_alignedReads);
                }

            private:
                bool m_alignedReads;
            };
        }
    }
}