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;
      binary_writer& operator =(const binary_writer&) = delete;
      ~binary_writer();
      
      
      std::optional<xtd::ref<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(xtd::byte value);
      
      virtual void write(char value);
      
      template<size_t size>
      void write(const std::array<xtd::byte, 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 xtd::read_only_span<xtd::byte>& buffer);
      
      virtual void write(const xtd::array<xtd::byte>& buffer, size_t index, size_t count);
      
      virtual void write(const xtd::read_only_span<char>& buffer);
      
      virtual void write(const xtd::array<char>& buffer, size_t index, size_t count);
      
      virtual void write(double value);
      
      virtual void write(int16 value);
      
      virtual void write(int32 value);
      
      virtual void write(int64 value);
      
      virtual void write(sbyte value);
      
      virtual void write(float value);
      
      virtual void write(const string& 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* value);
      virtual void write(const char16* value);
      virtual void write(const char32* value);
      virtual void write(const wchar* value);
      
      virtual void write(uint16 value);
      
      virtual void write(uint32 value);
      
      virtual void write(uint64 value);
      
      virtual void write(slong value);
      virtual void write(xtd::ulong 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 xtd::fixed_array<xtd::byte, size>& value) {write(value); return *this;}
      template<size_t size>
      binary_writer & operator <<(const xtd::fixed_array<char, size>& value) {write(value); return *this;}
      binary_writer & operator <<(const xtd::array<xtd::byte>& value) {write(value, 0, value.size()); return *this;}
      binary_writer & operator <<(const xtd::array<char>& value) {write(value, 0, value.size()); return *this;}
      binary_writer & operator <<(double value) {write(value); return *this;}
      binary_writer & operator <<(int16 value) {write(value); return *this;}
      binary_writer & operator <<(int32 value) {write(value); return *this;}
      binary_writer & operator <<(int64 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 string& value) {write(value); return *this;}
      binary_writer & operator <<(const char* value) {write(value); return *this;}
      binary_writer & operator <<(const char8* value) {write(value); return *this;}
      binary_writer & operator <<(const char16* value) {write(value); return *this;}
      binary_writer & operator <<(const char32* value) {write(value); return *this;}
      binary_writer & operator <<(const wchar* value) {write(value); return *this;}
      binary_writer & operator <<(uint16 value) {write(value); return *this;}
      binary_writer & operator <<(uint32 value) {write(value); return *this;}
      binary_writer & operator <<(uint64 value) {write(value); return *this;}
      
    private:
      void write_7bit_encoded_int(int32 value);
      std::ostream* stream_ = nullptr;
      bool delete_when_destroy_ = false;
    };
  }
}