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
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
|
//
// UnufferedStreamBuf.h
//
// Library: Foundation
// Package: Streams
// Module: StreamBuf
//
// Definition of template BasicUnbufferedStreamBuf and class UnbufferedStreamBuf.
//
// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Foundation_UnbufferedStreamBuf_INCLUDED
#define Foundation_UnbufferedStreamBuf_INCLUDED
#include "Poco/Foundation.h"
#include "Poco/StreamUtil.h"
#include <streambuf>
#include <iosfwd>
#include <ios>
namespace Poco {
template <typename ch, typename tr>
class BasicUnbufferedStreamBuf: public std::basic_streambuf<ch, tr>
/// This is an implementation of an unbuffered streambuf
/// that greatly simplifies the implementation of
/// custom streambufs of various kinds.
/// Derived classes only have to override the methods
/// readFromDevice() or writeToDevice().
{
protected:
typedef std::basic_streambuf<ch, tr> Base;
typedef std::basic_ios<ch, tr> IOS;
typedef ch char_type;
typedef tr char_traits;
typedef typename Base::int_type int_type;
typedef typename Base::pos_type pos_type;
typedef typename Base::off_type off_type;
typedef typename IOS::openmode openmode;
public:
BasicUnbufferedStreamBuf():
_pb(char_traits::eof()),
_ispb(false)
{
this->setg(0, 0, 0);
this->setp(0, 0);
}
~BasicUnbufferedStreamBuf()
{
}
virtual int_type overflow(int_type c)
{
if (c != char_traits::eof())
return writeToDevice(char_traits::to_char_type(c));
else
return c;
}
virtual int_type underflow()
{
if (_ispb)
{
return _pb;
}
else
{
int_type c = readFromDevice();
if (c != char_traits::eof())
{
_ispb = true;
_pb = c;
}
return c;
}
}
virtual int_type uflow()
{
if (_ispb)
{
_ispb = false;
return _pb;
}
else
{
int_type c = readFromDevice();
if (c != char_traits::eof())
{
_pb = c;
}
return c;
}
}
virtual int_type pbackfail(int_type c)
{
if (_ispb)
{
return char_traits::eof();
}
else
{
_ispb = true;
_pb = c;
return c;
}
}
virtual std::streamsize xsgetn(char_type* p, std::streamsize count)
/// Some platforms (for example, Compaq C++) have buggy implementations of
/// xsgetn that handle null buffers incorrectly.
/// Anyway, it does not hurt to provide an optimized implementation
/// of xsgetn for this streambuf implementation.
{
std::streamsize copied = 0;
while (count > 0)
{
int_type c = uflow();
if (c == char_traits::eof()) break;
*p++ = char_traits::to_char_type(c);
++copied;
--count;
}
return copied;
}
protected:
static int_type charToInt(char_type c)
{
return char_traits::to_int_type(c);
}
private:
virtual int_type readFromDevice()
{
return char_traits::eof();
}
virtual int_type writeToDevice(char_type)
{
return char_traits::eof();
}
int_type _pb;
bool _ispb;
BasicUnbufferedStreamBuf(const BasicUnbufferedStreamBuf&);
BasicUnbufferedStreamBuf& operator = (const BasicUnbufferedStreamBuf&);
};
//
// We provide an instantiation for char.
//
// Visual C++ needs a workaround - explicitly importing the template
// instantiation - to avoid duplicate symbols due to multiple
// instantiations in different libraries.
//
#if defined(_MSC_VER) && defined(POCO_DLL) && !defined(Foundation_EXPORTS)
template class Foundation_API BasicUnbufferedStreamBuf<char, std::char_traits<char> >;
#endif
typedef BasicUnbufferedStreamBuf<char, std::char_traits<char> > UnbufferedStreamBuf;
} // namespace Poco
#endif // Foundation_UnbufferedStreamBuf_INCLUDED
|
