EIC code displayed by LXR master/​include/​boost/​json/​detail/​stream.hpp	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2025-01-18 09:38:59

 //
 // Copyright (c) 2019 Vinnie Falco (vinnie.falco@gmail.com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 //
 // Official repository: https://github.com/boostorg/json
 //
 
 #ifndef BOOST_JSON_DETAIL_STREAM_HPP
 #define BOOST_JSON_DETAIL_STREAM_HPP
 
 namespace boost {
 namespace json {
 namespace detail {
 
 class const_stream
 {
     friend class local_const_stream;
 
     char const* p_;
     char const* end_;
 
 public:
     const_stream() = default;
 
     const_stream(
         char const* data,
         std::size_t size) noexcept
         : p_(data)
         , end_(data + size)
     {
     }
 
     size_t
     used(char const* begin) const noexcept
     {
         return static_cast<
             size_t>(p_ - begin);
     }
 
     size_t
     remain() const noexcept
     {
         return end_ - p_;
     }
 
     char const*
     data() const noexcept
     {
         return p_;
     }
 
     operator bool() const noexcept
     {
         return p_ < end_;
     }
 
     // unchecked
     char
     operator*() const noexcept
     {
         BOOST_ASSERT(p_ < end_);
         return *p_;
     }
 
     // unchecked
     const_stream&
     operator++() noexcept
     {
         BOOST_ASSERT(p_ < end_);
         ++p_;
         return *this;
     }
 
     void
     skip(std::size_t n) noexcept
     {
         BOOST_ASSERT(n <= remain());
         p_ += n;
     }
 
     void
     skip_to(const char* p) noexcept
     {
         BOOST_ASSERT(p <= end_ && p >= p_);
         p_ = p;
     }
 };
 
 class local_const_stream
     : public const_stream
 {
     const_stream& src_;
 
 public:
     explicit
     local_const_stream(
         const_stream& src) noexcept
         : const_stream(src)
         , src_(src)
     {
     }
 
     ~local_const_stream()
     {
         src_.p_ = p_;
     }
 
     void
     clip(std::size_t n) noexcept
     {
         if(static_cast<std::size_t>(
             src_.end_ - p_) > n)
             end_ = p_ + n;
         else
             end_ = src_.end_;
     }
 };
 
 class const_stream_wrapper
 {
     const char*& p_;
     const char* const end_;
 
     friend class clipped_const_stream;
 public:
     const_stream_wrapper(
         const char*& p,
         const char* end)
         : p_(p)
         , end_(end)
     {
     }
 
     void operator++() noexcept
     {
         ++p_;
     }
 
     void operator+=(std::size_t n) noexcept
     {
         p_ += n;
     }
 
     void operator=(const char* p) noexcept
     {
         p_ = p;
     }
 
     char operator*() const noexcept
     {
         return *p_;
     }
 
     operator bool() const noexcept
     {
         return p_ < end_;
     }
 
     const char* begin() const noexcept
     {
         return p_;
     }
 
     const char* end() const noexcept
     {
         return end_;
     }
 
     std::size_t remain() const noexcept
     {
         return end_ - p_;
     }
 
     std::size_t remain(const char* p) const noexcept
     {
         return end_ - p;
     }
 
     std::size_t used(const char* p) const noexcept
     {
         return p_ - p;
     }
 };
 
 class clipped_const_stream
     : public const_stream_wrapper
 {
     const char* clip_;
 
 public:
     clipped_const_stream(
         const char*& p,
         const char* end)
         : const_stream_wrapper(p, end)
         , clip_(end)
     {
     }
 
     void operator=(const char* p)
     {
         p_ = p;
     }
 
     const char* end() const noexcept
     {
         return clip_;
     }
 
     operator bool() const noexcept
     {
         return p_ < clip_;
     }
 
     std::size_t remain() const noexcept
     {
         return clip_ - p_;
     }
 
     std::size_t remain(const char* p) const noexcept
     {
         return clip_ - p;
     }
 
     void
     clip(std::size_t n) noexcept
     {
         if(static_cast<std::size_t>(
             end_ - p_) > n)
             clip_ = p_ + n;
         else
             clip_ = end_;
     }
 };
 
 //--------------------------------------
 
 class stream
 {
     friend class local_stream;
 
     char* p_;
     char* end_;
 
 public:
     stream(
         char* data,
         std::size_t size) noexcept
         : p_(data)
         , end_(data + size)
     {
     }
 
     size_t
     used(char* begin) const noexcept
     {
         return static_cast<
             size_t>(p_ - begin);
     }
 
     size_t
     remain() const noexcept
     {
         return end_ - p_;
     }
 
     char*
     data() noexcept
     {
         return p_;
     }
 
     operator bool() const noexcept
     {
         return p_ < end_;
     }
 
     // unchecked
     char&
     operator*() noexcept
     {
         BOOST_ASSERT(p_ < end_);
         return *p_;
     }
 
     // unchecked
     stream&
     operator++() noexcept
     {
         BOOST_ASSERT(p_ < end_);
         ++p_;
         return *this;
     }
 
     // unchecked
     void
     append(
         char const* src,
         std::size_t n) noexcept
     {
         BOOST_ASSERT(remain() >= n);
         std::memcpy(p_, src, n);
         p_ += n;
     }
 
     // unchecked
     void
     append(char c) noexcept
     {
         BOOST_ASSERT(p_ < end_);
         *p_++ = c;
     }
 
     void
     advance(std::size_t n) noexcept
     {
         BOOST_ASSERT(remain() >= n);
         p_ += n;
     }
 };
 
 class local_stream
     : public stream
 {
     stream& src_;
 
 public:
     explicit
     local_stream(
         stream& src)
         : stream(src)
         , src_(src)
     {
     }
 
     ~local_stream()
     {
         src_.p_ = p_;
     }
 };
 
 } // detail
 } // namespace json
 } // namespace boost
 
 #endif

This page was automatically generated by the 2.3.7 LXR engine. The LXR team