probe.hpp

Go to the documentation of this file.

 
#ifndef __DCONV_PROBE_HPP__
#define __DCONV_PROBE_HPP__
 
// C++.
#include <istream>
#include <limits>
 
// C.
#include <cstring>
#include <cstdint>
#include <cstddef>
 
#define DCONV_LIKELY(x) __builtin_expect ((x), 1)
#define DCONV_UNLIKELY(x) __builtin_expect ((x), 0)
#define DCONV_COLD __attribute__ ((cold, noinline))
 
namespace dconv
{
    class StringProbe
    {
    public:
        using ProbePos = const char*;
 
        constexpr StringProbe (const char* in, size_t count)
        : _cur (in)
        , _beg (in)
        , _end (in ? in + count : in)
        {
        }
 
        constexpr StringProbe (const char* first, const char* last)
        : _cur (first)
        , _beg (first)
        , _end (last)
        {
        }
 
        explicit StringProbe (const char* in)
        : _cur (in)
        , _beg (in)
        , _end (in ? in + std::char_traits<char>::length (in) : in)
        {
        }
 
        StringProbe (const StringProbe& other) = default;
 
        StringProbe& operator= (const StringProbe& other) = default;
 
        StringProbe (StringProbe&& other) = default;
 
        StringProbe& operator= (StringProbe&& other) = default;
 
        ~StringProbe () = default;
 
        inline int peek () const noexcept
        {
            if (DCONV_LIKELY (_cur < _end))
            {
                return static_cast<unsigned char> (*_cur);
            }
            return std::char_traits<char>::eof ();
        }
 
        inline int get () noexcept
        {
            if (DCONV_LIKELY (_cur < _end))
            {
                return static_cast<unsigned char> (*_cur++);
            }
            return std::char_traits<char>::eof ();
        }
 
        inline bool getIf (char expected) noexcept
        {
            if (DCONV_LIKELY (_cur < _end) && (*_cur == expected))
            {
                ++_cur;
                return true;
            }
            return false;
        }
 
        inline bool getIfNoCase (char expected) noexcept
        {
            if (DCONV_LIKELY (_cur < _end))
            {
                const char c = *_cur;
                if ((c | 32) == (expected | 32))
                {
                    ++_cur;
                    return true;
                }
            }
            return false;
        }
 
        inline size_t readDigits (uint64_t& value, size_t max = std::numeric_limits<size_t>::max ()) noexcept
        {
            const char* cur = _cur;
            const char* end = (static_cast<size_t> (_end - _cur) > max) ? _cur + max : _end;
            uint64_t word;
 
            while ((end - cur >= 8) &&
                   (std::memcpy (&word, cur, 8),
                    ((word & 0xF0F0F0F0F0F0F0F0ULL) |
                     (((word + 0x0606060606060606ULL) & 0xF0F0F0F0F0F0F0F0ULL) >> 4)) == 0x3333333333333333ULL))
            {
                word = ((word & 0x0F0F0F0F0F0F0F0FULL) * 2561) >> 8;
                word = ((word & 0x00FF00FF00FF00FFULL) * 6553601) >> 16;
                word = ((word & 0x0000FFFF0000FFFFULL) * 42949672960001ULL) >> 32;
                value = (value * 100000000) + word;
                cur += 8;
            }
 
            while ((cur < end) && (static_cast<unsigned char> (*cur - '0') < 10))
            {
                value = (value * 10) + (*cur++ - '0');
            }
 
            size_t count = cur - _cur;
            _cur = cur;
            return count;
        }
 
        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 ProbePos tell () const noexcept
        {
            return _cur;
        }
 
        inline ProbePos end () const noexcept
        {
            return _end;
        }
 
        inline void seek (ProbePos pos) noexcept
        {
            if (DCONV_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;
    };
 
    class StreamProbe
    {
    public:
        explicit StreamProbe (std::istream& in)
        : _in (in.rdbuf ())
        {
        }
 
        StreamProbe (const StreamProbe& other) = delete;
 
        StreamProbe& operator= (const StreamProbe& other) = delete;
 
        StreamProbe (StreamProbe&& other) = delete;
 
        StreamProbe& operator= (StreamProbe&& other) = delete;
 
        ~StreamProbe () = 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 (DCONV_LIKELY (c != std::char_traits<char>::eof ()))
            {
                if ((static_cast<char> (c) | 32) == (expected | 32))
                {
                    _in->sbumpc ();
                    return true;
                }
            }
            return false;
        }
 
        inline size_t readDigits (uint64_t& value, size_t max = std::numeric_limits<size_t>::max ()) noexcept
        {
            size_t count = 0;
            while ((count < max) && (static_cast<unsigned> (peek () - '0') < 10))
            {
                value = (value * 10) + (get () - '0');
                ++count;
            }
            return count;
        }
 
        inline size_t read (char* buf, size_t count) noexcept
        {
            return _in->sgetn (buf, count);
        }
 
    private:
        std::streambuf* _in;
    };
}
 
#endif