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;
      auto operator =(const binary_reader&) -> binary_reader& = delete;
      ~binary_reader();
      
      
      [[nodiscard]] auto base_stream() const -> std::optional<xtd::ref<std::istream>>;
      
      [[nodiscard]] auto end_of_stream() const -> bool;
      
      
      auto close() -> void;
      
      [[nodiscard]] auto peek_char() const -> xtd::int32;
      
      auto pop() -> std::streampos;
      
      auto push(std::streampos pos = 0) -> void;
      
      [[nodiscard]] virtual auto read() -> xtd::int32;
      
      virtual auto read(xtd::array<xtd::byte>& buffer, xtd::size index, xtd::size count) -> xtd::size;
      
      virtual auto read(xtd::array<char>& buffer, xtd::size index, xtd::size count) -> xtd::size;
      
      [[nodiscard]] virtual auto read_boolean() -> bool;
      
      [[nodiscard]] virtual auto read_byte() -> xtd::byte;
      
      [[nodiscard]] virtual auto read_bytes(xtd::size count) -> xtd::array<xtd::byte>;
      
      [[nodiscard]] virtual auto read_char() -> char;
      
      [[nodiscard]] virtual auto read_chars(xtd::size count) -> xtd::array<char>;
      
      [[nodiscard]] virtual auto read_double() -> double;
      
      [[nodiscard]] virtual auto read_int16() -> xtd::int16;
      
      [[nodiscard]] virtual auto read_int32() -> xtd::int32;
      
      [[nodiscard]] virtual auto read_int64() -> xtd::int64;
      
      [[nodiscard]] virtual auto read_sbyte() -> xtd::sbyte;
      
      [[nodiscard]] virtual auto read_single() -> float;
      
      [[nodiscard]] virtual auto read_size() -> xtd::size;
      
      [[nodiscard]] virtual auto read_string() -> xtd::string;
      
      [[nodiscard]] virtual auto read_uint16() -> xtd::uint16;
      
      [[nodiscard]] virtual auto read_uint32() -> xtd::uint32;
      
      [[nodiscard]] virtual auto read_uint64() -> xtd::uint64;
      
      auto rewind() -> void;
      
      virtual auto seek(std::streamoff off, std::ios_base::seekdir dir = std::ios_base::cur) -> void;
      
      [[nodiscard]] auto tell() -> std::streampos;
      
      auto operator >>(bool& value) -> binary_reader& {value = read_boolean(); return *this;}
      auto operator >>(xtd::byte& value) -> binary_reader& {value = read_byte(); return *this;}
      auto operator >>(char& value) -> binary_reader& {value = read_char(); return *this;}
      auto operator >>(double& value) -> binary_reader& {value = read_double(); return *this;}
      auto operator >>(int16& value) -> binary_reader& {value = read_int16(); return *this;}
      auto operator >>(int32& value) -> binary_reader& {value = read_int32(); return *this;}
      auto operator >>(int64& value) -> binary_reader& {value = read_int64(); return *this;}
      auto operator >>(sbyte& value) -> binary_reader& {value = read_sbyte(); return *this;}
      auto operator >>(float& value) -> binary_reader& {value = read_single(); return *this;}
      auto operator >>(string& value) -> binary_reader& {value = read_string(); return *this;}
      auto operator >>(uint16& value) -> binary_reader& {value = read_uint16(); return *this;}
      auto operator >>(uint32& value) -> binary_reader& {value = read_uint32(); return *this;}
      auto operator >>(uint64& value) -> binary_reader& {value = read_uint64(); return *this;}
      
    private:
      [[nodiscard]] auto read_7bit_encoded_int() -> int32;
      std::istream* stream_ = nullptr;
      std::stack<std::streampos> pos_stack_;
      bool delete_when_destroy_ = false;
    };
  }
}