stream.hpp

Go to the documentation of this file.

#pragma once
#include "seek_origin.hpp"
#include "../threading/manual_reset_event.hpp"
#include "../abstract_object.hpp"
#include "../async_callback.hpp"
#include "../core_export.hpp"
#include "../iasync_result.hpp"
#include "../span.hpp"
#include "../string.hpp"
#include <cstdio>
#include <sstream>

namespace xtd {
  namespace io {
    class null_stream;
    
    class core_export_ stream :  public xtd::abstract_object, public std::iostream {
      class async_result_stream : public xtd::object, public xtd::iasync_result {
      public:
        explicit async_result_stream(const xtd::any_object& async_state) : async_state_(async_state) {}
        xtd::any_object async_state() const noexcept override {return async_state_;}
        xtd::threading::wait_handle& async_wait_handle() noexcept override {return async_event_;}
        bool completed_synchronously() const noexcept override {return false;}
        bool is_completed() const noexcept override {return is_completed_;};
        
        xtd::any_object async_state_;
        bool is_completed_ = false;
        xtd::threading::manual_reset_event async_event_;
        std::exception_ptr exception_;
      };
      
      class streambuf : public std::streambuf {
      public:
        explicit streambuf(xtd::io::stream& owner);
        
        int_type underflow() override;
        int_type overflow(int_type value) override;
        
      private:
        xtd::io::stream& owner_;
        xtd::byte value_ = 0;
        char_type* value_ptr_ = reinterpret_cast<char_type*>(&value_);
      };
      
    public:
      
      
      
      static xtd::io::null_stream null_stream;
      
      inline static constexpr xtd::int32 eof = EOF;
      
      
      [[nodiscard]] virtual auto can_read() const noexcept -> bool = 0;
      
      [[nodiscard]] virtual auto can_seek() const noexcept -> bool = 0;
      
      [[nodiscard]] virtual auto can_timeout() const noexcept -> bool;
      
      [[nodiscard]] virtual auto can_write() const noexcept -> bool = 0;
      
      [[nodiscard]] virtual auto is_closed() const noexcept -> bool;
      
      [[nodiscard]] virtual auto length() const -> xtd::usize = 0;
      
      [[nodiscard]] virtual auto position() const -> xtd::usize = 0;
      virtual auto position(xtd::usize value) -> void = 0;
      
      [[nodiscard]] virtual auto read_timeout() const -> xtd::int32;
      virtual auto read_timeout(xtd::int32 value) -> void;
      
      [[nodiscard]] virtual auto write_timeout() const -> xtd::int32;
      
      virtual auto write_timeout(xtd::int32 value) -> void;
      
      
      auto copy_to(std::ostream& destination) -> void;
      
      auto copy_to(std::ostream& destination, xtd::usize buffer_size) -> void;
      
      virtual auto flush() -> void = 0;
      
      using std::iostream::read;
      virtual auto read(xtd::span<xtd::byte>& buffer) -> xtd::usize;
      virtual auto read(xtd::array<xtd::byte>& buffer, xtd::usize offset, xtd::usize count) -> xtd::usize = 0;
      
      auto read_at_least(xtd::array<xtd::byte>& buffer, xtd::usize minimum_bytes, bool throw_on_end_of_stream = true) -> xtd::usize;
      
      [[nodiscard]] virtual auto read_byte() -> xtd::int32;
      
      auto read_exactly(xtd::array<xtd::byte>& buffer) -> void;
      auto read_exactly(xtd::array<xtd::byte>& buffer, xtd::usize offset, xtd::usize count) -> void;
      
      virtual auto set_length(xtd::usize value) -> void = 0;
      
      using std::iostream::write;
      virtual auto write(xtd::span<const xtd::byte> buffer) -> void;
      virtual auto write(const xtd::array<xtd::byte>& buffer, xtd::usize offset, xtd::usize count) -> void = 0;
      
      virtual auto write_byte(xtd::byte value) -> void;
      
    protected:
      
      stream();
      
    private:
      streambuf streambuf_ {*this};
      bool closed_ = false;
    };
  }
}