fakestream.h

Go to the documentation of this file.

 
#pragma once
 
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <fstream>
#include <string>
#include <string_view>
#include <new>
 
#ifndef ALWAYS_INLINE
#if defined(__GNUC__) || defined(__clang__)
#define ALWAYS_INLINE inline __attribute__((always_inline))
#else
#define ALWAYS_INLINE
#endif
#endif
 
namespace bs {
    template<typename char_t>
    class basic_ifakestream {
    public:
        using traits_type = std::char_traits<char_t>;
        using char_type = traits_type::char_type;
        using int_type = traits_type::int_type;
 
        static constexpr auto EOF_VALUE = traits_type::eof();
 
        ALWAYS_INLINE basic_ifakestream()
            : m_nPos(0), m_pData(nullptr), m_nSize(0) {
        }
 
        ALWAYS_INLINE basic_ifakestream(const char *const pData, const std::size_t nSize)
            : m_nPos(0), m_pData(pData), m_nSize(nSize) {
        }
 
        ALWAYS_INLINE basic_ifakestream(const std::string_view &sText)
            : m_nPos(0), m_pData(sText.data()), m_nSize(sText.length()) {
        }
 
        // Deleted copy and move constructors and assignment operators.
        basic_ifakestream(const basic_ifakestream &) = delete;
 
        basic_ifakestream(basic_ifakestream &&) = delete;
 
        basic_ifakestream &operator=(const basic_ifakestream &) = delete;
 
        basic_ifakestream &operator=(basic_ifakestream &&) = delete;
 
        ALWAYS_INLINE int_type get() noexcept {
            auto nChar = m_nPos < m_nSize ? m_pData[m_nPos] : EOF_VALUE;
            this->m_nPos += 1;
            return nChar;
        }
 
        ALWAYS_INLINE int_type peek() noexcept {
            return m_nPos < m_nSize ? m_pData[m_nPos] : EOF_VALUE;
        }
 
        ALWAYS_INLINE int_type prev() noexcept {
            return m_nPos > 0 ? m_nPos <= m_nSize ? m_pData[m_nPos - 1] : EOF_VALUE : EOF_VALUE;
        }
 
        ALWAYS_INLINE void put_back() noexcept {
            if (m_nPos > 0)--m_nPos;
        }
 
        ALWAYS_INLINE std::size_t read(char_type *const pBuffer, const std::size_t nCount) noexcept {
            const std::size_t nRead = m_nPos + nCount > m_nSize
                                          ? nCount + m_nPos - m_nSize
                                          : nCount;
            std::memcpy(pBuffer, this->m_pData + this->m_nPos, nRead * sizeof(char_type));
            this->m_nPos += nRead;
            return nRead;
        }
 
        [[nodiscard]] ALWAYS_INLINE bool eof() const noexcept {
            return this->m_nPos >= m_nSize;
        }
 
        [[nodiscard]] ALWAYS_INLINE std::size_t tell() const noexcept {
            return this->m_nPos;
        }
 
        ALWAYS_INLINE void seek(const std::size_t pos) noexcept {
            this->m_nPos = pos;
        }
 
        [[nodiscard]] ALWAYS_INLINE std::size_t size() const noexcept {
            return this->m_nSize;
        }
 
        [[nodiscard]] ALWAYS_INLINE std::basic_string_view<char_type> view() const noexcept {
            return {this->m_pData, this->m_nSize};
        }
 
        [[nodiscard]] ALWAYS_INLINE std::basic_string_view<char_type> sub_view(
            const std::size_t nBegin, std::size_t nLength) const noexcept {
            nLength = nBegin + nLength > m_nSize
                          ? nBegin + nLength - m_nSize
                          : nLength;
            return {this->m_pData + nBegin, nLength};
        }
 
        [[nodiscard]] ALWAYS_INLINE std::basic_string<char_type> str() const {
            return {this->m_pData, this->m_nSize};
        }
 
        [[nodiscard]] ALWAYS_INLINE std::basic_string_view<char_type> remaining_view() const noexcept {
            if (this->m_nPos >= this->m_nSize)return "";
            return {this->m_pData + this->m_nPos, this->m_nSize - this->m_nPos};
        }
 
        [[nodiscard]] ALWAYS_INLINE std::basic_string<char_type> remaining_str() const {
            if (this->m_nPos >= this->m_nSize)return "";
            return {this->m_pData + this->m_nPos, this->m_nSize - this->m_nPos};
        }
 
    private:
        std::size_t m_nPos; 
        const char_type *const m_pData; 
        const std::size_t m_nSize; 
    };
 
    using ifakestream = basic_ifakestream<char>;
    using wifakestream = basic_ifakestream<wchar_t>;
    using u8ifakestream = basic_ifakestream<char8_t>;
    using u16ifakestream = basic_ifakestream<char16_t>;
    using u32ifakestream = basic_ifakestream<char32_t>;
 
    template<typename char_t>
    class basic_ofakestream {
    public:
        using traits_type = std::char_traits<char_t>;
        using char_type = traits_type::char_type;
        using int_type = traits_type::int_type;
 
        static constexpr auto DEFAULT_BUFFER_SIZE = 64;
        static constexpr auto EOF_VALUE = traits_type::eof();
 
        ALWAYS_INLINE basic_ofakestream()
            : m_pData(static_cast<char_type *>(
                  std::malloc(DEFAULT_BUFFER_SIZE * sizeof(char_type))
              )),
              m_nSize(DEFAULT_BUFFER_SIZE),
              m_nPos(0) {
            if (this->m_pData == nullptr) throw std::bad_alloc();
        }
 
        // Deleted copy and move constructors and assignment operators.
        basic_ofakestream(const basic_ofakestream &) = delete;
 
        basic_ofakestream(basic_ofakestream &&) = delete;
 
        basic_ofakestream &operator=(const basic_ofakestream &) = delete;
 
        basic_ofakestream &operator=(basic_ofakestream &&) = delete;
 
        ALWAYS_INLINE ~basic_ofakestream() {
            std::free(this->m_pData);
        }
 
        ALWAYS_INLINE void put(const char_type cChar) {
            if (m_nPos + 1 >= m_nSize) realloc(m_nPos + 1);
            m_pData[m_nPos++] = cChar;
        }
 
        ALWAYS_INLINE void write(const char_type *const pData, const std::size_t nLength) {
            if (m_nPos + nLength >= m_nSize) realloc(m_nPos + nLength);
            std::memcpy(this->m_pData + this->m_nPos, pData, nLength * sizeof(char_type));
            this->m_nPos += nLength;
        }
 
        [[nodiscard]] ALWAYS_INLINE bool empty() const noexcept {
            return this->m_nPos == 0;
        }
 
        [[nodiscard]] ALWAYS_INLINE std::size_t size() const noexcept {
            return this->m_nPos;
        }
 
        ALWAYS_INLINE void clear() noexcept {
            this->m_nPos = 0;
        }
 
        ALWAYS_INLINE void operator<<(const std::basic_string<char_type> &sString) {
            const std::size_t nLength = sString.length();
            if (m_nPos + nLength >= m_nSize) realloc(m_nPos + nLength);
            std::memcpy(this->m_pData + this->m_nPos, sString.data(), nLength * sizeof(char_type));
            this->m_nPos += nLength;
        }
 
        ALWAYS_INLINE void operator<<(const std::basic_string_view<char_type> &sString) {
            const std::size_t nLength = sString.length();
            if (m_nPos + nLength >= m_nSize) realloc(m_nPos + nLength);
            std::memcpy(this->m_pData + this->m_nPos, sString.data(), nLength * sizeof(char_type));
            this->m_nPos += nLength;
        }
 
        [[nodiscard]] ALWAYS_INLINE std::basic_string_view<char_type> view() const noexcept {
            return {this->m_pData, m_nPos};
        }
 
        [[nodiscard]] ALWAYS_INLINE std::basic_string<char_type> str() const {
            return {this->m_pData, m_nPos};
        }
 
        [[nodiscard]] ALWAYS_INLINE std::basic_string<char_type> str_reset() {
            std::basic_string<char_type> sResult{this->m_pData, m_nPos};
            this->m_nPos = 0;
            return sResult;
        }
 
        [[nodiscard]] ALWAYS_INLINE std::basic_string<char_type> sub_str(
            const std::size_t nBegin, std::size_t nLength) const noexcept {
            nLength = nBegin + nLength >= m_nSize
                          ? nBegin + nLength - m_nSize
                          : nLength;
            return {this->m_pData + nBegin, nLength};
        }
 
    private:
        char_type *m_pData;
        std::size_t m_nSize;
        std::size_t m_nPos;
 
        void realloc(const std::size_t nRequestedSize) {
            // Calculate new size
            std::size_t nNewSize = m_nSize * 2;
            while (nNewSize < nRequestedSize) nNewSize *= 2;
 
            // Malloc new memory
            const auto pNewData = static_cast<char *>(std::realloc(this->m_pData, nNewSize * sizeof(char_type)));
            if (pNewData == nullptr) throw std::bad_alloc();
 
            // Swap to the new pointer
            this->m_pData = pNewData;
            this->m_nSize = nNewSize;
        }
    };
 
    using ofakestream = basic_ofakestream<char>;
    using wofakestream = basic_ofakestream<wchar_t>;
    using u8ofakestream = basic_ofakestream<char8_t>;
    using u16ofakestream = basic_ofakestream<char16_t>;
    using u32ofakestream = basic_ofakestream<char32_t>;
}