ゴミ箱
bitstream.hpp
Go to the documentation of this file.
1 //
2 // Copyright (c) 2016-2017 Vinnie Falco (vinnie dot falco at gmail dot 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/beast
8 //
9 // This is a derivative work based on Zlib, copyright below:
10 /*
11  Copyright (C) 1995-2013 Jean-loup Gailly and Mark Adler
12 
13  This software is provided 'as-is', without any express or implied
14  warranty. In no event will the authors be held liable for any damages
15  arising from the use of this software.
16 
17  Permission is granted to anyone to use this software for any purpose,
18  including commercial applications, and to alter it and redistribute it
19  freely, subject to the following restrictions:
20 
21  1. The origin of this software must not be misrepresented; you must not
22  claim that you wrote the original software. If you use this software
23  in a product, an acknowledgment in the product documentation would be
24  appreciated but is not required.
25  2. Altered source versions must be plainly marked as such, and must not be
26  misrepresented as being the original software.
27  3. This notice may not be removed or altered from any source distribution.
28 
29  Jean-loup Gailly Mark Adler
30  jloup@gzip.org madler@alumni.caltech.edu
31 
32  The data format used by the zlib library is described by RFCs (Request for
33  Comments) 1950 to 1952 in the files http://tools.ietf.org/html/rfc1950
34  (zlib format), rfc1951 (deflate format) and rfc1952 (gzip format).
35 */
36 
37 #ifndef BOOST_BEAST_ZLIB_DETAIL_BITSTREAM_HPP
38 #define BOOST_BEAST_ZLIB_DETAIL_BITSTREAM_HPP
39 
40 #include <boost/assert.hpp>
41 #include <cstdint>
42 #include <iterator>
43 
44 namespace boost {
45 namespace beast {
46 namespace zlib {
47 namespace detail {
48 
49 class bitstream
50 {
51  using value_type = std::uint32_t;
52 
53  value_type v_ = 0;
54  unsigned n_ = 0;
55 
56 public:
57  // returns the number of bits in the reservoir
58  unsigned
59  size() const
60  {
61  return n_;
62  }
63 
64  // discard n bits
65  void
66  drop(std::size_t n)
67  {
68  BOOST_ASSERT(n <= n_);
69  n_ -= static_cast<unsigned>(n);
70  v_ >>= n;
71  }
72 
73  // flush everything
74  void
76  {
77  n_ = 0;
78  v_ = 0;
79  }
80 
81  // flush to the next byte boundary
82  void
84  {
85  drop(n_ % 8);
86  }
87 
88  // ensure at least n bits
89  template<class FwdIt>
90  bool
91  fill(std::size_t n, FwdIt& first, FwdIt const& last);
92 
93  // fill 8 bits, unchecked
94  template<class FwdIt>
95  void
96  fill_8(FwdIt& it);
97 
98  // fill 16 bits, unchecked
99  template<class FwdIt>
100  void
101  fill_16(FwdIt& it);
102 
103  // return n bits
104  template<class Unsigned>
105  void
106  peek(Unsigned& value, std::size_t n);
107 
108  // return everything in the reservoir
109  value_type
110  peek_fast() const
111  {
112  return v_;
113  }
114 
115  // return n bits, and consume
116  template<class Unsigned>
117  void
118  read(Unsigned& value, std::size_t n);
119 
120  // rewind by the number of whole bytes stored (unchecked)
121  template<class BidirIt>
122  void
123  rewind(BidirIt& it);
124 };
125 
126 template<class FwdIt>
127 inline
128 bool
130 fill(std::size_t n, FwdIt& first, FwdIt const& last)
131 {
132  while(n_ < n)
133  {
134  if(first == last)
135  return false;
136  v_ += static_cast<value_type>(*first++) << n_;
137  n_ += 8;
138  }
139  return true;
140 }
141 
142 template<class FwdIt>
143 inline
144 void
146 fill_8(FwdIt& it)
147 {
148  v_ += static_cast<value_type>(*it++) << n_;
149  n_ += 8;
150 }
151 
152 template<class FwdIt>
153 inline
154 void
156 fill_16(FwdIt& it)
157 {
158  v_ += static_cast<value_type>(*it++) << n_;
159  n_ += 8;
160  v_ += static_cast<value_type>(*it++) << n_;
161  n_ += 8;
162 }
163 
164 template<class Unsigned>
165 inline
166 void
168 peek(Unsigned& value, std::size_t n)
169 {
170  BOOST_ASSERT(n <= sizeof(value)*8);
171  BOOST_ASSERT(n <= n_);
172  value = static_cast<Unsigned>(
173  v_ & ((1ULL << n) - 1));
174 }
175 
176 template<class Unsigned>
177 inline
178 void
180 read(Unsigned& value, std::size_t n)
181 {
182  BOOST_ASSERT(n < sizeof(v_)*8);
183  BOOST_ASSERT(n <= n_);
184  value = static_cast<Unsigned>(
185  v_ & ((1ULL << n) - 1));
186  v_ >>= n;
187  n_ -= static_cast<unsigned>(n);
188 }
189 
190 template<class BidirIt>
191 inline
192 void
194 rewind(BidirIt& it)
195 {
196  auto len = n_ >> 3;
197  it = std::prev(it, len);
198  n_ &= 7;
199  v_ &= (1U << n_) - 1;
200 }
201 
202 } // detail
203 } // zlib
204 } // beast
205 } // boost
206 
207 #endif
void read(Unsigned &value, std::size_t n)
Definition: bitstream.hpp:180
Definition: async_result.hpp:20
bool fill(std::size_t n, FwdIt &first, FwdIt const &last)
Definition: bitstream.hpp:130
value_type peek_fast() const
Definition: bitstream.hpp:110
void rewind(BidirIt &it)
Definition: bitstream.hpp:194
Definition: bitstream.hpp:49
unsigned size() const
Definition: bitstream.hpp:59
void peek(Unsigned &value, std::size_t n)
Definition: bitstream.hpp:168
void flush_byte()
Definition: bitstream.hpp:83
void fill_16(FwdIt &it)
Definition: bitstream.hpp:156
void drop(std::size_t n)
Definition: bitstream.hpp:66
void flush()
Definition: bitstream.hpp:75
void fill_8(FwdIt &it)
Definition: bitstream.hpp:146