bool File::seek(int64 offset, int whence /* = SEEK_SET */) {
if (whence != SEEK_CUR) {
throw NotSupportedException(__func__, "cannot seek other than SEEK_CUR");
}
if (offset < 0) {
throw NotSupportedException(__func__, "cannot seek backwards");
}
if (offset > 0) {
int64 avail = m_writepos - m_readpos;
assert(avail >= 0);
if (avail >= offset) {
m_readpos += offset;
return true;
}
if (avail > 0) {
m_readpos += avail;
offset -= avail;
}
while (offset) {
char tmp[1024];
int64 nread = offset > (int64)sizeof(tmp) ? (int64)sizeof(tmp) : offset;
nread = readImpl(tmp, nread);
if (nread <= 0) {
return false;
}
offset -= nread;
}
}
return true;
}
int64 File::print() {
int64 total = 0;
while (true) {
char buffer[1024];
int64 len = readImpl(buffer, 1024);
if (len == 0) break;
total += len;
g_context->write(buffer, len);
}
return total;
}
int SerialChannelImpl::readImpl(char* pBuffer, std::size_t length)
{
if (0 == length) return 0;
std::string buf;
readImpl(buf, length);
std::size_t len = length;
if (buf.size() < length) len = buf.size();
strncpy(pBuffer, buf.c_str(), len);
return (int) len;
}
int File::getc() {
if (m_writepos > m_readpos) {
m_position++;
return m_buffer[m_readpos++] & 0xff;
}
char buffer[1];
int64 len = readImpl(buffer, 1);
if (len != 1) {
return EOF;
}
m_position += len;
return (int)(unsigned char)buffer[0];
}
void SerialPort::readBuffer()
{
if (!isOpenImpl()) throw Poco::IllegalStateException("Port is not open");
_cur = _end = _buffer.begin();
int n = readImpl(_cur, _buffer.size());
if (n >= 0)
{
_end += n;
if (_logger.debug())
{
_logger.dump(format("Received %d byte(s)", n), _cur, n, Poco::Message::PRIO_DEBUG);
}
}
else throw Poco::IOException("serial port read error");
}
void ThriftBuffer::read(char *data, int len) {
auto const avail = m_pEnd - m_p;
if (avail < 0) not_reached();
// still enough
if (avail >= len) {
if (data) memcpy(data, m_p, len);
if ((m_p += len) > m_pSafe) m_safe = false;
return;
}
if (data) memcpy(data, m_p, avail);
len -= avail;
data += avail;
while (true) {
String ret = readImpl();
if (ret.empty()) {
throwError("unable to read enough bytes",INVALID_DATA);
}
const char *rdata = ret.data();
int rsize = ret.size();
if (rsize >= len) {
if (data) memcpy(data, rdata, len);
rsize -= len;
if (rsize) {
memcpy(m_buf, rdata + len, rsize);
m_pEnd = m_buf + rsize;
} else {
m_pEnd = m_buf;
}
m_pSafe = m_pEnd - sizeof(int64_t) - 1;
m_p = m_buf;
if (m_p > m_pSafe) m_safe = false;
return; // done
}
if (data) memcpy(data, rdata, rsize);
len -= rsize;
data += rsize;
}
}
String File::read(int64 length) {
if (length <= 0) {
raise_notice("Invalid length %lld", length);
return "";
}
String s = String(length, ReserveString);
char *ret = s.mutableSlice().ptr;
int64 copied = 0;
int64 avail = m_writepos - m_readpos;
while (avail < length && !eof()) {
if (m_buffer == NULL) {
m_buffer = (char *)malloc(CHUNK_SIZE);
}
if (avail > 0) {
memcpy(ret + copied, m_buffer + m_readpos, avail);
copied += avail;
length -= avail;
}
m_writepos = readImpl(m_buffer, CHUNK_SIZE);
m_readpos = 0;
avail = m_writepos - m_readpos;
if (avail == 0 || m_nonblocking) {
// For nonblocking mode, temporary out of data.
break;
}
}
avail = m_writepos - m_readpos;
if (avail > 0) {
int64 n = length < avail ? length : avail;
memcpy(ret + copied, m_buffer + m_readpos, n);
m_readpos += n;
copied += n;
}
m_position += copied;
return s.setSize(copied);
}
String File::readRecord(CStrRef delimiter, int64 maxlen /* = 0 */) {
if (eof() && m_writepos == m_readpos) {
return empty_string;
}
if (maxlen <= 0 || maxlen > CHUNK_SIZE) {
maxlen = CHUNK_SIZE;
}
int64 avail = m_writepos - m_readpos;
if (m_buffer == NULL) {
m_buffer = (char *)malloc(CHUNK_SIZE * 3);
}
if (avail < maxlen && !eof()) {
assert(m_writepos + maxlen - avail <= CHUNK_SIZE * 3);
m_writepos += readImpl(m_buffer + m_writepos, maxlen - avail);
maxlen = m_writepos - m_readpos;
}
if (m_readpos >= CHUNK_SIZE) {
memcpy(m_buffer, m_buffer + m_readpos, m_writepos - m_readpos);
m_writepos -= m_readpos;
m_readpos = 0;
}
int64 toread;
const char *e;
bool skip = false;
if (delimiter.empty()) {
toread = maxlen;
} else {
if (delimiter.size() == 1) {
e = (const char *)memchr(m_buffer + m_readpos, delimiter.charAt(0),
m_writepos - m_readpos);
} else {
int64 pos = string_find(m_buffer + m_readpos, m_writepos - m_readpos,
delimiter.data(), delimiter.size(), 0, true);
if (pos >= 0) {
e = m_buffer + m_readpos + pos;
} else {
e = NULL;
}
}
if (!e) {
toread = maxlen;
} else {
toread = e - m_buffer - m_readpos;
skip = true;
}
}
if (toread > maxlen && maxlen > 0) {
toread = maxlen;
}
if (toread >= 0) {
String s = String(toread, ReserveString);
char *buf = s.mutableSlice().ptr;
if (toread) {
memcpy(buf, m_buffer + m_readpos, toread);
}
m_readpos += toread;
if (skip) {
m_readpos += delimiter.size();
m_position += delimiter.size();
}
return s.setSize(toread);
}
return empty_string;
}
String File::readLine(int64 maxlen /* = 0 */) {
size_t current_buf_size = 0;
size_t total_copied = 0;
char *ret = NULL;
for (;;) {
int64 avail = m_writepos - m_readpos;
if (avail > 0) {
int64 cpysz = 0;
bool done = false;
char *readptr = m_buffer + m_readpos;
const char *eol;
const char *cr;
const char *lf;
cr = (const char *)memchr(readptr, '\r', avail);
lf = (const char *)memchr(readptr, '\n', avail);
if (cr && lf != cr + 1 && !(lf && lf < cr)) {
/* mac */
eol = cr;
} else if ((cr && lf && cr == lf - 1) || (lf)) {
/* dos or unix endings */
eol = lf;
} else {
eol = cr;
}
if (eol) {
cpysz = eol - readptr + 1;
done = true;
} else {
cpysz = avail;
}
if (maxlen > 0 && maxlen <= cpysz) {
cpysz = maxlen;
done = true;
}
current_buf_size += cpysz + 1;
if (ret) {
ret = (char *)realloc(ret, current_buf_size);
} else {
ret = (char *)malloc(current_buf_size);
}
memcpy(ret + total_copied, readptr, cpysz);
m_position += cpysz;
m_readpos += cpysz;
maxlen -= cpysz;
total_copied += cpysz;
if (done) {
break;
}
} else if (eof()) {
break;
} else {
if (m_buffer == NULL) {
m_buffer = (char *)malloc(CHUNK_SIZE);
}
m_writepos = readImpl(m_buffer, CHUNK_SIZE);
m_readpos = 0;
if (m_writepos - m_readpos == 0) {
break;
}
}
}
if (total_copied == 0) {
assert(ret == NULL);
return String();
}
ret[total_copied] = '\0';
return String(ret, total_copied, AttachString);
}
char SerialChannelImpl::readImpl()
{
char readBuf = 0;
readImpl(&readBuf, 1);
return readBuf;
}
DynamicConfig::ValueNULL DynamicConfig::read(const Key &key)
{
return readImpl(t_, key);
}
