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
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
|
// This file is part of the ustl library, an STL implementation.
//
// Copyright (C) 2005 by Mike Sharov <msharov@users.sourceforge.net>
// This file is free software, distributed under the MIT License.
//
// mostream.h
#ifndef MOSTREAM_H_24A8C5397E0848216573E5670930FC9A
#define MOSTREAM_H_24A8C5397E0848216573E5670930FC9A
#include "memlink.h"
#include "uassert.h"
#include "uexception.h"
#include "utf8.h"
#include "uios.h"
#include <typeinfo>
namespace ustl {
class istream;
class string;
/// \class ostream mostream.h ustl.h
/// \ingroup BinaryStreams
///
/// \brief Helper class to write packed binary streams.
///
/// This class contains a set of functions to write integral types into an
/// unstructured memory block. Packing binary file data can be done this
/// way, for instance. aligning the data is your responsibility, and can
/// be accomplished by proper ordering of writes and by calling \ref ostream::align.
/// Unaligned access is usually slower by orders of magnitude and,
/// on some architectures, such as PowerPC, can cause your program to crash.
/// Therefore, all write functions have asserts to check alignment.
/// See \ref istream documentation for rules on designing your data format.
/// Overwriting the end of the stream will also cause a crash (an assert in
/// debug builds). Oh, and don't be intimidated by the size of the inlines
/// here. In the assembly code the compiler will usually chop everything down
/// to five instructions each.
///
/// Example code:
/// \code
/// memblock b;
/// ostream os (b);
/// os << boolVar << ios::talign<int>();
/// os << intVar << floatVar;
/// os.write (binaryData, binaryDataSize);
/// os.align();
/// b.resize (os.pos());
/// b.write_file ("test.file");
/// \endcode
///
class ostream : public memlink, public ios_base {
public:
ostream (void);
ostream (void* p, size_type n);
explicit ostream (const memlink& source);
inline iterator end (void) { return (memlink::end()); }
inline const_iterator end (void) const { return (memlink::end()); }
inline void seek (uoff_t newPos);
inline void iseek (const_iterator newPos);
inline void skip (size_type nBytes);
inline uoff_t pos (void) const { return (m_Pos); }
inline iterator ipos (void) { return (begin() + pos()); }
inline const_iterator ipos (void) const { return (begin() + pos()); }
inline size_type remaining (void) const;
inline bool aligned (size_type grain = c_DefaultAlignment) const;
void verify_remaining (const char* op, const char* type, size_t n) const;
inline size_type align_size (size_type grain = c_DefaultAlignment) const;
void align (size_type grain = c_DefaultAlignment);
void write (const void* buffer, size_type size);
inline void write (const cmemlink& buf);
void write_strz (const char* str);
void read (istream& is);
inline void write (ostream& os) const { os.write (begin(), pos()); }
void text_write (ostringstream& os) const;
inline size_t stream_size (void) const { return (pos()); }
void insert (iterator start, size_type size);
void erase (iterator start, size_type size);
void swap (ostream& os);
template <typename T>
inline void iwrite (const T& v);
inline virtual size_type overflow (size_type = 1){ return (remaining()); }
virtual void unlink (void);
inline void link (void* p, size_type n) { memlink::link (p, n); }
inline void link (memlink& l) { memlink::link (l.data(), l.writable_size()); }
inline void link (void* f, void* l) { memlink::link (f, l); }
OVERLOAD_POINTER_AND_SIZE_T_V2(link, void*)
inline void relink (void* p, size_type n) { memlink::relink (p, n); m_Pos = 0; }
inline void relink (memlink& l) { relink (l.data(), l.writable_size()); }
inline void seekp (off_t p, seekdir d = beg);
inline off_t tellp (void) const { return (pos()); }
protected:
inline void SetPos (uoff_t newPos) { m_Pos = newPos; }
private:
uoff_t m_Pos; ///< Current write position.
};
//----------------------------------------------------------------------
/// \class ostream_iterator mostream.h ustl.h
/// \ingroup BinaryStreamIterators
///
/// \brief An iterator over an ostream to use with uSTL algorithms.
///
template <typename T, typename Stream = ostream>
class ostream_iterator {
public:
typedef T value_type;
typedef ptrdiff_t difference_type;
typedef value_type* pointer;
typedef value_type& reference;
typedef ostream::size_type size_type;
public:
inline explicit ostream_iterator (Stream& os)
: m_Os (os) {}
inline ostream_iterator (const ostream_iterator& iter)
: m_Os (iter.m_Os) {}
/// Writes \p v into the stream.
inline ostream_iterator& operator= (const T& v)
{ m_Os << v; return (*this); }
inline ostream_iterator& operator* (void) { return (*this); }
inline ostream_iterator& operator++ (void) { return (*this); }
inline ostream_iterator operator++ (int) { return (*this); }
inline ostream_iterator& operator+= (size_type n) { m_Os.skip (n); return (*this); }
inline bool operator== (const ostream_iterator& i) const
{ return (m_Os.pos() == i.m_Os.pos()); }
inline bool operator< (const ostream_iterator& i) const
{ return (m_Os.pos() < i.m_Os.pos()); }
private:
Stream& m_Os;
};
//----------------------------------------------------------------------
typedef ostream_iterator<utf8subchar_t> ostream_iterator_for_utf8;
typedef utf8out_iterator<ostream_iterator_for_utf8> utf8ostream_iterator;
/// Returns a UTF-8 adaptor writing to \p os.
inline utf8ostream_iterator utf8out (ostream& os)
{
ostream_iterator_for_utf8 si (os);
return (utf8ostream_iterator (si));
}
//----------------------------------------------------------------------
/// Move the write pointer to \p newPos
inline void ostream::seek (uoff_t newPos)
{
#ifdef WANT_STREAM_BOUNDS_CHECKING
if (newPos > size())
throw stream_bounds_exception ("seekp", "byte", pos(), newPos - pos(), size());
#else
assert (newPos <= size());
#endif
SetPos (newPos);
}
/// Sets the current write position to \p newPos
inline void ostream::iseek (const_iterator newPos)
{
seek (distance (begin(), const_cast<iterator>(newPos)));
}
/// Sets the current write position to \p p based on \p d.
inline void ostream::seekp (off_t p, seekdir d)
{
switch (d) {
case beg: seek (p); break;
case cur: seek (pos() + p); break;
case ios_base::end: seek (size() - p); break;
}
}
/// Skips \p nBytes without writing anything.
inline void ostream::skip (size_type nBytes)
{
seek (pos() + nBytes);
}
/// Returns number of bytes remaining in the write buffer.
inline ostream::size_type ostream::remaining (void) const
{
return (size() - pos());
}
/// Returns \c true if the write pointer is aligned on \p grain
inline bool ostream::aligned (size_type grain) const
{
assert (uintptr_t(begin()) % grain == 0 && "Streams should be attached aligned at the maximum element grain to avoid bus errors.");
return (pos() % grain == 0);
}
/// Returns the number of bytes to skip to be aligned on \p grain.
inline ostream::size_type ostream::align_size (size_type grain) const
{
return (Align (pos(), grain) - pos());
}
/// Writes the contents of \p buf into the stream as a raw dump.
inline void ostream::write (const cmemlink& buf)
{
write (buf.begin(), buf.size());
}
/// Writes type T into the stream via a direct pointer cast.
template <typename T>
inline void ostream::iwrite (const T& v)
{
assert (aligned (alignof (v)));
#ifdef WANT_STREAM_BOUNDS_CHECKING
verify_remaining ("write", typeid(v).name(), sizeof(T));
#else
assert (remaining() >= sizeof(T));
#endif
*reinterpret_cast<T*>(ipos()) = v;
SetPos (pos() + sizeof(T));
}
#define OSTREAM_OPERATOR(type) \
inline ostream& operator<< (ostream& os, type v) { os.iwrite(v); return (os); }
template <typename T>
OSTREAM_OPERATOR(T*)
OSTREAM_OPERATOR(int8_t)
OSTREAM_OPERATOR(uint8_t)
OSTREAM_OPERATOR(int16_t)
OSTREAM_OPERATOR(uint16_t)
OSTREAM_OPERATOR(int32_t)
OSTREAM_OPERATOR(uint32_t)
OSTREAM_OPERATOR(float)
OSTREAM_OPERATOR(double)
OSTREAM_OPERATOR(wchar_t)
#if SIZE_OF_BOOL == SIZE_OF_CHAR
OSTREAM_OPERATOR(bool)
#else
inline ostream& operator<< (ostream& os, bool v)
{ os.iwrite (uint8_t(v)); return (os); }
#endif
#if HAVE_THREE_CHAR_TYPES
OSTREAM_OPERATOR(char)
#endif
#if HAVE_INT64_T
OSTREAM_OPERATOR(int64_t)
OSTREAM_OPERATOR(uint64_t)
#endif
#if SIZE_OF_LONG == SIZE_OF_INT
OSTREAM_OPERATOR(long)
OSTREAM_OPERATOR(unsigned long)
#endif
#if HAVE_LONG_LONG && (!HAVE_INT64_T || SIZE_OF_LONG_LONG > 8)
OSTREAM_OPERATOR(long long)
OSTREAM_OPERATOR(unsigned long long)
#endif
} // namespace ustl
#endif
|
