text_writer.h

Go to the documentation of this file.

#pragma once

#include <cstdio>
#include <istream>
#include <mutex>
#include <string>
#include "../core_export.h"
#include "../object.h"
#include "../ustring.h"

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