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
180
181
|
//
// LineEndingConverter.h
//
// Library: Foundation
// Package: Streams
// Module: LineEndingConverter
//
// Definition of the LineEndingConverter class.
//
// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Foundation_LineEndingConverter_INCLUDED
#define Foundation_LineEndingConverter_INCLUDED
#include "Poco/Foundation.h"
#include "Poco/UnbufferedStreamBuf.h"
#include <istream>
#include <ostream>
namespace Poco {
class Foundation_API LineEnding
/// This class defines valid line ending sequences
/// for InputLineEndingConverter and OutputLineEndingConverter.
{
public:
static const std::string NEWLINE_DEFAULT;
static const std::string NEWLINE_CR;
static const std::string NEWLINE_CRLF;
static const std::string NEWLINE_LF;
};
class Foundation_API LineEndingConverterStreamBuf: public UnbufferedStreamBuf
/// This stream buffer performs line ending conversion
/// on text streams. The converter can convert from and to
/// the Unix (LF), Mac (CR) and DOS/Windows/Network (CF-LF) endings.
///
/// Any newline sequence in the source will be replaced by the
/// target newline sequence.
{
public:
LineEndingConverterStreamBuf(std::istream& istr);
/// Creates the LineEndingConverterStreamBuf and connects it
/// to the given input stream.
LineEndingConverterStreamBuf(std::ostream& ostr);
/// Creates the LineEndingConverterStreamBuf and connects it
/// to the given output stream.
~LineEndingConverterStreamBuf();
/// Destroys the LineEndingConverterStream.
void setNewLine(const std::string& newLineCharacters);
/// Sets the target line ending for the converter.
///
/// Possible values are:
/// * NEWLINE_DEFAULT (whatever is appropriate for the current platform)
/// * NEWLINE_CRLF (Windows),
/// * NEWLINE_LF (Unix),
/// * NEWLINE_CR (Macintosh)
///
/// In theory, any character sequence can be used as newline sequence.
/// In practice, however, only the above three make sense.
const std::string& getNewLine() const;
/// Returns the line ending currently in use.
protected:
int readFromDevice();
int writeToDevice(char c);
private:
std::istream* _pIstr;
std::ostream* _pOstr;
std::string _newLine;
std::string::const_iterator _it;
char _lastChar;
};
class Foundation_API LineEndingConverterIOS: public virtual std::ios
/// The base class for InputLineEndingConverter and OutputLineEndingConverter.
///
/// This class provides common methods and is also needed to ensure
/// the correct initialization order of the stream buffer and base classes.
{
public:
LineEndingConverterIOS(std::istream& istr);
/// Creates the LineEndingConverterIOS and connects it
/// to the given input stream.
LineEndingConverterIOS(std::ostream& ostr);
/// Creates the LineEndingConverterIOS and connects it
/// to the given output stream.
~LineEndingConverterIOS();
/// Destroys the stream.
void setNewLine(const std::string& newLineCharacters);
/// Sets the target line ending for the converter.
///
/// Possible values are:
/// * NEWLINE_DEFAULT (whatever is appropriate for the current platform)
/// * NEWLINE_CRLF (Windows),
/// * NEWLINE_LF (Unix),
/// * NEWLINE_CR (Macintosh)
///
/// In theory, any character sequence can be used as newline sequence.
/// In practice, however, only the above three make sense.
///
/// If an empty string is given, all newline characters are removed from
/// the stream.
const std::string& getNewLine() const;
/// Returns the line ending currently in use.
LineEndingConverterStreamBuf* rdbuf();
/// Returns a pointer to the underlying streambuf.
protected:
LineEndingConverterStreamBuf _buf;
};
class Foundation_API InputLineEndingConverter: public LineEndingConverterIOS, public std::istream
/// InputLineEndingConverter performs line ending conversion
/// on text input streams. The converter can convert from and to
/// the Unix (LF), Mac (CR) and DOS/Windows/Network (CF-LF) endings.
///
/// Any newline sequence in the source will be replaced by the
/// target newline sequence.
{
public:
InputLineEndingConverter(std::istream& istr);
/// Creates the LineEndingConverterInputStream and connects it
/// to the given input stream.
InputLineEndingConverter(std::istream& istr, const std::string& newLineCharacters);
/// Creates the LineEndingConverterInputStream and connects it
/// to the given input stream.
~InputLineEndingConverter();
/// Destroys the stream.
};
class Foundation_API OutputLineEndingConverter: public LineEndingConverterIOS, public std::ostream
/// OutputLineEndingConverter performs line ending conversion
/// on text output streams. The converter can convert from and to
/// the Unix (LF), Mac (CR) and DOS/Windows/Network (CF-LF) endings.
///
/// Any newline sequence in the source will be replaced by the
/// target newline sequence.
{
public:
OutputLineEndingConverter(std::ostream& ostr);
/// Creates the LineEndingConverterOutputStream and connects it
/// to the given input stream.
OutputLineEndingConverter(std::ostream& ostr, const std::string& newLineCharacters);
/// Creates the LineEndingConverterOutputStream and connects it
/// to the given input stream.
~OutputLineEndingConverter();
/// Destroys the LineEndingConverterOutputStream.
};
} // namespace Poco
#endif // Foundation_LineEndingConverter_INCLUDED
|
