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
|
#include "StarIODevice.hpp"
#include "StarMathCommon.hpp"
#include "StarFormat.hpp"
namespace Star {
IODevice::IODevice(IOMode mode) {
m_mode = mode;
}
IODevice::~IODevice() {
close();
}
void IODevice::resize(StreamOffset) {
throw IOException("resize not supported");
}
void IODevice::readFull(char* data, size_t len) {
size_t r = read(data, len);
if (r < len) {
if (atEnd())
throw EofException("Failed to read full buffer in readFull, eof reached.");
else
throw IOException("Failed to read full buffer in readFull");
}
data += r;
len -= r;
}
void IODevice::writeFull(char const* data, size_t len) {
size_t r = write(data, len);
if (r < len) {
if (atEnd())
throw EofException("Failed to write full buffer in writeFull, eof reached.");
else
throw IOException("Failed to write full buffer in writeFull");
}
data += r;
len -= r;
}
void IODevice::open(IOMode mode) {
if (mode != m_mode)
throw IOException::format("Cannot reopen device '{}", deviceName());
}
void IODevice::close() {
m_mode = IOMode::Closed;
}
void IODevice::sync() {}
String IODevice::deviceName() const {
return strf("IODevice <{}>", (void*)this);
}
bool IODevice::atEnd() {
return pos() >= size();
}
StreamOffset IODevice::size() {
try {
StreamOffset storedPos = pos();
seek(0, IOSeek::End);
StreamOffset size = pos();
seek(storedPos);
return size;
} catch (IOException const& e) {
throw IOException("Cannot call size() on IODevice", e);
}
}
size_t IODevice::readAbsolute(StreamOffset readPosition, char* data, size_t len) {
StreamOffset storedPos = pos();
seek(readPosition);
size_t ret = read(data, len);
seek(storedPos);
return ret;
}
size_t IODevice::writeAbsolute(StreamOffset writePosition, char const* data, size_t len) {
StreamOffset storedPos = pos();
seek(writePosition);
size_t ret = write(data, len);
seek(storedPos);
return ret;
}
void IODevice::readFullAbsolute(StreamOffset readPosition, char* data, size_t len) {
while (len > 0) {
size_t r = readAbsolute(readPosition, data, len);
if (r == 0)
throw IOException("Failed to read full buffer in readFullAbsolute");
readPosition += r;
data += r;
len -= r;
}
}
void IODevice::writeFullAbsolute(StreamOffset writePosition, char const* data, size_t len) {
while (len > 0) {
size_t r = writeAbsolute(writePosition, data, len);
if (r == 0)
throw IOException("Failed to write full buffer in writeFullAbsolute");
writePosition += r;
data += r;
len -= r;
}
}
ByteArray IODevice::readBytes(size_t size) {
if (!size)
return {};
ByteArray p;
p.resize(size);
readFull(p.ptr(), size);
return p;
}
void IODevice::writeBytes(ByteArray const& p) {
writeFull(p.ptr(), p.size());
}
ByteArray IODevice::readBytesAbsolute(StreamOffset readPosition, size_t size) {
if (!size)
return {};
ByteArray p;
p.resize(size);
readFullAbsolute(readPosition, p.ptr(), size);
return p;
}
void IODevice::writeBytesAbsolute(StreamOffset writePosition, ByteArray const& p) {
writeFullAbsolute(writePosition, p.ptr(), p.size());
}
void IODevice::setMode(IOMode m) {
m_mode = m;
}
IODevice::IODevice(IODevice const& rhs) {
m_mode = rhs.mode();
}
IODevice& IODevice::operator=(IODevice const& rhs) {
m_mode = rhs.mode();
return *this;
}
}
|