binary_writer.h

Go to the documentation of this file.

#pragma once

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

namespace xtd {
  namespace io {
    class core_export_ binary_writer : public xtd::object {
    public:
      
      explicit binary_writer(const xtd::ustring& path);
      explicit binary_writer(std::ostream& stream);
      binary_writer(const binary_writer&) = delete;
      binary_writer& operator=(const binary_writer&) = delete;
      ~binary_writer();
      
      
      std::optional<std::reference_wrapper<std::ostream>> base_stream() const;
      
      
      virtual void close();
      
      virtual void flush();
      
      virtual size_t seek(size_t offset, std::ios::seekdir origin);
      
      virtual void write(bool value);
      
      virtual void write(byte_t value);
      
      virtual void write(char value);
      
      template<size_t size>
      void write(const std::array<byte_t, size>& buffer) {
        for (auto b : buffer)
          write(b);
      }
      
      template<size_t size>
      void write(const std::array<char, size>& buffer) {
        for (auto c : buffer)
          write(c);
      }
      
      virtual void write(const std::vector<byte_t>& buffer);
      
      virtual void write(const std::vector<byte_t>& buffer, size_t index, size_t count);
      
      virtual void write(const std::vector<char>& buffer);
      
      virtual void write(const std::vector<char>& buffer, size_t index, size_t count);
      
      virtual void write(double value);
      
      virtual void write(int16_t value);
      
      virtual void write(int32_t value);
      
      virtual void write(int64_t value);
      
      virtual void write(sbyte_t value);
      
      virtual void write(float value);
      
      virtual void write(const ustring& value);
      virtual void write(const std::string& value);
      virtual void write(const std::u8string& value);
      virtual void write(const std::u16string& value);
      virtual void write(const std::u32string& value);
      virtual void write(const std::wstring& value);
      virtual void write(const char* value);
      virtual void write(const char8_t* value);
      virtual void write(const char16_t* value);
      virtual void write(const char32_t* value);
      virtual void write(const wchar_t* value);
      
      virtual void write(uint16_t value);
      
      virtual void write(uint32_t value);
      
      virtual void write(uint64_t value);
      
      binary_writer& operator<<(bool value) {write(value); return *this;}
      binary_writer& operator<<(byte value) {write(value); return *this;}
      binary_writer& operator<<(char value) {write(value); return *this;}
      template<size_t size>
      binary_writer& operator<<(const std::array<byte_t, size>& value) {write(value); return *this;}
      template<size_t size>
      binary_writer& operator<<(const std::array<char, size>& value) {write(value); return *this;}
      binary_writer& operator<<(const std::vector<byte_t>& value) {write(value); return *this;}
      binary_writer& operator<<(const std::vector<char>& value) {write(value); return *this;}
      binary_writer& operator<<(double value) {write(value); return *this;}
      binary_writer& operator<<(int16_t value) {write(value); return *this;}
      binary_writer& operator<<(int32_t value) {write(value); return *this;}
      binary_writer& operator<<(int64_t value) {write(value); return *this;}
      binary_writer& operator<<(sbyte value) {write(value); return *this;}
      binary_writer& operator<<(float value) {write(value); return *this;}
      binary_writer& operator<<(const ustring& value) {write(value); return *this;}
      binary_writer& operator<<(const std::string& value) {write(value); return *this;}
      binary_writer& operator<<(const std::u8string& value) {write(value); return *this;}
      binary_writer& operator<<(const std::u16string& value) {write(value); return *this;}
      binary_writer& operator<<(const std::u32string& value) {write(value); return *this;}
      binary_writer& operator<<(const std::wstring& value) {write(value); return *this;}
      binary_writer& operator<<(const char* value) {write(value); return *this;}
      binary_writer& operator<<(const char8_t* value) {write(value); return *this;}
      binary_writer& operator<<(const char16_t* value) {write(value); return *this;}
      binary_writer& operator<<(const char32_t* value) {write(value); return *this;}
      binary_writer& operator<<(const wchar_t* value) {write(value); return *this;}
      binary_writer& operator<<(uint16_t value) {write(value); return *this;}
      binary_writer& operator<<(uint32_t value) {write(value); return *this;}
      binary_writer& operator<<(uint64_t value) {write(value); return *this;}
      
    private:
      std::ostream* stream_ = nullptr;
      bool delete_when_destroy_ = false;
    };
  }
}