view.hpp

Go to the documentation of this file.

 
#ifndef JOIN_DATA_VIEW_HPP
#define JOIN_DATA_VIEW_HPP
 
// libjoin.
#include <join/utils.hpp>
 
// C++.
#include <istream>
#include <string>
#include <vector>
 
// C.
#include <cstring>
#include <cstddef>
 
namespace join
{
    namespace details
    {
        struct alignas (64) EscapedTable
        {
            uint8_t data[256];
 
            constexpr EscapedTable ()
            : data{}
            {
                for (unsigned i = 0; i < 0x20; ++i)
                {
                    data[i] = 1;
                }
                data['"']  = 1;
                data['\\'] = 1;
            }
        };
 
        constexpr EscapedTable escapedLookup{};
 
        struct alignas (64) WhitespaceTable
        {
            uint8_t data[256];
 
            constexpr WhitespaceTable ()
            : data{}
            {
                data['\t'] = 1;
                data['\n'] = 1;
                data['\r'] = 1;
                data[' ']  = 1;
            }
        };
 
        constexpr WhitespaceTable whitespaceLookup{};
    }
 
    class StringView
    {
    public:
        using ViewPos = const char*;
 
        constexpr StringView (const char* in, size_t count)
        : _cur (in)
        , _beg (in)
        , _end (in ? in + count : in)
        {
        }
 
        constexpr StringView (const char* first, const char* last)
        : _cur (first)
        , _beg (first)
        , _end (last)
        {
        }
 
        StringView (const char* in)
        : _cur (in)
        , _beg (in)
        , _end (in ? in + std::char_traits<char>::length (in) : in)
        {
        }
 
        StringView (const StringView& other) = default;
 
        StringView& operator= (const StringView& other) = default;
 
        StringView (StringView&& other) = default;
 
        StringView& operator= (StringView&& other) = default;
 
        ~StringView () = default;
 
        inline int peek () const noexcept
        {
            if (JOIN_LIKELY (_cur < _end))
            {
                return static_cast<unsigned char> (*_cur);
            }
            return std::char_traits<char>::eof ();
        }
 
        inline int get () noexcept
        {
            if (JOIN_LIKELY (_cur < _end))
            {
                return static_cast<unsigned char> (*_cur++);
            }
            return std::char_traits<char>::eof ();
        }
 
        inline bool getIf (char expected) noexcept
        {
            if (JOIN_LIKELY (_cur < _end) && (*_cur == expected))
            {
                ++_cur;
                return true;
            }
            return false;
        }
 
        inline bool getIfNoCase (char expected) noexcept
        {
            if (JOIN_LIKELY (_cur < _end))
            {
                const char c = *_cur;
                if ((c | 32) == (expected | 32))
                {
                    ++_cur;
                    return true;
                }
            }
            return false;
        }
 
        inline size_t read (char* buf, size_t count) noexcept
        {
            const size_t available = _end - _cur;
            const size_t nread     = (count < available) ? count : available;
            std::memcpy (buf, _cur, nread);
            _cur += nread;
            return nread;
        }
 
        inline void readUntilEscaped (std::string& out) noexcept
        {
            const char* beg = _cur;
            const char* cur = _cur;
            const char* end = _end;
 
            while (cur < end && !details::escapedLookup.data[static_cast<unsigned char> (*cur)])
            {
                ++cur;
            }
 
            out.append (beg, static_cast<size_t> (cur - beg));
            _cur = cur;
        }
 
        inline int skipWhitespaces () noexcept
        {
            const char* cur = _cur;
            const char* end = _end;
 
            while (cur < end && details::whitespaceLookup.data[static_cast<unsigned char> (*cur)])
            {
                ++cur;
            }
 
            _cur = cur;
 
            return 0;
        }
 
        inline int skipWhitespacesAndComments () noexcept
        {
            const char* cur = _cur;
            const char* end = _end;
 
            while (cur < end)
            {
                while (cur < end && details::whitespaceLookup.data[static_cast<unsigned char> (*cur)])
                {
                    ++cur;
                }
 
                if (cur >= end || *cur != '/')
                {
                    break;
                }
 
                if (++cur >= end)
                {
                    return -1;
                }
 
                if (*cur == '*')
                {
                    ++cur;
                    bool closed = false;
                    while (cur < end)
                    {
                        if (*cur == '*' && (cur + 1 < end) && *(cur + 1) == '/')
                        {
                            cur += 2;
                            closed = true;
                            break;
                        }
                        ++cur;
                    }
                    if (!closed)
                    {
                        return -1;
                    }
                }
                else if (*cur == '/')
                {
                    ++cur;
                    const char* p = static_cast<const char*> (memchr (cur, '\n', end - cur));
                    cur           = p ? p : end;
                }
                else
                {
                    return -1;
                }
            }
 
            _cur = cur;
 
            return 0;
        }
 
        inline ViewPos tell () const noexcept
        {
            return _cur;
        }
 
        inline void seek (ViewPos pos) noexcept
        {
            if (JOIN_LIKELY (pos >= _beg && pos <= _end))
            {
                _cur = pos;
            }
            else if (pos < _beg)
            {
                _cur = _beg;
            }
            else
            {
                _cur = _end;
            }
        }
 
    private:
        const char* _cur = nullptr;
 
        const char* _beg = nullptr;
 
        const char* _end = nullptr;
    };
 
    template <bool Seekable = true>
    class BasicStreamView
    {
    public:
        using ViewPos = std::streampos;
 
        BasicStreamView (std::istream& in)
        : _in (in.rdbuf ())
        {
        }
 
        BasicStreamView (const BasicStreamView& other) = delete;
 
        BasicStreamView& operator= (const BasicStreamView& other) = delete;
 
        BasicStreamView (BasicStreamView&& other) = delete;
 
        BasicStreamView& operator= (BasicStreamView&& other) = delete;
 
        ~BasicStreamView () = default;
 
        inline int peek () const noexcept
        {
            return _in->sgetc ();
        }
 
        inline int get () noexcept
        {
            return _in->sbumpc ();
        }
 
        inline bool getIf (char expected) noexcept
        {
            if (_in->sgetc () == static_cast<int> (static_cast<unsigned char> (expected)))
            {
                _in->sbumpc ();
                return true;
            }
            return false;
        }
 
        inline bool getIfNoCase (char expected) noexcept
        {
            const int c = _in->sgetc ();
            if (JOIN_LIKELY (c != std::char_traits<char>::eof ()))
            {
                if ((static_cast<char> (c) | 32) == (expected | 32))
                {
                    _in->sbumpc ();
                    return true;
                }
            }
            return false;
        }
 
        inline size_t read (char* buf, size_t count) noexcept
        {
            return _in->sgetn (buf, count);
        }
 
        inline void readUntilEscaped (std::string& out) noexcept
        {
            int c;
            while ((c = _in->sgetc ()) != std::char_traits<char>::eof () &&
                   !details::escapedLookup.data[static_cast<unsigned char> (c)])
            {
                out.push_back (static_cast<char> (c));
                _in->sbumpc ();
            }
        }
 
        inline int skipWhitespaces () noexcept
        {
            int c;
            while ((c = _in->sgetc ()) != std::char_traits<char>::eof () &&
                   details::whitespaceLookup.data[static_cast<unsigned char> (c)])
            {
                _in->sbumpc ();
            }
 
            return 0;
        }
 
        inline int skipWhitespacesAndComments () noexcept
        {
            int c;
 
            while ((c = _in->sgetc ()) != std::char_traits<char>::eof ())
            {
                while ((c = _in->sgetc ()) != std::char_traits<char>::eof () &&
                       details::whitespaceLookup.data[static_cast<unsigned char> (c)])
                {
                    _in->sbumpc ();
                }
 
                if (c != '/')
                {
                    break;
                }
 
                _in->sbumpc ();
                c = _in->sgetc ();
 
                if (c == std::char_traits<char>::eof ())
                {
                    return -1;
                }
 
                if (c == '*')
                {
                    _in->sbumpc ();
                    bool closed = false;
 
                    while ((c = _in->sbumpc ()) != std::char_traits<char>::eof ())
                    {
                        if (c == '*' && _in->sgetc () == '/')
                        {
                            _in->sbumpc ();
                            closed = true;
                            break;
                        }
                    }
 
                    if (!closed)
                    {
                        return -1;
                    }
                }
                else if (c == '/')
                {
                    _in->sbumpc ();
 
                    while ((c = _in->sbumpc ()) != std::char_traits<char>::eof () && c != '\n')
                    {
                    }
                }
                else
                {
                    return -1;
                }
            }
 
            return 0;
        }
 
        template <bool S = Seekable>
        inline typename std::enable_if<S, ViewPos>::type tell () const noexcept
        {
            return _in->pubseekoff (0, std::ios::cur, std::ios::in);
        }
 
        template <bool S = Seekable>
        inline typename std::enable_if<S, void>::type seek (ViewPos pos) noexcept
        {
            _in->pubseekpos (pos, std::ios::in);
        }
 
    private:
        std::streambuf* _in;
    };
 
    using StringStreamView = BasicStreamView<true>;
 
    using FileStreamView = BasicStreamView<true>;
 
    using StreamView = BasicStreamView<false>;
 
    template <typename ViewType>
    struct is_seekable : std::false_type
    {
    };
 
    template <>
    struct is_seekable<StringView> : std::true_type
    {
    };
 
    template <>
    struct is_seekable<BasicStreamView<true>> : std::true_type
    {
    };
 
    template <typename ViewType, bool Seekable = is_seekable<ViewType>::value>
    class BufferingView;
 
    template <typename ViewType>
    class BufferingView<ViewType, true>
    {
    public:
        explicit BufferingView (ViewType& view)
        : _view (view)
        , _beg (view.tell ())
        {
        }
 
        inline int peek () const noexcept
        {
            return _view.peek ();
        }
 
        inline int get () noexcept
        {
            return _view.get ();
        }
 
        inline bool getIf (char expected) noexcept
        {
            return _view.getIf (expected);
        }
 
        inline bool getIfNoCase (char expected) noexcept
        {
            return _view.getIfNoCase (expected);
        }
 
        inline void snapshot (std::string& out)
        {
            size_t len = _view.tell () - _beg;
            out.resize (len);
 
            _view.seek (_beg);
            _view.read (&out[0], len);
        }
 
        inline void consume (std::string& out)
        {
            snapshot (out);
            _beg = _view.tell ();
        }
 
    private:
        ViewType& _view;
 
        typename ViewType::ViewPos _beg;
    };
 
    template <typename ViewType>
    class BufferingView<ViewType, false>
    {
    public:
        explicit BufferingView (ViewType& view)
        : _view (view)
        {
            static thread_local std::vector<char> buffer;
            buffer.clear ();
            buffer.reserve (32);
            _buf = &buffer;
        }
 
        inline int peek () const noexcept
        {
            return _view.peek ();
        }
 
        inline int get () noexcept
        {
            const int c = _view.get ();
            if (JOIN_LIKELY (c != std::char_traits<char>::eof ()))
            {
                _buf->push_back (static_cast<char> (c));
            }
            return c;
        }
 
        inline bool getIf (char expected) noexcept
        {
            if (_view.peek () == static_cast<int> (static_cast<unsigned char> (expected)))
            {
                _buf->push_back (static_cast<char> (_view.get ()));
                return true;
            }
            return false;
        }
 
        inline bool getIfNoCase (char expected) noexcept
        {
            const int c = _view.peek ();
            if (JOIN_LIKELY (c != std::char_traits<char>::eof ()))
            {
                if ((static_cast<char> (c) | 32) == (expected | 32))
                {
                    _buf->push_back (static_cast<char> (_view.get ()));
                    return true;
                }
            }
            return false;
        }
 
        inline void snapshot (std::string& out)
        {
            out.assign (_buf->data (), _buf->size ());
        }
 
        inline void consume (std::string& out)
        {
            snapshot (out);
            _buf->clear ();
        }
 
    private:
        ViewType& _view;
 
        std::vector<char>* _buf = nullptr;
    };
}
 
#endif