binary_reader.hpp

Go to the documentation of this file.

 
#pragma once
#include "../array.hpp"
#include "../optional.hpp"
#include "../object.hpp"
#include "../string.hpp"
#include <iostream>
#include <fstream>
#include <vector>
#include <stack>
 
namespace xtd {
  namespace io {
    class core_export_ binary_reader : public xtd::object {
    public:
      
      explicit binary_reader(const xtd::string& path);
      explicit binary_reader(std::istream& stream);
      binary_reader(const binary_reader&) = delete;
      binary_reader& operator =(const binary_reader&) = delete;
      ~binary_reader();
      
      
      std::optional<std::reference_wrapper<std::istream>> base_stream() const;
      
      bool end_of_stream() const;
      
      
      void close();
      
      int32 peek_char() const;
      
      std::streampos pop();
      
      void push(std::streampos pos = 0);
      
      virtual int32 read();
      
      virtual size_t read(xtd::array<xtd::byte>& buffer, size_t index, size_t count);
      
      virtual size_t read(xtd::array<char>& buffer, size_t index, size_t count);
      
      virtual bool read_boolean();
      
      virtual xtd::byte read_byte();
      
      virtual xtd::array<xtd::byte> read_bytes(size_t count);
      
      virtual char read_char();
      
      virtual xtd::array<char> read_chars(size_t count);
      
      virtual double read_double();
      
      virtual int16 read_int16();
      
      virtual int32 read_int32();
      
      virtual int64 read_int64();
      
      virtual sbyte read_sbyte();
      
      virtual float read_single();
      
      virtual string read_string();
      
      virtual uint16 read_uint16();
      
      virtual uint32 read_uint32();
      
      virtual uint64 read_uint64();
      
      void rewind();
      
      void seekg(std::streamoff off, std::ios_base::seekdir dir = std::ios_base::cur);
      
      std::streampos tellg();
      
      binary_reader& operator >>(bool& value) {value = read_boolean(); return *this;}
      binary_reader& operator >>(xtd::byte& value) {value = read_byte(); return *this;}
      binary_reader& operator >>(char& value) {value = read_char(); return *this;}
      binary_reader& operator >>(double& value) {value = read_double(); return *this;}
      binary_reader& operator >>(int16& value) {value = read_int16(); return *this;}
      binary_reader& operator >>(int32& value) {value = read_int32(); return *this;}
      binary_reader& operator >>(int64& value) {value = read_int64(); return *this;}
      binary_reader& operator >>(sbyte& value) {value = read_sbyte(); return *this;}
      binary_reader& operator >>(float& value) {value = read_single(); return *this;}
      binary_reader& operator >>(string& value) {value = read_string(); return *this;}
      binary_reader& operator >>(uint16& value) {value = read_uint16(); return *this;}
      binary_reader& operator >>(uint32& value) {value = read_uint32(); return *this;}
      binary_reader& operator >>(uint64& value) {value = read_uint64(); return *this;}
      
    private:
      int32 read_7bit_encoded_int();
      std::istream* stream_ = nullptr;
      std::stack<std::streampos> pos_stack_;
      bool delete_when_destroy_ = false;
    };
  }
}