binary_writer.hpp

Go to the documentation of this file.

#pragma once
#define __XTD_STD_INTERNAL__
#include "../internal/__xtd_std_version.hpp"
#undef __XTD_STD_INTERNAL__
#include "../array.hpp"
#include "../fixed_array.hpp"
#include "../object.hpp"
#include "../optional.hpp"
#include "../read_only_span"
#include "../string.hpp"
#include <fstream>
#include <array>
#include <vector>

namespace xtd {
  namespace io {
    class core_export_ binary_writer : public xtd::object {
    public:
      
      explicit binary_writer(const xtd::string& path);
      explicit binary_writer(std::ostream& stream);
      binary_writer(const binary_writer&) = delete;
      auto operator =(const binary_writer&) -> binary_writer& = delete;
      ~binary_writer();
      
      
      [[nodiscard]] auto base_stream() const -> std::optional<xtd::ref<std::ostream>>;
      
      
      virtual auto close() -> void;
      
      virtual auto flush() -> void;
      
      virtual auto seek(xtd::size offset, std::ios::seekdir origin) -> xtd::size;
      
      [[nodiscard]] virtual auto tell() -> std::streampos;

      virtual auto write(bool value) -> void;
      
      virtual auto write(xtd::byte value) -> void;
      
      virtual auto write(char value) -> void;
      
      template<xtd::size size>
      auto write(const std::array<xtd::byte, size>& buffer) -> void {
        for (auto b : buffer)
          write(b);
      }
      
      template<xtd::size size>
      auto write(const std::array<char, size>& buffer) -> void {
        for (auto c : buffer)
          write(c);
      }
      
      virtual auto write(const xtd::read_only_span<xtd::byte>& buffer) -> void;
      
      virtual auto write(const xtd::array<xtd::byte>& buffer, xtd::size index, xtd::size count) -> void;
      
      virtual auto write(const xtd::read_only_span<char>& buffer) -> void;
      
      virtual auto write(const xtd::array<char>& buffer, xtd::size index, xtd::size count) -> void;
      
      virtual auto write(double value) -> void;
      
      virtual auto write(int16 value) -> void;
      
      virtual auto write(xtd::int32 value) -> void;
      
      virtual auto write(xtd::int64 value) -> void;
      
      virtual auto write(xtd::sbyte value) -> void;
      
      virtual auto write(float value) -> void;
      
      virtual auto write(const xtd::string& value) -> void;
      virtual auto write(const std::string& value) -> void;
      virtual auto write(const std::u8string& value) -> void;
      virtual auto write(const std::u16string& value) -> void;
      virtual auto write(const std::u32string& value) -> void;
      virtual auto write(const std::wstring& value) -> void;
      virtual auto write(const char* value) -> void;
      virtual auto write(const xtd::char8* value) -> void;
      virtual auto write(const xtd::char16* value) -> void;
      virtual auto write(const xtd::char32* value) -> void;
      virtual auto write(const xtd::wchar* value) -> void;
      
      virtual auto write(xtd::uint16 value) -> void;
      
      virtual auto write(xtd::uint32 value) -> void;
      
      virtual auto write(xtd::uint64 value) -> void;
      
      virtual auto write(xtd::slong value) -> void;
      virtual auto write(xtd::ulong value) -> void;
      
      
      auto operator <<(bool value) -> binary_writer& {write(value); return *this;}
      auto operator <<(byte value) -> binary_writer& {write(value); return *this;}
      auto operator <<(char value) -> binary_writer& {write(value); return *this;}
      template<xtd::size size>
      auto operator <<(const xtd::fixed_array<xtd::byte, size>& value) -> binary_writer& {write(value); return *this;}
      template<xtd::size size>
      auto operator <<(const xtd::fixed_array<char, size>& value) -> binary_writer& {write(value); return *this;}
      auto operator <<(const xtd::array<xtd::byte>& value) -> binary_writer& {write(value, 0, value.length()); return *this;}
      auto operator <<(const xtd::array<char>& value) -> binary_writer& {write(value, 0, value.length()); return *this;}
      auto operator <<(double value) -> binary_writer& {write(value); return *this;}
      auto operator <<(int16 value) -> binary_writer& {write(value); return *this;}
      auto operator <<(int32 value) -> binary_writer& {write(value); return *this;}
      auto operator <<(int64 value) -> binary_writer& {write(value); return *this;}
      auto operator <<(sbyte value) -> binary_writer& {write(value); return *this;}
      auto operator <<(float value) -> binary_writer& {write(value); return *this;}
      auto operator <<(const string& value) -> binary_writer& {write(value); return *this;}
      auto operator <<(const char* value) -> binary_writer& {write(value); return *this;}
      auto operator <<(const char8* value) -> binary_writer& {write(value); return *this;}
      auto operator <<(const char16* value) -> binary_writer& {write(value); return *this;}
      auto operator <<(const char32* value) -> binary_writer& {write(value); return *this;}
      auto operator <<(const wchar* value) -> binary_writer& {write(value); return *this;}
      auto operator <<(uint16 value) -> binary_writer& {write(value); return *this;}
      auto operator <<(uint32 value) -> binary_writer& {write(value); return *this;}
      auto operator <<(uint64 value) -> binary_writer& {write(value); return *this;}
      
    private:
      auto write_7bit_encoded_int(int32 value) -> void;
      std::ostream* stream_ = nullptr;
      bool delete_when_destroy_ = false;
    };
  }
}