stream.hpp

Go to the documentation of this file.

 
#pragma once
#include "io_exception.hpp"
#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(std::any async_state) : async_state_(async_state) {}
        std::any 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_;};
        
        std::any 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(stream& owner);
        
        int_type underflow() override;
        int_type overflow(int_type value) override;
        
      private:
        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 int32 eof = EOF;
      
      
      virtual bool can_read() const noexcept = 0;
 
      virtual bool can_seek() const noexcept = 0;
 
      virtual bool can_timeout() const noexcept;
 
      virtual bool can_write() const noexcept = 0;
 
      virtual bool is_closed() const noexcept;
 
      virtual xtd::size length() const = 0;
 
      virtual xtd::size position() const = 0;
      virtual void position(xtd::size value) = 0;
      
      virtual int32 read_timeout() const;
      virtual void read_timeout(int32 value);
 
      virtual int32 write_timeout() const;
 
      virtual void write_timeout(int32 value);
      
      
      void copy_to(std::ostream& destination);
      
      void copy_to(std::ostream& destination, xtd::size buffer_size);
      
      virtual void flush() = 0;
      
      using std::iostream::read;
      virtual xtd::size read(xtd::span<xtd::byte>& buffer);
      virtual xtd::size read(xtd::array<xtd::byte>& buffer, xtd::size offset, xtd::size count) = 0;
      
      xtd::size read_at_least(xtd::array<xtd::byte>& buffer, xtd::size minimum_bytes, bool throw_on_end_of_stream = true);
 
      virtual int32 read_byte();
 
      void read_exactly(xtd::array<xtd::byte>& buffer);
      void read_exactly(xtd::array<xtd::byte>& buffer, xtd::size offset, xtd::size count);
 
      virtual void set_length(xtd::size value) = 0;
      
      using std::iostream::write;
      virtual void write(xtd::span<const xtd::byte> buffer);
      virtual void write(const xtd::array<xtd::byte>& buffer, xtd::size offset, xtd::size count) = 0;
 
      virtual void write_byte(xtd::byte value);
      
    protected:
      
      stream();
      
    private:
      streambuf streambuf_ {*this};
      bool closed_ = false;
    };
  }
}