Blame view

3rdparty/boost_1_81_0/boost/json/detail/stack.hpp 1.85 KB
63e88f80   Hu Chunming   提交三方库
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
  //
  // 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_STACK_HPP
  #define BOOST_JSON_DETAIL_STACK_HPP
  
  #include <boost/json/detail/config.hpp>
  #include <boost/json/storage_ptr.hpp>
  #include <cstring>
  
  BOOST_JSON_NS_BEGIN
  namespace detail {
  
  class stack
  {
      storage_ptr sp_;
      std::size_t cap_ = 0;
      std::size_t size_ = 0;
      char* buf_ = nullptr;
  
  public:
      BOOST_JSON_DECL
      ~stack();
  
      bool
      empty() const noexcept
      {
          return size_ == 0;
      }
  
      void
      clear() noexcept
      {
          size_ = 0;
      }
  
      BOOST_JSON_DECL
      void
      reserve(std::size_t n);
  
      template<class T>
      void
      push(T const& t)
      {
          auto const n = sizeof(T);
          // If this assert goes off, it
          // means the calling code did not
          // reserve enough to prevent a
          // reallocation.
          //BOOST_ASSERT(cap_ >= size_ + n);
          reserve(size_ + n);
          std::memcpy(
              buf_ + size_, &t, n);
          size_ += n;
      }
  
      template<class T>
      void
      push_unchecked(T const& t)
      {
          auto const n = sizeof(T);
          BOOST_ASSERT(size_ + n <= cap_);
          std::memcpy(
              buf_ + size_, &t, n);
          size_ += n;
      }
  
      template<class T>
      void
      peek(T& t)
      {
          auto const n = sizeof(T);
          BOOST_ASSERT(size_ >= n);
          std::memcpy(&t,
              buf_ + size_ - n, n);
      }
  
      template<class T>
      void
      pop(T& t)
      {
          auto const n = sizeof(T);
          BOOST_ASSERT(size_ >= n);
          size_ -= n;
          std::memcpy(
              &t, buf_ + size_, n);
      }
  };
  
  } // detail
  BOOST_JSON_NS_END
  
  #endif