alt_sstream_impl.hpp
Go to the documentation of this file.
1 // ----------------------------------------------------------------------------
2 // alt_sstream_impl.hpp : alternative stringstream, templates implementation
3 // ----------------------------------------------------------------------------
4 
5 // Copyright Samuel Krempp 2003. Use, modification, and distribution are
6 // subject to the Boost Software License, Version 1.0. (See accompanying
7 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
8 
9 // See http://www.boost.org/libs/format for library home page
10 
11 // ----------------------------------------------------------------------------
12 
13 #ifndef BOOST_SK_ALT_SSTREAM_IMPL_HPP
14 #define BOOST_SK_ALT_SSTREAM_IMPL_HPP
15 
16 namespace boost {
17  namespace io {
18 // --- Implementation ------------------------------------------------------//
19 
20  template<class Ch, class Tr, class Alloc>
21  void basic_altstringbuf<Ch, Tr, Alloc>::
22  clear_buffer () {
23  const Ch * p = pptr();
24  const Ch * b = pbase();
25  if(p != NULL && p != b) {
26  seekpos(0, ::std::ios_base::out);
27  }
28  p = gptr();
29  b = eback();
30  if(p != NULL && p != b) {
31  seekpos(0, ::std::ios_base::in);
32  }
33  }
34 
35  template<class Ch, class Tr, class Alloc>
36  void basic_altstringbuf<Ch, Tr, Alloc>::
37  str (const string_type& s) {
38  size_type sz=s.size();
39  if(sz != 0 && mode_ & (::std::ios_base::in | ::std::ios_base::out) ) {
40 #ifdef _RWSTD_NO_CLASS_PARTIAL_SPEC
41  void *vd_ptr = alloc_.allocate(sz, is_allocated_? eback() : 0);
42  Ch *new_ptr = static_cast<Ch *>(vd_ptr);
43 #else
44  Ch *new_ptr = alloc_.allocate(sz, is_allocated_? eback() : 0);
45 #endif
46  // if this didnt throw, we're safe, update the buffer
47  dealloc();
48  sz = s.copy(new_ptr, sz);
49  putend_ = new_ptr + sz;
50  if(mode_ & ::std::ios_base::in)
51  streambuf_t::setg(new_ptr, new_ptr, new_ptr + sz);
52  if(mode_ & ::std::ios_base::out) {
53  streambuf_t::setp(new_ptr, new_ptr + sz);
54  if(mode_ & (::std::ios_base::app | ::std::ios_base::ate))
55  streambuf_t::pbump(static_cast<int>(sz));
56  if(gptr() == NULL)
57  streambuf_t::setg(new_ptr, NULL, new_ptr);
58  }
59  is_allocated_ = true;
60  }
61  else
62  dealloc();
63  }
64  template<class Ch, class Tr, class Alloc>
65  Ch* basic_altstringbuf<Ch, Tr, Alloc>::
66  begin () const {
67  if(mode_ & ::std::ios_base::out && pptr() != NULL)
68  return pbase();
69  else if(mode_ & ::std::ios_base::in && gptr() != NULL)
70  return eback();
71  return NULL;
72  }
73 
74  template<class Ch, class Tr, class Alloc>
75  typename std::basic_string<Ch,Tr,Alloc>::size_type
76  basic_altstringbuf<Ch, Tr, Alloc>::
77  size () const {
78  if(mode_ & ::std::ios_base::out && pptr())
79  return static_cast<size_type>(pend() - pbase());
80  else if(mode_ & ::std::ios_base::in && gptr())
81  return static_cast<size_type>(egptr() - eback());
82  else
83  return 0;
84  }
85 
86  template<class Ch, class Tr, class Alloc>
87  typename std::basic_string<Ch,Tr,Alloc>::size_type
88  basic_altstringbuf<Ch, Tr, Alloc>::
89  cur_size () const {
90  if(mode_ & ::std::ios_base::out && pptr())
91  return static_cast<streamsize>( pptr() - pbase());
92  else if(mode_ & ::std::ios_base::in && gptr())
93  return static_cast<streamsize>( gptr() - eback());
94  else
95  return 0;
96  }
97 
98  template<class Ch, class Tr, class Alloc>
99  typename basic_altstringbuf<Ch, Tr, Alloc>::pos_type
100  basic_altstringbuf<Ch, Tr, Alloc>::
101  seekoff (off_type off, ::std::ios_base::seekdir way, ::std::ios_base::openmode which) {
102  if(pptr() != NULL && putend_ < pptr())
103  putend_ = pptr();
104  if(which & ::std::ios_base::in && gptr() != NULL) {
105  // get area
106  if(way == ::std::ios_base::end)
107  off += static_cast<off_type>(putend_ - gptr());
108  else if(way == ::std::ios_base::beg)
109  off += static_cast<off_type>(eback() - gptr());
110  else if(way != ::std::ios_base::cur || (which & ::std::ios_base::out) )
111  // (altering in&out is only supported if way is beg or end, not cur)
112  return pos_type(off_type(-1));
113  if(eback() <= off+gptr() && off+gptr() <= putend_ ) {
114  // set gptr
115  streambuf_t::gbump(static_cast<int>(off));
116  if(which & ::std::ios_base::out && pptr() != NULL)
117  // update pptr to match gptr
118  streambuf_t::pbump(static_cast<int>(gptr()-pptr()));
119  }
120  else
121  off = off_type(-1);
122  }
123  else if(which & ::std::ios_base::out && pptr() != NULL) {
124  // put area
125  if(way == ::std::ios_base::end)
126  off += static_cast<off_type>(putend_ - pptr());
127  else if(way == ::std::ios_base::beg)
128  off += static_cast<off_type>(pbase() - pptr());
129  else if(way != ::std::ios_base::beg)
130  return pos_type(off_type(-1));
131  if(pbase() <= off+pptr() && off+pptr() <= putend_)
132  // set pptr
133  streambuf_t::pbump(static_cast<int>(off));
134  else
135  off = off_type(-1);
136  }
137  else // neither in nor out
138  off = off_type(-1);
139  return (pos_type(off));
140  }
141  //- end seekoff(..)
142 
143 
144  template<class Ch, class Tr, class Alloc>
145  typename basic_altstringbuf<Ch, Tr, Alloc>::pos_type
146  basic_altstringbuf<Ch, Tr, Alloc>::
147  seekpos (pos_type pos, ::std::ios_base::openmode which) {
148  off_type off = off_type(pos); // operation guaranteed by 27.4.3.2 table 88
149  if(pptr() != NULL && putend_ < pptr())
150  putend_ = pptr();
151  if(off != off_type(-1)) {
152  if(which & ::std::ios_base::in && gptr() != NULL) {
153  // get area
154  if(0 <= off && off <= putend_ - eback()) {
155  streambuf_t::gbump(static_cast<int>(eback() - gptr() + off));
156  if(which & ::std::ios_base::out && pptr() != NULL) {
157  // update pptr to match gptr
158  streambuf_t::pbump(static_cast<int>(gptr()-pptr()));
159  }
160  }
161  else
162  off = off_type(-1);
163  }
164  else if(which & ::std::ios_base::out && pptr() != NULL) {
165  // put area
166  if(0 <= off && off <= putend_ - eback())
167  streambuf_t::pbump(static_cast<int>(eback() - pptr() + off));
168  else
169  off = off_type(-1);
170  }
171  else // neither in nor out
172  off = off_type(-1);
173  return (pos_type(off));
174  }
175  else {
176  BOOST_ASSERT(0); // §27.4.3.2 allows undefined-behaviour here
177  return pos_type(off_type(-1));
178  }
179  }
180  // -end seekpos(..)
181 
182 
183  template<class Ch, class Tr, class Alloc>
184  typename basic_altstringbuf<Ch, Tr, Alloc>::int_type
185  basic_altstringbuf<Ch, Tr, Alloc>::
186  underflow () {
187  if(gptr() == NULL) // no get area -> nothing to get.
188  return (compat_traits_type::eof());
189  else if(gptr() < egptr()) // ok, in buffer
190  return (compat_traits_type::to_int_type(*gptr()));
191  else if(mode_ & ::std::ios_base::in && pptr() != NULL
192  && (gptr() < pptr() || gptr() < putend_) )
193  { // expand get area
194  if(putend_ < pptr())
195  putend_ = pptr(); // remember pptr reached this far
196  streambuf_t::setg(eback(), gptr(), putend_);
197  return (compat_traits_type::to_int_type(*gptr()));
198  }
199  else // couldnt get anything. EOF.
200  return (compat_traits_type::eof());
201  }
202  // -end underflow(..)
203 
204 
205  template<class Ch, class Tr, class Alloc>
206  typename basic_altstringbuf<Ch, Tr, Alloc>::int_type
207  basic_altstringbuf<Ch, Tr, Alloc>::
208  pbackfail (int_type meta) {
209  if(gptr() != NULL && (eback() < gptr())
210  && (mode_ & (::std::ios_base::out)
211  || compat_traits_type::eq_int_type(compat_traits_type::eof(), meta)
212  || compat_traits_type::eq(compat_traits_type::to_char_type(meta), gptr()[-1]) ) ) {
213  streambuf_t::gbump(-1); // back one character
214  if(!compat_traits_type::eq_int_type(compat_traits_type::eof(), meta))
215  // put-back meta into get area
216  *gptr() = compat_traits_type::to_char_type(meta);
217  return (compat_traits_type::not_eof(meta));
218  }
219  else
220  return (compat_traits_type::eof()); // failed putback
221  }
222  // -end pbackfail(..)
223 
224 
225  template<class Ch, class Tr, class Alloc>
226  typename basic_altstringbuf<Ch, Tr, Alloc>::int_type
227  basic_altstringbuf<Ch, Tr, Alloc>::
228  overflow (int_type meta) {
229 #ifdef BOOST_MSVC
230 #pragma warning(push)
231 #pragma warning(disable:4996)
232 #endif
233  if(compat_traits_type::eq_int_type(compat_traits_type::eof(), meta))
234  return compat_traits_type::not_eof(meta); // nothing to do
235  else if(pptr() != NULL && pptr() < epptr()) {
236  streambuf_t::sputc(compat_traits_type::to_char_type(meta));
237  return meta;
238  }
239  else if(! (mode_ & ::std::ios_base::out))
240  // no write position, and cant make one
241  return compat_traits_type::eof();
242  else { // make a write position available
243  std::size_t prev_size = pptr() == NULL ? 0 : epptr() - eback();
244  std::size_t new_size = prev_size;
245  // exponential growth : size *= 1.5
246  std::size_t add_size = new_size / 2;
247  if(add_size < alloc_min)
248  add_size = alloc_min;
249  Ch * newptr = NULL, *oldptr = eback();
250 
251  // make sure adding add_size wont overflow size_t
252  while (0 < add_size && ((std::numeric_limits<std::size_t>::max)()
253  - add_size < new_size) )
254  add_size /= 2;
255  if(0 < add_size) {
256  new_size += add_size;
257 #ifdef _RWSTD_NO_CLASS_PARTIAL_SPEC
258  void *vdptr = alloc_.allocate(new_size, is_allocated_? oldptr : 0);
259  newptr = static_cast<Ch *>(vdptr);
260 #else
261  newptr = alloc_.allocate(new_size, is_allocated_? oldptr : 0);
262 #endif
263  }
264 
265  if(0 < prev_size)
266  compat_traits_type::copy(newptr, oldptr, prev_size);
267  if(is_allocated_)
268  alloc_.deallocate(oldptr, prev_size);
269  is_allocated_=true;
270 
271  if(prev_size == 0) { // first allocation
272  putend_ = newptr;
273  streambuf_t::setp(newptr, newptr + new_size);
274  if(mode_ & ::std::ios_base::in)
275  streambuf_t::setg(newptr, newptr, newptr + 1);
276  else
277  streambuf_t::setg(newptr, 0, newptr);
278  }
279  else { // update pointers
280  putend_ = putend_ - oldptr + newptr;
281  int pptr_count = static_cast<int>(pptr()-pbase());
282  int gptr_count = static_cast<int>(gptr()-eback());
283  streambuf_t::setp(pbase() - oldptr + newptr, newptr + new_size);
284  streambuf_t::pbump(pptr_count);
285  if(mode_ & ::std::ios_base::in)
286  streambuf_t::setg(newptr, newptr + gptr_count, pptr() + 1);
287  else
288  streambuf_t::setg(newptr, 0, newptr);
289  }
290  streambuf_t::sputc(compat_traits_type::to_char_type(meta));
291  return meta;
292  }
293 #ifdef BOOST_MSVC
294 #pragma warning(pop)
295 #endif
296  }
297  // -end overflow(..)
298 
299  template<class Ch, class Tr, class Alloc>
300  void basic_altstringbuf<Ch, Tr, Alloc>:: dealloc() {
301  if(is_allocated_)
302  alloc_.deallocate(eback(), (pptr() != NULL ? epptr() : egptr()) - eback());
303  is_allocated_ = false;
304  streambuf_t::setg(0, 0, 0);
305  streambuf_t::setp(0, 0);
306  putend_ = NULL;
307  }
308 
309  }// N.S. io
310 } // N.S. boost
311 
312 #endif // include guard
313 
end
GLuint GLuint end
Definition: glad/glad/glad.h:2396
b
GLboolean GLboolean GLboolean b
Definition: glad/glad/glad.h:3065
boost::io::basic_altstringbuf::streamsize
::std::streamsize streamsize
Definition: alt_sstream.hpp:54
boost
BOOST_MOVE_USE_STANDARD_LIBRARY_MOVE.
Definition: core/addressof.hpp:19
s
GLdouble s
Definition: glad/glad/glad.h:2442
p
GLfloat GLfloat p
Definition: glext.h:12687
boost::io::basic_altstringbuf::cur_size
size_type cur_size() const
Definition: alt_sstream_impl.hpp:89
boost::io::basic_altstringbuf::pos_type
compat_traits_type::pos_type pos_type
Definition: alt_sstream.hpp:48
boost::io::basic_altstringbuf::size_type
string_type::size_type size_type
Definition: alt_sstream.hpp:52
boost::io::basic_altstringbuf::off_type
compat_traits_type::off_type off_type
Definition: alt_sstream.hpp:49
boost::io::basic_altstringbuf::overflow
virtual int_type overflow(int_type meta=compat_traits_type::eof())
Definition: alt_sstream_impl.hpp:228
boost::io::basic_altstringbuf::seekpos
virtual pos_type seekpos(pos_type pos,::std::ios_base::openmode which=::std::ios_base::in|::std::ios_base::out)
Definition: alt_sstream_impl.hpp:147
boost::io::basic_altstringbuf::int_type
compat_traits_type::int_type int_type
Definition: alt_sstream.hpp:47
boost::io::basic_altstringbuf::begin
Ch * begin() const
Definition: alt_sstream_impl.hpp:66
boost::io::basic_altstringbuf::pbackfail
virtual int_type pbackfail(int_type meta=compat_traits_type::eof())
Definition: alt_sstream_impl.hpp:208
boost::io::basic_altstringbuf::clear_buffer
void clear_buffer()
Definition: alt_sstream_impl.hpp:22
boost::io::basic_altstringbuf::underflow
virtual int_type underflow()
Definition: alt_sstream_impl.hpp:186
boost::io::basic_altstringbuf::seekoff
virtual pos_type seekoff(off_type off,::std::ios_base::seekdir way,::std::ios_base::openmode which=::std::ios_base::in|::std::ios_base::out)
Definition: alt_sstream_impl.hpp:101
boost::io::basic_altstringbuf::dealloc
void dealloc()
Definition: alt_sstream_impl.hpp:300
boost::io::basic_altstringbuf::str
string_type str() const
Definition: alt_sstream.hpp:88
boost::io::basic_altstringbuf::size
size_type size() const
Definition: alt_sstream_impl.hpp:77
eq
bool eq(float3 const &a, float3 const &b)
Definition: test-pose.cpp:57
in
GLuint in
Definition: glext.h:8859
pos
float rs2_vector::* pos
Definition: rs-trajectory.cpp:252
NULL
#define NULL
Definition: tinycthread.c:47
opencv_pointcloud_viewer.out
out
Definition: opencv_pointcloud_viewer.py:264
BOOST_ASSERT
#define BOOST_ASSERT(expr)
Definition: assert.hpp:56
librealsense::copy
void copy(void *dst, void const *src, size_t size)
Definition: types.cpp:836
boost::io::basic_altstringbuf::string_type
::std::basic_string< Ch, Tr, Alloc > string_type
Definition: alt_sstream.hpp:51

librealsense2
Author(s): Sergey Dorodnicov , Doron Hirshberg , Mark Horn , Reagan Lopez , Itay Carpis
autogenerated on Mon May 3 2021 02:45:06