stream.h

Go to the documentation of this file.

 
#ifndef CPPCOMMON_SYSTEM_STREAM_H
#define CPPCOMMON_SYSTEM_STREAM_H
 
#include "common/reader.h"
#include "common/writer.h"
#include "errors/exceptions.h"
 
#include <memory>
 
namespace CppCommon {
 
 
class StdInput : public Reader
{
public:
    StdInput();
    StdInput(const StdInput&) = delete;
    StdInput(StdInput&& stream) = delete;
    virtual ~StdInput();
 
    StdInput& operator=(const StdInput&) = delete;
    StdInput& operator=(StdInput&& stream) = delete;
 
    explicit operator bool() const noexcept { return IsValid(); }
 
    void* stream() const noexcept;
 
    bool IsValid() const noexcept;
 
 
    size_t Read(void* buffer, size_t size) override;
 
    using Reader::ReadAllBytes;
    using Reader::ReadAllText;
    using Reader::ReadAllLines;
 
    void swap(StdInput& stream) noexcept;
    friend void swap(StdInput& stream1, StdInput& stream2) noexcept;
 
private:
    class Impl;
 
    Impl& impl() noexcept { return reinterpret_cast<Impl&>(_storage); }
    const Impl& impl() const noexcept { return reinterpret_cast<Impl const&>(_storage); }
 
    static const size_t StorageSize = 8;
    static const size_t StorageAlign = 8;
    alignas(StorageAlign) std::byte _storage[StorageSize];
};
 
 
class StdOutput : public Writer
{
public:
    StdOutput();
    StdOutput(const StdOutput&) = delete;
    StdOutput(StdOutput&& stream) = delete;
    virtual ~StdOutput();
 
    StdOutput& operator=(const StdOutput&) = delete;
    StdOutput& operator=(StdOutput&& stream) = delete;
 
    explicit operator bool() const noexcept { return IsValid(); }
 
    void* stream() const noexcept;
 
    bool IsValid() const noexcept;
 
 
    size_t Write(const void* buffer, size_t size) override;
 
    using Writer::Write;
 
    void Flush() override;
 
    void swap(StdOutput& stream) noexcept;
    friend void swap(StdOutput& stream1, StdOutput& stream2) noexcept;
 
private:
    class Impl;
 
    Impl& impl() noexcept { return reinterpret_cast<Impl&>(_storage); }
    const Impl& impl() const noexcept { return reinterpret_cast<Impl const&>(_storage); }
 
    static const size_t StorageSize = 8;
    static const size_t StorageAlign = 8;
    alignas(StorageAlign) std::byte _storage[StorageSize];
};
 
 
class StdError : public Writer
{
public:
    StdError();
    StdError(const StdError&) = delete;
    StdError(StdError&& stream) = delete;
    virtual ~StdError();
 
    StdError& operator=(const StdError&) = delete;
    StdError& operator=(StdError&& stream) = delete;
 
    explicit operator bool() const { return IsValid(); }
 
    void* stream() const noexcept;
 
    bool IsValid() const noexcept;
 
 
    size_t Write(const void* buffer, size_t size) override;
 
    using Writer::Write;
 
    void Flush() override;
 
    void swap(StdError& stream) noexcept;
    friend void swap(StdError& stream1, StdError& stream2) noexcept;
 
private:
    class Impl;
 
    Impl& impl() noexcept { return reinterpret_cast<Impl&>(_storage); }
    const Impl& impl() const noexcept { return reinterpret_cast<Impl const&>(_storage); }
 
    static const size_t StorageSize = 8;
    static const size_t StorageAlign = 8;
    alignas(StorageAlign) std::byte _storage[StorageSize];
};
 
} // namespace CppCommon
 
#include "stream.inl"
 
#endif // CPPCOMMON_SYSTEM_STREAM_H