text_writer.hpp

Go to the documentation of this file.

#pragma once
#include "../core_export.hpp"
#include "../object.hpp"
#include "../string.hpp"
#include <cstdio>
#include <istream>
#include <string>

namespace xtd {
  namespace io {
    class null_text_writer;
    class synchronized_text_writer;
    
    class core_export_ text_writer : public xtd::object {
    public:
      
      [[nodiscard]] static auto null() noexcept -> null_text_writer&;
      
      
      [[nodiscard]] auto new_line() const noexcept -> const xtd::string&;
      auto new_line(const xtd::string& new_line) noexcept -> void;
      
      
      virtual auto close() -> void;
      
      virtual auto flush() -> void;
      
      virtual auto write(const xtd::string& value) -> void;
      
      auto write(bool value) -> void;
      
      auto write(double value) -> void;
      
      auto write(float value) -> void;
      
      auto write(sbyte value) -> void;
      
      auto write(int16 value) -> void;
      
      auto write(int32 value) -> void;
      
      auto write(int64 value) -> void;
      
      auto write(xtd::byte value) -> void;
      
      auto write(uint16 value) -> void;
      
      auto write(uint32 value) -> void;
      
      auto write(uint64 value) -> void;
      
      template<class value_t>
      auto write(value_t value) -> void {write(xtd::string::format("{}", value));}
      
      template<class ...args_t>
      auto write(const xtd::string& fmt, args_t&& ... args) noexcept -> void {write(xtd::string::format(fmt, std::forward<args_t>(args)...));}
      
      auto write_line() -> void;
      
      auto write_line(const xtd::string& value) -> void;
      
      auto write_line(bool value) -> void;
      
      auto write_line(double value) -> void;
      
      auto write_line(float value) -> void;
      
      auto write_line(sbyte value) -> void;
      
      auto write_line(int16 value) -> void;
      
      auto write_line(int32 value) -> void;
      
      auto write_line(int64 value) -> void;
      
      auto write_line(xtd::byte value) -> void;
      
      auto write_line(uint16 value) -> void;
      
      auto write_line(uint32 value) -> void;
      
      auto write_line(uint64 value) -> void;
      
      template<class value_t>
      auto write_line(value_t value) -> void {write_line(xtd::string::format("{}", value));}
      
      template<class ...args_t>
      auto write_line(const xtd::string& fmt, args_t&& ... args) noexcept -> void {write_line(xtd::string::format(fmt, std::forward<args_t>(args)...));}
      
      
      [[nodiscard]] static auto synchronised(text_writer& writer) noexcept -> synchronized_text_writer;
      
    protected:
      
      text_writer() = default;
      
    private:
      xtd::string new_line_ = "\n";
    };
    
    class core_export_ null_text_writer : public xtd::io::text_writer {
    public:
      auto write(const xtd::string&) -> void override;
    };
    
    class core_export_ synchronized_text_writer : public xtd::io::text_writer {
    public:
      auto write(const xtd::string& value) -> void override ;
      
    private:
      friend class text_writer;
      explicit synchronized_text_writer(xtd::io::text_writer& writer);
      synchronized_text_writer() = delete;
      xtd::io::text_writer& writer_;
    };
  }
}