TLA  Line data    Source code

       1                 : //
       2                 : // Copyright (c) 2019 Vinnie Falco (vinnie.falco@gmail.com)
       3                 : //
       4                 : // Distributed under the Boost Software License, Version 1.0. (See accompanying
       5                 : // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
       6                 : //
       7                 : // Official repository: https://github.com/boostorg/json
       8                 : //
       9                 : 
      10                 : #ifndef BOOST_JSON_DETAIL_STACK_HPP
      11                 : #define BOOST_JSON_DETAIL_STACK_HPP
      12                 : 
      13                 : #include <boost/json/detail/config.hpp>
      14                 : #include <boost/json/storage_ptr.hpp>
      15                 : #include <boost/mp11/integral.hpp>
      16                 : #include <cstring>
      17                 : #include <type_traits>
      18                 : 
      19                 : namespace boost {
      20                 : namespace json {
      21                 : namespace detail {
      22                 : 
      23                 : #if defined( BOOST_LIBSTDCXX_VERSION ) && BOOST_LIBSTDCXX_VERSION < 50000
      24                 : 
      25                 : template<class T>
      26                 : struct is_trivially_copy_assignable
      27                 :     : mp11::mp_bool<
      28                 :         std::is_copy_assignable<T>::value &&
      29                 :           std::has_trivial_copy_assign<T>::value >
      30                 : {};
      31                 : 
      32                 : #else
      33                 : 
      34                 : using std::is_trivially_copy_assignable;
      35                 : 
      36                 : #endif
      37                 : 
      38                 : class stack
      39                 : {
      40                 :     template< class T = void >
      41                 :     struct non_trivial;
      42                 : 
      43                 :     storage_ptr sp_;
      44                 :     std::size_t cap_ = 0;
      45                 :     std::size_t size_ = 0;
      46                 :     non_trivial<>* head_ = nullptr;
      47                 :     unsigned char* base_ = nullptr;
      48                 :     unsigned char* buf_ = nullptr;
      49                 : 
      50                 : public:
      51                 :     BOOST_JSON_DECL
      52                 :     ~stack();
      53                 : 
      54 HIT     2164605 :     stack() = default;
      55                 : 
      56                 :     stack(
      57                 :         storage_ptr sp,
      58                 :         unsigned char* buf,
      59                 :         std::size_t buf_size) noexcept;
      60                 : 
      61                 :     bool
      62         3260464 :     empty() const noexcept
      63                 :     {
      64         3260464 :         return size_ == 0;
      65                 :     }
      66                 : 
      67                 :     BOOST_JSON_DECL
      68                 :     void
      69                 :     clear() noexcept;
      70                 : 
      71                 :     void
      72          173075 :     reserve(std::size_t n)
      73                 :     {
      74          173075 :         if(n > cap_)
      75          115792 :             reserve_impl(n);
      76          173075 :     }
      77                 : 
      78                 :     template<class T>
      79                 :     void
      80           47896 :     push(T&& t)
      81                 :     {
      82                 :         using U = remove_cvref<T>;
      83           47896 :         push( static_cast<T&&>(t), is_trivially_copy_assignable<U>() );
      84           47894 :     }
      85                 : 
      86                 :     template<class T>
      87                 :     void
      88                 :     push_unchecked(
      89                 :         T const& t);
      90                 : 
      91                 :     template<class T>
      92                 :     void
      93                 :     peek(T& t);
      94                 : 
      95                 :     template<class T>
      96                 :     void
      97          328590 :     pop(T& t)
      98                 :     {
      99                 :         using U = remove_cvref<T>;
     100          328590 :         pop( t, is_trivially_copy_assignable<U>() );
     101          328590 :     }
     102                 : 
     103                 : private:
     104                 :     template<class T> void push(
     105                 :         T const& t, std::true_type);
     106                 :     template<class T> void push(
     107                 :         T&& t, std::false_type);
     108                 :     template<class T> void pop(
     109                 :         T& t, std::true_type);
     110                 :     template<class T> void pop(
     111                 :         T& t, std::false_type);
     112                 : 
     113                 :     BOOST_JSON_DECL
     114                 :     void
     115                 :     reserve_impl(
     116                 :         std::size_t n);
     117                 : };
     118                 : 
     119                 : } // detail
     120                 : } // namespace json
     121                 : } // namespace boost
     122                 : 
     123                 : #include <boost/json/detail/impl/stack.hpp>
     124                 : 
     125                 : #endif