From c2f637904c93ca59c02ce0471898125576a5d767 Mon Sep 17 00:00:00 2001
From: Mobin Aydinfar <mobin@mobintestserver.ir>
Date: Wed, 13 Sep 2023 20:45:19 +0330
Subject: [PATCH] dinit-iostream & dinit-fstream: Custom new special-purpose
 libraries

These are replacement for C++ standard library iostream/fstream.

See dinit-iostream.h and dinit-fstream.h for more information and the usage.

Signed-off-by: Mobin "Hojjat" Aydinfar <mobin@mobintestserver.ir>
Reviewed-by: Davin McCall <EMAIL HIDDEN>
---
 src/dinit-fstream.cc          | 171 ++++++++
 src/dinit-iostream.cc         | 582 ++++++++++++++++++++++++++
 src/includes/dinit-fstream.h  | 382 +++++++++++++++++
 src/includes/dinit-iostream.h | 742 ++++++++++++++++++++++++++++++++++
 4 files changed, 1877 insertions(+)
 create mode 100644 src/dinit-fstream.cc
 create mode 100644 src/dinit-iostream.cc
 create mode 100644 src/includes/dinit-fstream.h
 create mode 100644 src/includes/dinit-iostream.h

diff --git a/src/dinit-fstream.cc b/src/dinit-fstream.cc
new file mode 100644
index 00000000..1545a0dd
--- /dev/null
+++ b/src/dinit-fstream.cc
@@ -0,0 +1,171 @@
+#include <cstring>
+
+#include <dinit-fstream.h>
+
+// See dinit-fstream.h for inforamtion about the usage
+
+namespace dio {
+
+// class fstream_base
+int fstream_base::open(const char *path, const int flags) noexcept
+{
+    if (path == nullptr || path[0] == '\0') {
+        errno = EINVAL;
+        return -1; // Path is empty
+    }
+    int fd = bp_sys::open(path, flags);
+    if (fd < 0) return -1; // Failed
+    are_we_open = true;
+    return fd;
+}
+
+int fstream_base::open(const char *path, const int flags, const mode_t mode) noexcept
+{
+    if (path == nullptr || path[0] == '\0') {
+        errno = EINVAL;
+        return -1; // Path is empty
+    }
+    int fd = bp_sys::open(path, flags, mode);
+    if (fd < 0) return -1; // Failed
+    are_we_open = true;
+    return fd;
+}
+
+bool fstream_base::is_open() noexcept
+{
+    return are_we_open;
+}
+
+int fstream_base::close(const int fd) noexcept
+{
+    if (!is_open()) return -1;
+
+    int r = bp_sys::close(fd);
+    if (r < 0) return fd; // Failed
+    are_we_open = false;
+    return -1; // -1 means successful
+}
+
+// class ofstream
+bool ofstream::open() noexcept
+{
+    setfd(fstream_base::open(path, O_WRONLY));
+    return (getfd() >= 0);
+}
+
+bool ofstream::open(const int flags) noexcept
+{
+    setfd(fstream_base::open(path, O_WRONLY | flags));
+    return (getfd() >= 0);
+}
+
+bool ofstream::open(const int flags, const mode_t mode) noexcept
+{
+    setfd(fstream_base::open(path, O_WRONLY | flags, mode));
+    return (getfd() >= 0);
+}
+
+bool ofstream::open(const char *dpath) noexcept
+{
+    path = dpath;
+    open();
+    return (getfd() >= 0);
+}
+
+bool ofstream::open(const char *dpath, const int flags) noexcept
+{
+    path = dpath;
+    open(flags);
+    return (getfd() >= 0);
+}
+
+bool ofstream::open(const char *dpath, const int flags, const mode_t mode) noexcept
+{
+    path = dpath;
+    open(flags, mode);
+    return (getfd() >= 0);
+}
+
+bool ofstream::close() noexcept
+{
+    if (is_open()) setfd(fstream_base::close(getfd()));
+    return (getfd() < 0);
+}
+
+bool ofstream::operator!() noexcept
+{
+    return !is_open();
+}
+
+ofstream::operator bool() noexcept
+{
+    return is_open();
+}
+
+ofstream::~ofstream() noexcept
+{
+    close();
+}
+
+// class ifstream
+bool ifstream::open() noexcept
+{
+    setfd(fstream_base::open(path, O_RDONLY));
+    return (getfd() >= 0);
+}
+
+bool ifstream::open(const int flags) noexcept
+{
+    setfd(fstream_base::open(path, O_RDONLY | flags));
+    return (getfd() >= 0);
+}
+
+bool ifstream::open(const int flags, const mode_t mode) noexcept
+{
+    setfd(fstream_base::open(path, O_RDONLY | flags, mode));
+    return (getfd() >= 0);
+}
+
+bool ifstream::open(const char *dpath) noexcept
+{
+    path = dpath;
+    open();
+    return (getfd() >= 0);
+}
+
+bool ifstream::open(const char *dpath, const int flags) noexcept
+{
+    path = dpath;
+    open(flags);
+    return (getfd() >= 0);
+}
+
+bool ifstream::open(const char *dpath, const int flags, const mode_t mode) noexcept
+{
+    path = dpath;
+    open(flags, mode);
+    return (getfd() >= 0);
+}
+
+bool ifstream::close() noexcept
+{
+    if (is_open()) setfd(fstream_base::close(getfd()));
+    return (getfd() < 0);
+}
+
+bool ifstream::operator!() noexcept
+{
+    return !is_open();
+}
+
+ifstream::operator bool() noexcept
+{
+    return is_open();
+}
+
+ifstream::~ifstream() noexcept
+{
+    close();
+}
+
+} /* dio namespace */
diff --git a/src/dinit-iostream.cc b/src/dinit-iostream.cc
new file mode 100644
index 00000000..2d152454
--- /dev/null
+++ b/src/dinit-iostream.cc
@@ -0,0 +1,582 @@
+#include <algorithm>
+#include <exception>
+#include <limits>
+#include <cstring>
+
+#include <dinit-iostream.h>
+#include <baseproc-sys.h>
+
+// See dinit-iostream.h for inforamtion about the usage
+
+namespace {
+
+// A simple trick for calculating how much digits can be in a type with compile-time
+// integer logarithm like function.
+template <typename T> constexpr T TYPE_MAX_NUMDIGITS(T num = std::numeric_limits<T>::max(),
+        unsigned pow = 0)
+{
+    return (num == 0) ? pow : TYPE_MAX_NUMDIGITS(num / 10, pow + 1);
+}
+
+constexpr unsigned INT_NUMDIGITS = TYPE_MAX_NUMDIGITS<int>() + 1;
+constexpr unsigned UINT_NUMDIGITS = TYPE_MAX_NUMDIGITS<unsigned>() + 1;
+constexpr unsigned LONG_NUMDIGITS = TYPE_MAX_NUMDIGITS<long>() + 1;
+
+} /* anonymous namespace */
+
+namespace dio {
+
+// class streambuf_base
+streambuf *streambuf_base::get_buf() noexcept
+{
+    return buf.get();
+}
+
+// class ostream
+ssize_t ostream::put(const char *msg) noexcept
+{
+    if (!buf) {
+        setstate(diostates::buffer_failbit, true);
+        return -1; // Tried to use output on null pointer buffer
+    }
+    else if (buffer_failure()) {
+        setstate(diostates::buffer_failbit, false);
+    }
+
+    // Capturing flush_nothrow() calls for returing exat number of written charactors
+    unsigned flush_result = 0;
+
+    if (msg == nullptr) {
+        return 0; // Null message
+    }
+    unsigned msg_len = strlen(msg);
+    if (msg_len == 0) {
+        return 0; // Empty message
+    }
+    else if (msg_len > buf->get_size()) {
+        ssize_t r = flush_nothrow();
+        if (r < 0) {
+            // posixio_errno was set by flush_nothrow() call
+            return -1;
+        }
+        ssize_t res = bp_sys::write(fd, msg, msg_len);
+        if (res < 0) {
+            setstate(diostates::posixio_errno, errno);
+            return -1;
+        }
+        return (r > 0) ? r + res : -1;
+    }
+    else while (msg_len > buf->get_free()) {
+        // If we haven't enough storage for caputring the message
+        // Firstly we try to free-up the buffer and then continue the
+        // normal opreation.
+        // If we cannot, We set posixio_errno by POSIX errno and return -1.
+        int prev_freespace = buf->get_free();
+        buf->append(msg, buf->get_free());
+        msg += prev_freespace;
+        msg_len -= prev_freespace;
+        ssize_t r = flush_nothrow();
+        if (r > 0) {
+            flush_result += r;
+            continue;
+        }
+        if (r < 0) {
+            // posixio_errno was set by flush_nothrow()
+            return -1;
+        }
+    }
+
+    buf->append(msg, msg_len);
+
+    return flush_result;
+}
+
+void ostream::throw_on_states(const int bit, const bool do_throw) noexcept
+{
+    if ((bit & diostates::buffer_failbit) && throw_on_buffer_fail != do_throw) {
+        throw_on_buffer_fail = do_throw;
+    }
+    if ((bit & diostates::posixio_errno) && throw_on_posixio_fail != do_throw) {
+        throw_on_posixio_fail = do_throw;
+    }
+}
+
+void ostream::clear_throws() noexcept
+{
+    throw_on_states(diostates::buffer_failbit | diostates::posixio_errno, false);
+}
+
+void ostream::setfd(const int tfd) noexcept
+{
+    fd = tfd;
+}
+
+int ostream::getfd() noexcept
+{
+    return fd;
+}
+
+void ostream::setstate(const int bit, const int value) noexcept
+{
+    if (bit & diostates::buffer_failbit) {
+        buffer_failbit = value;
+    }
+    if (bit & diostates::posixio_errno) {
+        posixio_errno = value;
+    }
+}
+
+int ostream::rdstate() noexcept
+{
+    int bits = 0;
+    if (buffer_failbit) bits |= diostates::buffer_failbit;
+    if (posixio_errno) bits |= diostates::posixio_errno;
+    return bits;
+}
+
+int ostream::good() noexcept
+{
+    return (rdstate() == 0);
+}
+
+int ostream::buffer_failure() noexcept
+{
+    return (rdstate() & buffer_failbit);
+}
+
+int ostream::posixio_failure() noexcept
+{
+    return posixio_errno;
+}
+
+void ostream::clear() noexcept
+{
+    // Reset all failures
+    setstate(diostates::buffer_failbit | diostates::posixio_errno, 0);
+}
+
+ssize_t ostream::flush_nothrow()
+{
+    if (!buf) {
+        setstate(diostates::buffer_failbit, true);
+        return -1; // Tried to use output on null pointer buffer
+    }
+    else if (buffer_failure()) {
+        setstate(diostates::buffer_failbit, false);
+    }
+    ssize_t r = 0;
+    while (buf->get_length() > 0) {
+        char *ptr = buf->get_ptr(0);
+        unsigned len = buf->get_contiguous_length(ptr);
+        r = bp_sys::write(fd, ptr, len);
+
+        if (r < 0) {
+            setstate(diostates::posixio_errno, errno);
+            return -1;
+        }
+        buf->consume(r);
+    }
+
+    return r;
+}
+
+ssize_t ostream::flush()
+{
+    ssize_t r = flush_nothrow();
+    if (buffer_failure() && throw_on_buffer_fail) {
+        throw iostream_error("Cannot use stream's buffer: buffer is nullptr!");
+    }
+    if (posixio_failure() && throw_on_posixio_fail) {
+        throw posixio_error(posixio_failure());
+    }
+    return r;
+}
+
+ssize_t ostream::write_nothrow(const char *msg) noexcept
+{
+    return put(msg);
+}
+
+ssize_t ostream::write(const char *msg)
+{
+    ssize_t r = write_nothrow(msg);
+    if (buffer_failure() && throw_on_buffer_fail) {
+        throw iostream_error("Cannot use stream's buffer: buffer is nullptr!");
+    }
+    if (posixio_failure() && throw_on_posixio_fail) {
+        throw posixio_error(posixio_failure());
+    }
+    return r;
+}
+
+ssize_t ostream::write_nothrow(const char msg) noexcept
+{
+    char tmp[2];
+    tmp[0] = msg;
+    tmp[1] = '\0';
+    return put(tmp);
+}
+
+ssize_t ostream::write(const char msg)
+{
+    ssize_t r = write_nothrow(msg);
+    if (buffer_failure() && throw_on_buffer_fail) {
+        throw iostream_error("Cannot use stream's buffer: buffer is nullptr!");
+    }
+    if (posixio_failure() && throw_on_posixio_fail) {
+        throw posixio_error(posixio_failure());
+    }
+    return r;
+}
+
+ssize_t ostream::write_nothrow(const std::string &msg) noexcept
+{
+    return put(msg.c_str());
+}
+
+ssize_t ostream::write(const std::string &msg)
+{
+    ssize_t r = write_nothrow(msg);
+    if (buffer_failure() && throw_on_buffer_fail) {
+        throw iostream_error("Cannot use stream's buffer: buffer is nullptr!");
+    }
+    if (posixio_failure() && throw_on_posixio_fail) {
+        throw posixio_error(posixio_failure());
+    }
+    return r;
+}
+
+ssize_t ostream::write_nothrow(const int num) noexcept
+{
+    char tmp[INT_NUMDIGITS];
+    snprintf(tmp, sizeof(tmp), "%d", num);
+    return put(tmp);
+}
+
+ssize_t ostream::write(const int num)
+{
+    ssize_t r = write_nothrow(num);
+    if (buffer_failure() && throw_on_buffer_fail) {
+        throw iostream_error("Cannot use stream's buffer: buffer is nullptr!");
+    }
+    if (posixio_failure() && throw_on_posixio_fail) {
+        throw posixio_error(posixio_failure());
+    }
+    return r;
+}
+
+ssize_t ostream::write_nothrow(const unsigned num) noexcept
+{
+    char tmp[UINT_NUMDIGITS];
+    snprintf(tmp, sizeof(tmp), "%d", num);
+    return put(tmp);
+}
+
+ssize_t ostream::write(const unsigned num)
+{
+    ssize_t r = write_nothrow(num);
+    if (buffer_failure() && throw_on_buffer_fail) {
+        throw iostream_error("Cannot use stream's buffer: buffer is nullptr!");
+    }
+    if (posixio_failure() && throw_on_posixio_fail) {
+        throw posixio_error(posixio_failure());
+    }
+    return r;
+}
+
+ssize_t ostream::write_nothrow(const long num) noexcept
+{
+    char tmp[LONG_NUMDIGITS];
+    snprintf(tmp, sizeof(tmp), "%ld", num);
+    return put(tmp);
+}
+
+ssize_t ostream::write(const long num)
+{
+    ssize_t r = write_nothrow(num);
+    if (buffer_failure() && throw_on_buffer_fail) {
+        throw iostream_error("Cannot use stream's buffer: buffer is nullptr!");
+    }
+    if (posixio_failure() && throw_on_posixio_fail) {
+        throw posixio_error(posixio_failure());
+    }
+    return r;
+}
+
+ssize_t ostream::write_nothrow(const endline &) noexcept
+{
+    int r = put("\n");
+    return (r > 0) ? flush_nothrow() + r : flush_nothrow();
+}
+
+ssize_t ostream::write(const endline &)
+{
+    int r = put("\n");
+    return (r > 0) ? flush() + r : flush();
+}
+
+ssize_t ostream::write_nothrow(const flushbuf &) noexcept
+{
+    return flush_nothrow();
+}
+
+ssize_t ostream::write(const flushbuf &)
+{
+    return flush();
+}
+
+ostream::~ostream() noexcept
+{
+    flush_nothrow();
+}
+
+// Standard output "cout" on STDOUT_FILENO file descriptor
+ostream cout(STDOUT_FILENO);
+// Standard error output "cerr" on STDERR_FILENO file descriptor
+ostream cerr(STDERR_FILENO);
+
+// class istream
+void istream::throw_on_states(const int bit, const bool do_throw) noexcept
+{
+    if ((bit & diostates::eofbit) && throw_on_eofbit != do_throw) {
+        throw_on_eofbit = do_throw;
+    }
+    if ((bit & diostates::buffer_failbit) && throw_on_buffer_fail != do_throw) {
+        throw_on_buffer_fail = do_throw;
+    }
+    if ((bit & diostates::string_failbit) && throw_on_string_fail != do_throw){
+        throw_on_string_fail = do_throw;
+    }
+    if ((bit & diostates::posixio_errno) && throw_on_posixio_fail != do_throw) {
+        throw_on_posixio_fail = do_throw;
+    }
+}
+
+void istream::clear_throws() noexcept
+{
+    throw_on_states(diostates::eofbit | diostates::buffer_failbit | diostates::string_failbit |
+            diostates::posixio_errno, false);
+}
+
+void istream::setfd(const int tfd) noexcept
+{
+    fd = tfd;
+}
+
+int istream::getfd() noexcept
+{
+    return fd;
+}
+
+void istream::setstate(const int bit, const int value) noexcept
+{
+    if (bit & diostates::eofbit) {
+        eofbit = value;
+    }
+    if (bit & diostates::buffer_failbit) {
+        buffer_failbit = value;
+    }
+    if (bit & diostates::string_failbit) {
+        string_failbit = value;
+    }
+    if (bit & diostates::posixio_errno) {
+        posixio_errno = value;
+    }
+}
+
+int istream::rdstate() noexcept
+{
+    int bits = 0;
+    if (eofbit) bits |= diostates::eofbit;
+    if (buffer_failbit) bits |= diostates::buffer_failbit;
+    if (string_failbit) bits |= diostates::string_failbit;
+    if (posixio_errno) bits |= diostates::posixio_errno;
+    return bits;
+}
+
+int istream::good() noexcept
+{
+    return (rdstate() == 0);
+}
+
+int istream::eof() noexcept
+{
+    return (rdstate() & diostates::eofbit);
+}
+
+int istream::buffer_failure() noexcept
+{
+    return (rdstate() & diostates::buffer_failbit);
+}
+
+int istream::string_failure() noexcept
+{
+    return (rdstate() & diostates::string_failbit);
+}
+
+int istream::posixio_failure() noexcept
+{
+    return posixio_errno;
+}
+
+void istream::clear() noexcept
+{
+    setstate(diostates::eofbit | diostates::buffer_failbit | diostates::string_failbit |
+            diostates::posixio_errno, 0);
+}
+
+int istream::read(unsigned len) noexcept
+{
+    if (!buf) {
+        setstate(diostates::buffer_failbit, true);
+        return -1; // Tried to use input on null pointer buffer
+    }
+    else if (buffer_failure()) {
+        setstate(diostates::buffer_failbit, false);
+    }
+
+    int r = buf->fill(fd, len);
+    if (r < 0) {
+        setstate(diostates::posixio_errno, errno);
+        return -1;
+    }
+    return r;
+}
+
+int istream::getc_nothrow() noexcept
+{
+    if (!buf) {
+        setstate(diostates::buffer_failbit, true);
+        return -1; // Tried to use input on null pointer buffer
+    }
+    else if (buffer_failure()) {
+        setstate(diostates::buffer_failbit, false);
+    }
+    if (buf->get_length() == 0) {
+        int r = read(1);
+        if (r == 0) {
+            setstate(diostates::eofbit, true);
+            return EOF;
+        }
+        else if (r < 0) {
+            setstate(diostates::posixio_errno, errno);
+            return EOF;
+        }
+    }
+    char result = *buf->get_ptr(0);
+    buf->consume(1);
+    return result;
+}
+
+int istream::getc()
+{
+    int r = getc_nothrow();
+    if (r <= 0) {
+        if (buffer_failure() && throw_on_buffer_fail) {
+            throw iostream_error("Cannot use stream's buffer: buffer is nullptr!");
+        }
+        if (eof() && throw_on_eofbit) {
+            throw iostream_eof("End Of File has been reached.");
+        }
+        if (posixio_failure() && throw_on_posixio_fail) {
+            throw posixio_error(posixio_failure());
+        }
+    }
+    return r;
+}
+
+ssize_t istream::getline_nothrow(std::string &dest, char delim) noexcept
+{
+    if (!buf) {
+        setstate(diostates::buffer_failbit, true);
+        return -1; // Tried to use input on null pointer buffer
+    }
+    else if (buffer_failure()) {
+        setstate(diostates::buffer_failbit, false);
+    }
+    if (buf->get_length() == 0) {
+        int r = read(buf->get_size());
+        if (r == 0) {
+            setstate(diostates::eofbit, true);
+            return 0;
+        }
+        if (r < 0) {
+            setstate(diostates::posixio_errno, errno);
+            return -1;
+        }
+    }
+    dest.erase(dest.begin(), dest.end());
+    unsigned index = 0;
+    char *ptr = buf->get_ptr(0);
+    unsigned len = buf->get_contiguous_length(ptr);
+    char *creptr = ptr + len;  // contiguous region end
+    char *eptr = std::find(ptr, creptr, delim);
+    index = eptr - ptr;
+    if (eptr == ptr) {
+        buf->consume(1);
+        return 1; // An empty line
+    }
+    else if (eptr == creptr) {
+        // If it hasn't any delim; We try to read as much as possible to reach the EOF
+        // or find a "delim" charactor
+        while (eptr == creptr) {
+            // dest.append() may throw out_of_range, length_error or bad_alloc
+            try {
+                dest.append(ptr, ptr + index);
+                buf->consume(index);
+            }
+            catch (std::exception &) {
+                setstate(diostates::string_failbit, true);
+                return -1;
+            }
+            int r = read(buf->get_size());
+            if (r == 0) {
+                return dest.length();
+            }
+            else if (r < 0) {
+                setstate(diostates::posixio_errno, errno);
+                return -1;
+            }
+            ptr = buf->get_ptr(0);
+            len = buf->get_contiguous_length(ptr);
+            creptr = ptr + len;  // contiguous region end
+            eptr = std::find(ptr, creptr, delim);
+            index = eptr - ptr;
+        };
+    }
+    // dest.append() may throw out_of_range, length_error or bad_alloc
+    try {
+        dest.append(ptr, ptr + index);
+        buf->consume(index + 1); // Cleanup delim charactor also
+    }
+    catch (std::exception &) {
+        setstate(diostates::string_failbit, true);
+        return -1;
+    }
+    return dest.length();
+}
+
+ssize_t istream::getline(std::string &dest, char delim)
+{
+    ssize_t r = getline_nothrow(dest, delim);
+    if (r <= 0) {
+        if (buffer_failure() && throw_on_buffer_fail) {
+            throw iostream_error("Cannot use stream's buffer: buffer is nullptr!");
+        }
+        if (eof() && throw_on_eofbit) {
+            throw iostream_eof("End Of File has been reached.");
+        }
+        if (string_failure() && throw_on_string_fail) {
+            throw iostream_error("Cannot put lines into given std::string.");
+        }
+        if (posixio_failure() && throw_on_posixio_fail) {
+            throw posixio_error(posixio_failure());
+        }
+    }
+    return r;
+}
+
+// Standard input "cin" on STDIN_FILENO file descriptor
+istream cin(STDIN_FILENO);
+
+} /* dio namespace */
diff --git a/src/includes/dinit-fstream.h b/src/includes/dinit-fstream.h
new file mode 100644
index 00000000..e57ef079
--- /dev/null
+++ b/src/includes/dinit-fstream.h
@@ -0,0 +1,382 @@
+#ifndef DINIT_FSTREAM_H_INCLUDED
+#define DINIT_FSTREAM_H_INCLUDED 1
+
+#include <dinit-iostream.h>
+
+/*
+ * dinit-fstream is a special purpose library which provides a interface for automatic
+ * file descriptor handling (opening and closing). It's recommended to use this library
+ * instead of using pure iostream library and handling file descriptor yourself.
+ *
+ * This library provides two clases for output and input: ofstream and ifstream.
+ * See documention for each class in top of it.
+ *
+ * All of the functionality of this library is located in "dio" namespace.
+ */
+
+namespace dio {
+
+// fstream_base is class which maintains the file path and current state about
+// opened file and provides open() functions to opening a file path and will
+// return file descriptor number or -1 on failure cases in output/input streams.
+// It's supposed to be used in internal ofstream/ifstream functionality.
+class fstream_base
+{
+    protected:
+    const char *path; // File path
+    bool are_we_open = false;
+
+    public:
+    // open() functions
+    // Open file descriptor based on passed file path and return fd or -1
+    int open(const char *path, const int flags) noexcept;
+
+    int open(const char *path, const int flags, const mode_t mode) noexcept;
+
+    // Is current stream's file descriptor open?
+    bool is_open() noexcept;
+
+    // Close passed file descriptor and returns -1 on SUCCESS
+    int close(const int fd) noexcept;
+};
+
+/*
+ * ofstream
+ * =-=-=-=-
+ *
+ * This class is designed to provide automatic file descriptor management around
+ * ostream class. Users are supposed to use ofstream/ifstream instead of pure
+ * ostream/istream in most cases because it provides interfaces to open a
+ * file path and provides automatic closing file when it should (through destructor
+ * of class). It stores file path and current state of opened file descriptor.
+ *
+ * All of functionality and interfaces in this class are exception-free but ostream
+ * class members can throw exceptions. See documention of ostream class and its members.
+ *
+ * Constructors
+ * ------------
+ *
+ * ofstream class has four constructor:
+ *
+ *      // Simple construction
+ *      dio::ofstream output_a;
+ *      if (output_a.buffer_failure()) return -1; // Failure in buffer allocation
+ *
+ *      // Construction with moving pre-allocated unique_ptr of buffer
+ *      try {
+ *          std::unique_ptr<streambuf> my_buffer(new streambuf);
+ *      }
+ *      catch(const std::bad_alloc &) {
+ *          printerr("Cannot allocate memory for output buffer!\n");
+ *          return -1;
+ *      }
+ *      dio::ofstream output_b(std::move(my_buffer));
+ *
+ *      // Construction with file path.
+ *      dio::ofstream output_c("/path/to/file");
+ *      if (output_c.buffer_failure()) return -1; // Failure in buffer allocation
+ *
+ *      // Construction with combination of file path and moving pre-allocated unique_ptr of buffer
+ *      dio::ofstream output_d("/path/to/file", std::move(my_buffer));
+ *      if (output_d.buffer_failure()) return -1; // Failure in buffer allocation
+ *
+ * Also setting (or changing) file path/buffer after construction is available by
+ * open()/set_buf_with_owner() functions.
+ *
+ * copy/move constructors/assignments and destructor
+ * -------------------------------------------------
+ *
+ * ofstream copy constructor is prohibited (copy constructor is deleted).
+ * ofstream copy assignment is same as copy constructor.
+ *
+ * ofstream move constructor is prohibited (move constructor is deleted).
+ * ofstream move assignment is same as move constructor.
+ *
+ * ofstream destructor will write all of buffer content into its fd through
+ * flush_nothrow() call (through ostream destructor) and close current file descriptor.
+ *
+ * Public member: open()
+ * ---------------------
+ *
+ * ofstream provides open() functions to open a file path. See more details in top of
+ * each open() function. Will return true on success and false on failure. failure details
+ * should be check throw errno which will get set by open(2) on failure (and by this function
+ * itself when passed path is empty or nullptr to EINVAL).
+ *
+ * Note: O_WRONLY is hard-coded in internal call to POSIX open().
+ *
+ * Public member: close()
+ * ----------------------
+ *
+ * ofstream provides close() function to close current file descriptor if it is opened.
+ * Will return true on success or false on failure cases.
+ *
+ * Public member: is_open()
+ * ------------------------
+ *
+ * ofstream through derived fstream_base class provides is_open() function which return
+ * true when current file path is open or false when it's not.
+ *
+ * Public member: operator!()
+ * --------------------------
+ *
+ * ofstream overloads "!" operator and operator!() will return false when current file path is
+ * open or true when it's not.
+ *
+ *      if (!output_a) {
+ *          return errno; // Cannot open file
+ *      }
+ *
+ * Public member: operator bool()
+ * ------------------------------
+ *
+ * ofstream overloads "bool" operator and bool() will return true when current file path is
+ * open or false when it's not.
+ *
+ *      if (output_a) {
+ *          return; // success
+ *      }
+ *
+ * Error handling and Exception handling
+ * -------------------------------------
+ *
+ * ofstream class doesn't change stream state, and error details in opening/closing
+ * should be checked through POSIX errno.
+ *
+ * All of functionality and interfaces in this class are exception-free but ostream
+ * class members can throw exceptions. See documention of ostream class and its members.
+ */
+class ofstream : public fstream_base, public ostream
+{
+    public:
+    ofstream() noexcept
+    {
+        // constructor
+    }
+
+    ofstream(std::unique_ptr<streambuf> passed_buf) noexcept
+    {
+        // constructor
+        buf = std::move(passed_buf);
+    }
+
+    ofstream(const char *dest) noexcept
+    {
+        // constructor
+        path = dest;
+    }
+
+    ofstream(const char *dest, std::unique_ptr<streambuf> passed_buf) noexcept
+    {
+        // constructor
+        path = dest;
+        buf = std::move(passed_buf);
+    }
+
+    ofstream(const ofstream &) = delete; // copy constructor
+
+    ofstream operator=(const ofstream &) = delete; // copy assignment
+
+    ofstream(const ofstream &&) = delete; // move constructor
+
+    void operator=(const ofstream &&) = delete; // move assignment
+
+    // open() functions
+    // Open file path which specified in path or as open() parameter with flags or modes
+    // Note: O_WRONLY is hard-coded in internal call to POSIX open().
+    // Will return true on success and false on failure
+    bool open() noexcept;
+
+    bool open(const int flags) noexcept;
+
+    bool open(const int flags, const mode_t mode) noexcept;
+
+    bool open(const char *dpath) noexcept;
+
+    bool open(const char *dpath, const int flags) noexcept;
+
+    bool open(const char *dpath, const int flags, const mode_t mode) noexcept;
+
+    // Close current file descriptor if it is opened
+    bool close() noexcept;
+
+    // Return true if file is closed
+    bool operator!() noexcept;
+
+    // Return true if file is opened
+    operator bool() noexcept;
+
+    ~ofstream() noexcept;
+};
+
+/*
+ * ofstream
+ * =-=-=-=-
+ *
+ * This class is designed to provide automatic file descriptor management around
+ * istream class. Users are supposed to use ofstream/ifstream instead of pure
+ * ostream/istream in most cases because it provides interfaces to open a
+ * file path and provides automatic closing file when it should (through destructor
+ * of class). It stores file path and current state of opened file descriptor.
+ *
+ * All of functionality and interfaces in this class are exception-free but istream
+ * class members can throw exceptions. See documention of istream class and its members.
+ *
+ * Constructors
+ * ------------
+ *
+ * ifstream class has four constructor:
+ *
+ *      // Simple construction
+ *      dio::ifstream input_a;
+ *      if (input_a.buffer_failure()) return -1; // Failure in buffer allocation
+ *
+ *      // Construction with moving pre-allocated unique_ptr of buffer
+ *      try {
+ *          std::unique_ptr<streambuf> my_buffer(new streambuf);
+ *      }
+ *      catch(const std::bad_alloc &) {
+ *          printerr("Cannot allocate memory for input buffer!\n");
+ *          return -1;
+ *      }
+ *      dio::ifstream input_b(std::move(my_buffer));
+ *
+ *      // Construction with file path.
+ *      dio::ifstream input_c("/path/to/file");
+ *      if (input_c.buffer_failure()) return -1; // Failure in buffer allocation
+ *
+ *      // Construction with combination of file path and moving pre-allocated unique_ptr of buffer
+ *      dio::ifstream input_d("/path/to/file", std::move(my_buffer));
+ *      if (input_d.buffer_failure()) return -1; // Failure in buffer allocation
+ *
+ * Also setting (or changing) file path/buffer after construction is available by
+ * open()/set_buf_with_owner() functions.
+ *
+ * copy/move constructors/assignments and destructor
+ * -------------------------------------------------
+ *
+ * ifstream copy constructor is prohibited (copy constructor is deleted).
+ * ifstream copy assignment is same as copy constructor.
+ *
+ * ifstream move constructor is prohibited (move constructor is deleted).
+ * ifstream move assignment is same as move constructor.
+ *
+ * ifstream destructor will close current file descriptor.
+ *
+ * Public member: open()
+ * ---------------------
+ *
+ * ifstream provides open() functions to open a file path. See more details in top of
+ * each open() function. Will return true on success and false on failure. failure details
+ * should be check throw errno which will get set by open(2) on failure (and by this function
+ * itself when passed path is empty or nullptr to EINVAL).
+ *
+ * Note: O_RDONLY is hard-coded in internal call to POSIX open().
+ *
+ * Public member: close()
+ * ----------------------
+ *
+ * ifstream provides close() function to close current file descriptor if it is opened.
+ * Will return true on success or false on failure cases.
+ *
+ * Public member: is_open()
+ * ------------------------
+ *
+ * ifstream through derived fstream_base class provides is_open() function which return
+ * true when current file path is open or false when it's not.
+ *
+ * Public member: operator!()
+ * --------------------------
+ *
+ * ifstream overloads "!" operator and operator!() will return false when current file path is
+ * open or true when it's not.
+ *
+ *      if (!input_a) {
+ *          return errno; // Cannot open file
+ *      }
+ *
+ * Public member: operator bool()
+ * ------------------------------
+ *
+ * ifstream overloads "bool" operator and bool() will return true when current file path is
+ * open or false when it's not.
+ *
+ *      if (input_a) {
+ *          return; // success
+ *      }
+ *
+ * Error handling and Exception handling
+ * -------------------------------------
+ *
+ * ifstream class doesn't change stream state, and error details in opening/closing
+ * should be checked through POSIX errno.
+ *
+ * All of functionality and interfaces in this class are exception-free but istream
+ * class members can throw exceptions. See documention of istream class and its members.
+ */
+class ifstream : public fstream_base, public istream
+{
+    public:
+    ifstream() noexcept
+    {
+        // constructor
+    }
+
+    ifstream(std::unique_ptr<streambuf> passed_buf) noexcept
+    {
+        // constructor
+        buf = std::move(passed_buf);
+    }
+
+    ifstream(const char *dest) noexcept
+    {
+        // constructor
+        path = dest;
+    }
+
+    ifstream(const char *dest, std::unique_ptr<streambuf> passed_buf) noexcept
+    {
+        // constructor
+        path = dest;
+        buf = std::move(passed_buf);
+    }
+
+    ifstream(const ifstream &) = delete; // copy constructor
+
+    ifstream operator=(const ifstream &) = delete; // copy assignment
+
+    ifstream(const ifstream &&) = delete; // move constructor
+
+    void operator=(const ifstream &&) = delete; // move assignment
+
+    // open() functions
+    // Open file path which specified in path or as open() parameter with flags or modes
+    // Note: O_RDONLY is hard-coded in internal call to POSIX open().
+    // Will return true on success and false on failure
+    bool open() noexcept;
+
+    bool open(const int flags) noexcept;
+
+    bool open(const int flags, const mode_t mode) noexcept;
+
+    bool open(const char *dpath) noexcept;
+
+    bool open(const char *dpath, const int flags) noexcept;
+
+    bool open(const char *dpath, const int flags, const mode_t mode) noexcept;
+
+    // Close current file descriptor if it is opened
+    bool close() noexcept;
+
+    // Return true if file is closed
+    bool operator!() noexcept;
+
+    // Return true if file is opened
+    operator bool() noexcept;
+
+    ~ifstream() noexcept;
+};
+
+} /* dio namespace */
+
+#endif /* DINIT_FSTREAM_H_INCLUDED */
diff --git a/src/includes/dinit-iostream.h b/src/includes/dinit-iostream.h
new file mode 100644
index 00000000..0aa98673
--- /dev/null
+++ b/src/includes/dinit-iostream.h
@@ -0,0 +1,742 @@
+#ifndef DINIT_IOSTREAM_H_INCLUDED
+#define DINIT_IOSTREAM_H_INCLUDED 1
+
+#include <cpbuffer.h>
+
+/*
+ * dinit-iostream is a specialized library providing input/output wrappers
+ * around POSIX I/O interfaces. The purpose is to replace standard library
+ * iostreams with something more usable, robust, and lightweight. One of the
+ * major issues with stdlib iostreams is the difficulty of obtaining useful
+ * error messages in a standardized way. The language spec allows for it, but
+ * implementations often map all error conditions to the same unhelpful message.
+ * std::ios::failure extends std::system_error but doesn't use errno as the
+ * error code. Also, they are heavyweight due to support for different
+ * locales (which is unnecessary in dinit).
+ *
+ * This library provides two classes for output and input: ostream and istream.
+ * See documentation for each class at the top of it.
+ *
+ * All functionality of this library is located in the "dio" namespace.
+ *
+ * Global members based on ostream:
+ * --------------------------------
+ *
+ * ostream cout  // stdout output object on STDOUT_FILENO file descriptor
+ *
+ * ostream cerr  // stderr output object on STDERR_FILENO file descriptor
+ *
+ * print(...)    // Writing to stdout
+ *
+ * printerr(...) // Writing to stderr
+ *
+ * "cout" and "cerr" are global objects to write to standard/error output.
+ * They provide two global functions: print() and printerr(). They are guaranteed
+ * to be exception-free and not to throw any exceptions anyway.
+ *
+ * See "ostream" class documentation for low-level functionality details.
+ *
+ * Usage:
+ *
+ *      print("Hello Standard output :)\n")      // -> stdout
+ *      print("2 * 2 equals to: ", 2 * 2, endl); // -> stdout
+ *      printerr("Hello Error output :)\n")      // -> stderr
+ *
+ *
+ * Global members based on istream:
+ * --------------------------------
+ *
+ * istream cin        // stdin input object on STDIN_FILENO file descriptor
+ *
+ * getchar()          // Read one character from cin
+ *
+ * getline(dio::istream &stream, std::string &dest)
+ *                    // Read one line and push to passed std::string
+ *
+ * getline(dio::istream &stream, std::string &dest, char delim)
+ *                    // Read file until delim is found and push to std::string
+ *
+ * getline_nothrow(dio::istream &stream, std::string &dest)
+ *                    // Exception-free variant of getline()
+ *
+ * getline_nothrow(dio::istream &stream, std::string &dest, char delim)
+ *                    // Exception-free variant of getline()
+ *
+ * "cin" is a global object to interact with standard input, which provides getchar().
+ *
+ * getchar() is guaranteed to be exception-free and not to throw any exceptions anyway.
+ *
+ * getline() (and all of its variants) are used to read one line from the passed istream
+ * and push it to the passed std::string.
+ *
+ * NOTE: getline() erases all contents of the passed std::string when there is
+ * something in the buffer!
+ *
+ * getline() can throw these exceptions based on the throw_on_states() function setting:
+ * On eofbit:
+ *      dio::iostream_eof("End Of File has been reached.")
+ * On buffer_failbit:
+ *      dio::iostream_error("Cannot use stream's buffer: buffer is nullptr!")
+ * On string_failbit:
+ *      dio::iostream_error("Cannot put lines into given std::string.")
+ * On posixio_errno:
+ *      dio::posixio_error(errno)
+ *
+ * Usage:
+ *
+ *      while(getline_nothrow(cin, my_string)) {
+ *          my_output.write(my_string, "\n");
+ *      }
+ *      int a_character = getchar();
+ *      if (a_character == EOF) return; // Check for EOF or error
+ *      my_output.write((char)a_character, "\n");
+ */
+
+constexpr unsigned IOSTREAM_BUFSIZE = 16384; // Size of the buffers
+
+namespace dio {
+
+/*
+ * Stream state bits/vars:
+ *
+ * 1. "eofbit" indicates that the End Of File has been reached, and there is nothing
+ *    left in the buffer (istream only).
+ * 2. "buffer_failbit" indicates an attempt to use the buffer when the buffer pointer
+ *    was nullptr (e.g. failure to allocate a unique_ptr of streambuf) (ostream/istream).
+ * 3. "string_failbit" indicates a failed operation in std::string related calls
+ *    (e.g. failure in pushing a line from the buffer to the given std::string in
+ *    getline()) (istream only).
+ * 4. "posixio_errno" indicates that a POSIX I/O function failed, and the POSIX errno
+ *    was set (ostream/istream).
+ *
+ * If all of the above bits/variables are false or 0, the stream status is "good".
+ *
+ * 1. The rdstate() function returns the stream's current status based on this table.
+ * 2. The setstate() function only accepts these values as its "bits/vars".
+ */
+enum diostates
+{
+    eofbit = 0x01,
+    buffer_failbit = 0x02,
+    string_failbit = 0x04,
+    posixio_errno = 0x08
+};
+
+// Some empty classes for buffer operations implementation.
+// Used for accepting endl and flush in ostream::write() functions.
+class endline { };
+class flushbuf { };
+static constexpr endline endl;   // same as std::endl
+static constexpr flushbuf flush; // same as std::flush
+
+// Specialise system_error & runtime_error for more meaningful exceptions on state bits/var
+class iostream_eof : public std::runtime_error
+{
+    public:
+    iostream_eof(const char *msg) : runtime_error(msg)
+    {
+        // on eofbit
+    }
+};
+class iostream_error : public std::runtime_error
+{
+    public:
+    iostream_error(const char *msg) : runtime_error(msg)
+    {
+        // on buffer_failbit, string_failbit
+    }
+};
+class posixio_error : public std::system_error
+{
+    public:
+    posixio_error(const int posix_errno) : system_error(errno, std::system_category())
+    {
+        // on posixio_errno
+    }
+};
+
+// streambuf is just cpbuffer with fixed IOSTREAM_BUFSIZE size
+using streambuf = cpbuffer<IOSTREAM_BUFSIZE>;
+
+// streambuf_base is class which maintains a unique_ptr of streambuf and provides
+// functions to getting buffer in output/input streams.
+// It's supposed to be used for providing buffer related interfaces in ostream/istream.
+class streambuf_base
+{
+    protected:
+    std::unique_ptr<streambuf> buf;
+
+    public:
+    // Get raw pointer of current buffer
+    // NOTE: If the buffer is null, this function will return nullptr!
+    streambuf *get_buf() noexcept;
+};
+
+/*
+ * ostream
+ * =-=-=-=
+ *
+ * This class provides fundamental output functionality. It holds a std::unique_ptr
+ * of streambuf (a fixed-size circular buffer which that's size can be changed at
+ * compile-time) and stores the file descriptor number in its private space.
+ *
+ * Constructors
+ * ------------
+ *
+ * The ostream class has four constructors:
+ *
+ *      // Simple construction
+ *      dio::ostream output_a;
+ *      if (output_a.buffer_failure()) return -1; // Failure in buffer allocation
+ *
+ *      // Construction with moving a pre-allocated unique_ptr of the buffer
+ *      try {
+ *          std::unique_ptr<streambuf> my_buffer(new streambuf);
+ *      }
+ *      catch(const std::bad_alloc &) {
+ *          printerr("Cannot allocate memory for the output buffer!\n");
+ *          return -1;
+ *      }
+ *      dio::ostream output_b(std::move(my_buffer)); // Takes ownership of my_buffer
+ *
+ *      // Construction with a file descriptor number
+ *      dio::ostream output_c(3);
+ *      if (output_c.buffer_failure()) return -1; // Failure in buffer allocation
+ *
+ *      // Construction with a combination of a file descriptor and moving a
+ *      // pre-allocated unique_ptr of the buffer
+ *      dio::ostream output_d(3, std::move(buffer_2));
+ *      if (output_d.buffer_failure()) return -1; // Failure in buffer allocation
+ *
+ * Setting (or changing) the file descriptor after construction is available through
+ * the setfd() function.
+ *
+ * Copy/move constructors/assignments and destructor
+ * -------------------------------------------------
+ *
+ * The ostream copy constructor is prohibited (copy constructor is deleted).
+ * The ostream copy assignment is the same as the copy constructor.
+ *
+ * The ostream move constructor is prohibited (move constructor is deleted).
+ * The ostream move assignment is the same as the move constructor.
+ *
+ * The ostream destructor will write all of the buffer content into its file
+ * descriptor through the flush_nothrow() call.
+ *
+ * Public member: write()
+ * -----------------------
+ *
+ * The ostream provides write() functions supporting various data types for
+ * writing into file descriptor(s). See the class definition for a full list of
+ * types supported by write() functions. It's possible to combine different types
+ * in a single call with the "," character as well:
+ *
+ *      output_a.write("This is an example message.\n");
+ *      output_b.write("2 + 2 equals: ", 2 + 2, endl);
+ *
+ * All calls to write() will be buffered and not necessarily written to the file
+ * descriptor except in these situations:
+ *
+ * 1. The size of the passed message is larger than the buffer size.
+ * 2. The size of the passed message is larger than the current buffer free space.
+ * 3. "flush()" (or its exception-free variant: flush_nothrow()) is called.
+ * 4. A "flush" object is passed to write() functions (equivalent to calling flush()).
+ * 5. An "endl" object is passed to write() functions (equivalent to writing \n and
+ *    calling flush()).
+ * 6. The object is destructed (which calls flush_nothrow()).
+ *
+ * write() functions guarantee to return the number of actually written characters,
+ * not the number of buffered characters. They can also return -1 on failure cases.
+ *
+ * Public member: flush()
+ * ----------------------
+ *
+ * The ostream provides a flush() function to write all contents of the buffer.
+ * Passing a "flush" object to write() functions is equivalent to calling flush()
+ * on the stream. This function will return the number of all written characters
+ * or -1 on failure cases.
+ *
+ * Error handling and Stream states
+ * --------------------------------
+ *
+ * ostream states are: buffer_failbit and posixio_errno.
+ * buffer_failbit is false by default and means the class constructor failed to
+ * allocate a unique_ptr of the buffer at construction time.
+ * posixio_errno is 0 by default and means there is something wrong with POSIX I/O calls,
+ * It's set to the POSIX errno in this case.
+ *
+ * For checking current stream states, these functions are available:
+ * 1. rdstate(): Returns all current state bits or 0 when everything looks good.
+ * 2. good(): Returns 1 when there are no set bits otherwise 0.
+ * 3. buffer_failure(): Returns 1 or 0 based on whether buffer_failbit is set or not.
+ * 4. posixio_failure(): Returns 0 or the POSIX errno based on the posixio_errno value.
+ *
+ * For setting current stream state(s), these functions are available:
+ * 1. clear(): Sets all bits/vars to zero or false.
+ * 2. setstate(): Sets requested bits/vars to the requested value.
+ *
+ * Exception handling
+ * ------------------
+ *
+ * throw_on_states() can be used to set when an exception should be thrown or not.
+ * For ostream, it accepts diostates::buffer_failbit and diostates::posixio_errno.
+ *
+ * clear_throws() can be used for clear all marked situations for throwing exceptions.
+ *
+ * See the description for each function to know what exceptions can be thrown by
+ * functions.
+ *
+ * All exception-throwing functions have exception-free variants marked by the
+ * "_nothrow" suffix. Those functions guarantee not to throw any exceptions
+ * regardless of the throw_on_states() setting.
+ */
+class ostream : public streambuf_base
+{
+    int fd = -1;
+
+    // Variables to capture stream current status:
+    bool buffer_failbit = false;
+    // posixio_errno has different functionality, it will be set to POSIX errno
+    // which returned by POSIX functions (such as read()).
+    int posixio_errno = 0;
+
+    // Keep when should throw an exception (on which case):
+    bool throw_on_buffer_fail = false;
+    bool throw_on_posixio_fail = false;
+
+    // Internal function to appending into the buffer
+    ssize_t put(const char *msg) noexcept;
+
+    public:
+    ostream()
+    {
+        // constructor
+        buf = std::unique_ptr<streambuf>(new(std::nothrow) streambuf);
+        if (!buf) setstate(diostates::buffer_failbit, true);
+    }
+
+    ostream(std::unique_ptr<streambuf> passed_buf) noexcept
+    {
+        // constructor
+        buf = std::move(passed_buf);
+    }
+
+    ostream(const int fd) noexcept : fd(fd)
+    {
+        // constructor
+        buf = std::unique_ptr<streambuf>(new(std::nothrow) streambuf);
+        if (!buf) setstate(diostates::buffer_failbit, true);
+    }
+
+    ostream(const int fd, std::unique_ptr<streambuf> passed_buf) noexcept : fd(fd)
+    {
+        // constructor
+        buf = std::move(passed_buf);
+    }
+
+    ostream(const ostream &) = delete; // copy constructor
+
+    void operator=(const ostream &) = delete; // copy assignment
+
+    ostream(const ostream &&) = delete; // move consturctor
+
+    void operator=(const ostream &&) = delete; // move assignment
+
+    public:
+    // throw_on_states() used for throw an exception on requested "bit"
+    // flag can be: diostates::buffer_failbit and diostates::posixio_errno
+    // Multiple bits can be passed with "|" bitwise operator also.
+    void throw_on_states(const int bit, const bool do_throw) noexcept;
+
+    // Clear all situations which marked to throw exceptions
+    void clear_throws() noexcept;
+
+    // Set file descriptor
+    void setfd(const int fd) noexcept;
+
+    // Get current file descriptor
+    int getfd() noexcept;
+
+    // Set a specific bits/vars in stream based on diostates enum
+    void setstate(const int bit, const int value) noexcept;
+
+    // Returns current bits/vars in stream based on diostates enum
+    int rdstate() noexcept;
+
+    // Returns 1 when there is no set bits/vars otherwise 0
+    int good() noexcept;
+
+    // Returns 1 or 0 if buffer_failbit is set or not
+    int buffer_failure() noexcept;
+
+    // Returns 0 or POSIX errno based on posixio_errno value
+    int posixio_failure() noexcept;
+
+    // Resets failure bits/vars to false (or 0 about posixio_errno)
+    void clear() noexcept;
+
+    // Flush buffer of stream
+    // Non _nothrow variant may throw:
+    // dio::iostream_error on Buffer failure (buffer is nullptr)
+    // dio::posixio_error on POSIX I/O failure
+    ssize_t flush_nothrow();
+    ssize_t flush();
+
+    // write() functions, Used for write many types
+    // Non _nothrow variants may throw:
+    // dio::iostream_error on Buffer failure (buffer is nullptr)
+    // dio::posixio_error on POSIX I/O failure
+    ssize_t write_nothrow(const char *msg) noexcept;
+    ssize_t write(const char *msg);
+
+    ssize_t write_nothrow(const char msg) noexcept;
+    ssize_t write(const char msg);
+
+    ssize_t write_nothrow(const std::string &msg) noexcept;
+    ssize_t write(const std::string &msg);
+
+    ssize_t write_nothrow(const int num) noexcept;
+    ssize_t write(const int num);
+
+    ssize_t write_nothrow(const unsigned num) noexcept;
+    ssize_t write(const unsigned num);
+
+    ssize_t write_nothrow(const long num) noexcept;
+    ssize_t write(const long num);
+
+    ssize_t write_nothrow(const endline &) noexcept;
+    ssize_t write(const endline &);
+
+    ssize_t write_nothrow(const flushbuf &) noexcept;
+    ssize_t write(const flushbuf &);
+
+    template <typename T> inline ssize_t write_nothrow(T t) noexcept
+    {
+        return put(t);
+    }
+
+    template <typename T, typename... arguments> inline ssize_t write_nothrow(T t, arguments... args)
+            noexcept
+    {
+        if (!good()) return -1;
+        write_nothrow(t);
+        if (!good()) return -1;
+        return write_nothrow(args...);
+    }
+
+    template <typename T> inline ssize_t write(T t)
+    {
+        ssize_t r = put(t);
+        if (buffer_failure() && throw_on_buffer_fail) {
+            throw iostream_error("Cannot use stream's buffer: buffer is nullptr!");
+        }
+        if (posixio_failure() && throw_on_posixio_fail) {
+            throw posixio_error(posixio_failure());
+        }
+        return r;
+    }
+
+    template <typename T, typename... arguments> inline ssize_t write(T t, arguments... args)
+    {
+        if (!good()) return -1;
+        write(t);
+        if (!good()) return -1;
+        return write(args...);
+    }
+
+    virtual ~ostream() noexcept;
+};
+
+extern ostream cout;
+extern ostream cerr;
+
+template <typename... arguments> ssize_t print(arguments... args) noexcept
+{
+    return cout.write_nothrow(args...);
+}
+
+template <typename... arguments> ssize_t printerr(arguments... args) noexcept
+{
+    return cerr.write_nothrow(args...);
+}
+
+/*
+ * istream
+ * =-=-=-=
+ *
+ * This class provides fundamental input functionality. It holds a std::unique_ptr
+ * streambuf (a fixed-size circular buffer which that's size can be changed at
+ * compile-time) and stores the file descriptor number in its private space.
+ *
+ * Constructors
+ * ------------
+ *
+ * The istream class has four constructors (excluding copy/move constructors):
+ *
+ *      // Simple construction
+ *      dio::istream input_a;
+ *      if (input_a.buffer_failure()) return -1; // Failure in buffer allocation
+ *
+ *      // Construction with moving a pre-allocated unique_ptr of the buffer
+ *      try {
+ *          std::unique_ptr<streambuf> my_buffer(new streambuf);
+ *      }
+ *      catch(const std::bad_alloc &) {
+ *          printerr("Cannot allocate memory for input buffer!\n");
+ *          return -1;
+ *      }
+ *      dio::istream input_b(std::move(my_buffer)); // Takes ownership of my_buffer
+ *
+ *      // Construction with a file descriptor number
+ *      dio::istream input_c(3);
+ *      if (input_c.buffer_failure()) return -1; // Failure in buffer allocation
+ *
+ *      // Construction with a combination of a file descriptor and moving a
+ *      // pre-allocated unique_ptr of the buffer
+ *      dio::istream input_d(3, std::move(buffer_2));
+ *      if (input_d.buffer_failure()) return -1; // Failure in buffer allocation
+ *
+ * Also, setting (or changing) file descriptor after construction is available
+ * through setfd() function.
+ *
+ * Copy/move constructors/assignments and destructor
+ * -------------------------------------------------
+ *
+ * The istream copy constructor is prohibited (copy constructor is deleted).
+ * The istream copy assignment is the same as the copy constructor.
+ *
+ * The istream move constructor is prohibited (move constructor is deleted).
+ * The istream move assignment is the same as the move constructor.
+ *
+ * The istream has no destructor.
+ *
+ * Public member: read()
+ * ---------------------
+ *
+ * istream provides the read() function to read a given amount of characters from
+ * its file descriptor and write it into the buffer. It's useful for raw reading
+ * through the stream.
+ *
+ * read() will return the amount of read characters or 0 on EOF or -1 on
+ * buffer_failure or posixio_failure.
+ *
+ * read() is an exception-free function and does not throw any exceptions anyway.
+ *
+ * Public member: getc()
+ * ----------------------
+ *
+ * istream provides the getc() function to read one character from its file
+ * descriptor and return that.
+ *
+ * getc() will return a character as an integer or EOF macro on eofbit,
+ * buffer_failure, or posixio_failure.
+ *
+ * For exception handling, see the "Exception handling" section.
+ *
+ * Public member: getline()
+ * ------------------------
+ *
+ * istream provides the getline() function to read from its file descriptor until
+ * the delimiter character is found (usually '\n') and write it to the given
+ * std::string. Also, the given std::string will be erased when there is
+ * something in the buffer on each call.
+ *
+ * getline() will return the amount of characters in the string or 0 on EOF or -1
+ * on buffer_failure, string_failure, or posixio_failure.
+ *
+ * For exception handling, see the "Exception handling" section.
+ *
+ * Error handling and Stream states
+ * --------------------------------
+ *
+ * istream states are: eofbit, buffer_failbit, string_failbit, and posixio_errno.
+ * 1. eofbit is false by default and means there is nothing left in the file
+ *    descriptor and the buffer of the stream.
+ * 2. buffer_failbit is false by default and means the class constructor failed to
+ *    allocate a unique_ptr of the buffer at construction time.
+ * 3. string_failbit is false by default and means a std::string related operation
+ *    was failed.
+ * 4. posixio_errno is 0 by default and means there is something wrong from
+ *    POSIX I/O calls, It's set to the POSIX errno in this case.
+ *
+ * For checking current stream states these functions are available:
+ * 1. rdstate(): Returns all current state bits/vars or 0 when everything looks
+ *    good.
+ * 2. good(): Returns 1 when there are no set bits/vars otherwise 0.
+ * 3. eof(): Returns 1 or 0 based on eofbit is set or not.
+ * 4. buffer_failure(): Returns 1 or 0 based on buffer_failbit is set or not.
+ * 5. string_failure(): Returns 1 or 0 based on string_failbit is set or not.
+ * 6. posixio_failure(): Returns 0 or POSIX errno based on posixio_errno value.
+ *
+ * For setting current stream state(s) these functions are available:
+ *
+ * 1. clear(): Set state bits/vars to 0 or false
+ * 2. setstate(): Set requested bits/vars to requested value.
+ *
+ * Exception handling
+ * ------------------
+ *
+ * throw_on_states() can be used to set when an exception should be thrown or not.
+ * For istream, it accepts diostates::eofbit, diostates::buffer_failbit,
+ * diostates::string_failbit and diostates::posixio_errno.
+ *
+ * clear_throws() can be used for clear all marked situations for throwing exceptions.
+ *
+ * See the description for each function to know what exceptions can be thrown by
+ * functions.
+ *
+ * All of the exception-throwing functions have exception-free variants which are
+ * marked by the "_nothrow" suffix. Those functions guarantee not to throw any
+ * exceptions regardless of the throw_on_states() setting.
+ */
+class istream : public streambuf_base
+{
+    int fd = -1;
+
+    // Variables to capture stream current status:
+    bool eofbit = false;
+    bool buffer_failbit = false;
+    bool string_failbit = false;
+    // posixio_errno has different functionality, it will be set to POSIX errno
+    // which returned by POSIX functions (such as read()).
+    int posixio_errno = 0;
+
+    // Keep when should throw an exception (on which case):
+    bool throw_on_eofbit = false;
+    bool throw_on_buffer_fail = false;
+    bool throw_on_string_fail = false;
+    bool throw_on_posixio_fail = false;
+
+    public:
+    istream()
+    {
+        // constructor
+        buf = std::unique_ptr<streambuf>(new(std::nothrow) streambuf);
+        if (!buf) setstate(diostates::buffer_failbit, true);
+    }
+
+    istream(std::unique_ptr<streambuf> passed_buf) noexcept
+    {
+        // consturctor
+        buf = std::move(passed_buf);
+    }
+
+    istream(const int fd) noexcept : fd(fd)
+    {
+        // constructor
+        buf = std::unique_ptr<streambuf>(new(std::nothrow) streambuf);
+        if (!buf) setstate(diostates::buffer_failbit, true);
+    }
+
+    istream(const int fd, std::unique_ptr<streambuf> passed_buf) noexcept : fd(fd)
+    {
+        // consturctor
+        buf = std::move(passed_buf);
+    }
+
+    istream(const istream &) = delete; // copy constructor
+
+    void operator=(const istream &) = delete; // copy assignment
+
+    istream(const istream &&) = delete; // move consturctor
+
+    void operator=(const istream &&) = delete; // move assignment
+
+    public:
+    // throw_on_states() used for throw/not throw an exception on requested "bit"
+    // flag can to be: diostates::eofbit, diostates::buffer_failbit,
+    // diostates::string_fialbit and diostates::posixio_errno
+    // Multiple bits can be passed with "|" bitwise operator also
+    void throw_on_states(const int bit, const bool do_throw) noexcept;
+
+    // Clear all situations which marked to throw exceptions
+    void clear_throws() noexcept;
+
+    // Set file descriptor
+    void setfd(const int tfd) noexcept;
+
+    // Get current file descriptor
+    int getfd() noexcept;
+
+    // Set a specific bit in stream based on diostates enum
+    void setstate(const int bit, const int value) noexcept;
+
+    // Returns current bits in stream based on diostates enum
+    int rdstate() noexcept;
+
+    // Returns 1 when there is no set bits/vars otherwise 0
+    int good() noexcept;
+
+    // Returns 1 or 0 based on eofbit is set or not
+    int eof() noexcept;
+
+    // Returns 1 or 0 based on buffer_failbit is set or not
+    int buffer_failure() noexcept;
+
+    // Returns 1 or 0 based on string_failbit is set or not
+    int string_failure() noexcept;
+
+    // Returns 0 or POSIX errno based on posixio_errno value
+    int posixio_failure() noexcept;
+
+    // Resets failure bits/vars to false (or 0 about posixio_errno)
+    void clear() noexcept;
+
+    // Reads the file and puts it into the buffer
+    int read(unsigned len) noexcept;
+
+    // Reads and returns one charactor from file descriptor
+    // Non _nothrow variant may throw:
+    // dio::iostream_eof on EOF
+    // dio::iostream_error on Buffer failure (buffer is nullptr)
+    // dio::posixio_error on POSIX I/O failure
+    int getc_nothrow() noexcept;
+    int getc();
+
+    // Reads and stores one line from fd into given std::string
+    // Non _nothrow variant may throw:
+    // dio::iostream_eof on EOF
+    // dio::iostream_error on Buffer failure (buffer is nullptr)
+    // dio::iostream_error on putting into given std::string failure
+    // dio::posixio_error on POSIX I/O failure
+    ssize_t getline_nothrow(std::string &dest, char delim) noexcept;
+    ssize_t getline(std::string &dest, char delim);
+};
+
+extern istream cin;
+
+// Reads and returns one charactor from file descriptor 1 (stdin)
+inline int getchar() noexcept
+{
+    return cin.getc_nothrow();
+}
+
+// Reads and stores one line from given istream into given std::string
+// Non _nothrow variants May throw:
+// dio::iostream_eof on EOF
+// dio::iostream_error on Buffer failure (buffer is nullptr)
+// dio::iostream_error on pushing into given std::string failure
+// dio::posixio_error on POSIX I/O failure
+inline ssize_t getline_nothrow(istream &stream, std::string &dest, char delim) noexcept
+{
+    return stream.getline_nothrow(dest, delim);
+}
+
+inline ssize_t getline_nothrow(istream &stream, std::string &dest) noexcept
+{
+    return stream.getline_nothrow(dest, '\n');
+}
+
+inline ssize_t getline(istream &stream, std::string &dest, char delim)
+{
+    return stream.getline(dest, delim);
+}
+
+inline ssize_t getline(istream &stream, std::string &dest)
+{
+    return stream.getline(dest, '\n');
+}
+
+} /* dio namespace */
+
+#endif /* DINIT_IOSTREAM_H_INCLUDED */