CUBinaryReader.h

//
//  CUBinaryReader.h
//  Cornell University Game Library (CUGL)
//
//  This module provides a simple Java-style reader for decoding binary files.
//  All data is marshalled from network order, ensuring that the files are
//  supported across multiple platforms.
//
//  Note that this reader does not refer to the integral types as short, int,
//  long, etc.  Those types are NOT cross-platform.  For example, a long is
//  8 bytes on Unix/OS X, but 4 bytes on Win32 platforms.
//
//  By default, this module (and every module in the io package) accesses the
//  application save directory.  If you want to access another directory, you
//  will need to specify an absolute path for the file name.  Keep in mind that
//  absolute paths are very dangerous on mobile devices, because they do not
//  have proper file systems.  You should confine all files to either the asset
//  or the save directory.
//
//  This class uses our standard shared-pointer architecture.
//
//  1. The constructor does not perform any initialization; it just sets all
//     attributes to their defaults.
//
//  2. All initialization takes place via init methods, which can fail if an
//     object is initialized more than once.
//
//  3. All allocation takes place via static constructors which return a shared
//     pointer.
//
//  CUGL MIT License:
//      This software is provided 'as-is', without any express or implied
//      warranty.  In no event will the authors be held liable for any damages
//      arising from the use of this software.
//
//      Permission is granted to anyone to use this software for any purpose,
//      including commercial applications, and to alter it and redistribute it
//      freely, subject to the following restrictions:
//
//      1. The origin of this software must not be misrepresented; you must not
//      claim that you wrote the original software. If you use this software
//      in a product, an acknowledgment in the product documentation would be
//      appreciated but is not required.
//
//      2. Altered source versions must be plainly marked as such, and must not
//      be misrepresented as being the original software.
//
//      3. This notice may not be removed or altered from any source distribution.
//
//  Author: Walker White
//  Version: 11/28/16
//
#ifndef __CU_BINARY_READER_H__
#define __CU_BINARY_READER_H__
#include <cugl/base/CUBase.h>
#include <SDL/SDL.h>
#include <cugl/io/CUPathname.h>
#include <string>

namespace cugl {

class BinaryReader {
protected:
    std::string _name;
    SDL_RWops*  _stream;
    Sint64      _ssize;
    Sint64      _scursor;
    
    char*       _buffer;
    Uint32      _capacity;
    Uint32      _bufsize;
    Sint32      _bufoff;
    
#pragma mark -
#pragma mark Internal Methods

    void fill(unsigned int bytes=1);
    
    
#pragma mark -
#pragma mark Constructors
public:
    BinaryReader() : _name(""), _stream(nullptr), _ssize(-1), _scursor(-1),
                     _buffer(nullptr), _capacity(0), _bufoff(-1), _bufsize(0) {}
    
    ~BinaryReader() { close(); }
    
    bool init(const std::string& file) {
        return init(Pathname(file));
    }
    
    bool init(const char* file) {
        return init(Pathname(file));
    }

    bool init(const Pathname& file);
    
    bool init(const std::string& file, unsigned int capacity) {
        return init(Pathname(file),capacity);
    }
    
    bool init(const char* file, unsigned int capacity) {
        return init(Pathname(file),capacity);
    }

    bool init(const Pathname& file, unsigned int capacity);
    
    bool initWithAsset(const std::string& file) {
        return init(file.c_str());
    }
    
    bool initWithAsset(const char* file);
    
    bool initWithAsset(const std::string& file, unsigned int capacity) {
        return init(file.c_str(),capacity);
    }
    
    bool initWithAsset(const char* file, unsigned int capacity);
    
    
#pragma mark -
#pragma mark Static Constructors

    static std::shared_ptr<BinaryReader> alloc(const std::string& file) {
        std::shared_ptr<BinaryReader> result = std::make_shared<BinaryReader>();
        return (result->init(file) ? result : nullptr);
    }
    
    static std::shared_ptr<BinaryReader> alloc(const char* file) {
        std::shared_ptr<BinaryReader> result = std::make_shared<BinaryReader>();
        return (result->init(file) ? result : nullptr);
    }
    
    static std::shared_ptr<BinaryReader> alloc(const std::string& file, unsigned int capacity) {
        std::shared_ptr<BinaryReader> result = std::make_shared<BinaryReader>();
        return (result->init(file,capacity) ? result : nullptr);
    }
    
    static std::shared_ptr<BinaryReader> alloc(const char* file, unsigned int capacity) {
        std::shared_ptr<BinaryReader> result = std::make_shared<BinaryReader>();
        return (result->init(file,capacity) ? result : nullptr);
    }
    
    static std::shared_ptr<BinaryReader> allocWithAsset(const std::string& file) {
        std::shared_ptr<BinaryReader> result = std::make_shared<BinaryReader>();
        return (result->initWithAsset(file) ? result : nullptr);
    }
    
    static std::shared_ptr<BinaryReader> allocWithAsset(const char* file) {
        std::shared_ptr<BinaryReader> result = std::make_shared<BinaryReader>();
        return (result->initWithAsset(file) ? result : nullptr);
    }
    
    static std::shared_ptr<BinaryReader> allocWithAsset(const std::string& file, unsigned int capacity) {
        std::shared_ptr<BinaryReader> result = std::make_shared<BinaryReader>();
        return (result->initWithAsset(file,capacity) ? result : nullptr);
    }
    
    static std::shared_ptr<BinaryReader> allocWithAsset(const char* file, unsigned int capacity) {
        std::shared_ptr<BinaryReader> result = std::make_shared<BinaryReader>();
        return (result->initWithAsset(file,capacity) ? result : nullptr);
    }
    
    
#pragma mark -
#pragma mark Stream Management

    void reset();
    
    void close();
    
    bool ready(unsigned int bytes=1) const;
    
    
#pragma mark -
#pragma mark Single Element Reads

    char readChar();

    Uint8 readByte();
    
    Sint16 readSint16();

    Uint16 readUint16();

    Sint32 readSint32();
    
    Uint32 readUint32();
    
    Sint64 readSint64();
    
    Uint64 readUint64();
    
    float readFloat();
    
    double readDouble();
    
    
#pragma mark -
#pragma mark Array Reads

    size_t read(char* buffer, size_t maximum, size_t offset=0);

    size_t read(Uint8* buffer, size_t maximum, size_t offset=0);

    size_t read(Sint16* buffer, size_t maximum, size_t offset=0);

    size_t read(Uint16* buffer, size_t maximum, size_t offset=0);

    size_t read(Sint32* buffer, size_t maximum, size_t offset=0);
    
    size_t read(Uint32* buffer, size_t maximum, size_t offset=0);
    
    size_t read(Sint64* buffer, size_t maximum, size_t offset=0);
    
    size_t read(Uint64* buffer, size_t maximum, size_t offset=0);

    size_t read(float* buffer, size_t maximum, size_t offset=0);
    
    size_t read(double* buffer, size_t maximum, size_t offset=0);
};

}
#endif /* __CU_BINARY_READER_H__ */