binary_writer.h

Go to the documentation of this file.

 
#pragma once
#include "../optional.h"
#include "../object.h"
#include "../ustring.h"
#include <fstream>
#include <array>
#include <vector>
 
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(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 std::vector<xtd::byte>& buffer);
      
      virtual void write(const std::vector<xtd::byte>& 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 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 ustring& value);
      virtual void write(const std::string& value);
#if defined(__cpp_lib_char8_t)
      virtual void write(const std::u8string& value);
#endif
      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);
#if defined(__cpp_lib_char8_t)
      virtual void write(const char8* value);
#endif
      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);
      
      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<xtd::byte, 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<xtd::byte>& 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 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 ustring& value) {write(value); return *this;}
      binary_writer& operator <<(const std::string& value) {write(value); return *this;}
#if defined(__cpp_lib_char8_t)
      binary_writer& operator <<(const std::u8string& value) {write(value); return *this;}
#endif
      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;}
#if defined(__cpp_lib_char8_t)
      binary_writer& operator <<(const char8* value) {write(value); return *this;}
#endif
      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:
      std::ostream* stream_ = nullptr;
      bool delete_when_destroy_ = false;
    };
  }
}