binary_reader.h

Go to the documentation of this file.

#pragma once

#include <fstream>
#include <optional>
#include <vector>
#include "../object.h"
#include "../ustring.h"

namespace xtd {
  namespace io {
    class core_export_ binary_reader : public xtd::object {
    public:
      
      explicit binary_reader(const xtd::ustring& 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_t peek_char() const;
      
      virtual int32_t read();
      
      virtual size_t read(std::vector<byte_t>& buffer, size_t index, size_t count);
      
      virtual size_t read(std::vector<char>& buffer, size_t index, size_t count);
      
      virtual bool read_boolean();
      
      virtual byte_t read_byte();
      
      virtual std::vector<byte_t> read_bytes(size_t count);
      
      virtual char read_char();
      
      virtual std::vector<char> read_chars(size_t count);
      
      virtual double read_double();
      
      virtual int16_t read_int16();
      
      virtual int32_t read_int32();
      
      virtual int64_t read_int64();
      
      virtual sbyte_t read_sbyte();
      
      virtual float read_single();
      
      virtual ustring read_string();
      
      virtual uint16_t read_uint16();
      
      virtual uint32_t read_uint32();
      
      virtual uint64_t read_uint64();
      
      binary_reader& operator>>(bool& value) {value = read_boolean(); return *this;}
      binary_reader& operator>>(byte_t& 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_t& value) {value = read_int16(); return *this;}
      binary_reader& operator>>(int32_t& value) {value = read_int32(); return *this;}
      binary_reader& operator>>(int64_t& value) {value = read_int64(); return *this;}
      binary_reader& operator>>(sbyte_t& value) {value = read_sbyte(); return *this;}
      binary_reader& operator>>(float& value) {value = read_single(); return *this;}
      binary_reader& operator>>(ustring& value) {value = read_string(); return *this;}
      binary_reader& operator>>(uint16_t& value) {value = read_uint16(); return *this;}
      binary_reader& operator>>(uint32_t& value) {value = read_uint32(); return *this;}
      binary_reader& operator>>(uint64_t& value) {value = read_uint64(); return *this;}
      
    private:
      std::istream* stream_ = nullptr;
      bool delete_when_destroy_ = false;
    };
  }
}