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); }