FileStreamBuf::pos_type FileStreamBuf::seekoff(off_type offset, std::ios_base::seekdir whence, std::ios_base::openmode mode)
{
if(!usrFile || (mode&std::ios_base::out))
return traits_type::eof();
pos_type pos = traits_type::eof();
switch(whence)
{
case std::ios_base::beg:
if(offset == off_type(alureInt64(offset)))
pos = pos_type(fio.seek(usrFile, offset, SEEK_SET));
break;
case std::ios_base::cur:
offset -= off_type(egptr()-gptr());
if(offset == off_type(alureInt64(offset)))
pos = pos_type(fio.seek(usrFile, offset, SEEK_CUR));
break;
case std::ios_base::end:
if(offset == off_type(alureInt64(offset)))
pos = pos_type(fio.seek(usrFile, offset, SEEK_END));
break;
default:
break;
}
if(pos >= 0)
setg(0, 0, 0);
return pos;
}
std::streampos FileStreamBuf::seekoff(std::streamoff off, std::ios::seekdir dir, std::ios::openmode mode)
{
if (_fd == -1 || !(getMode() & mode))
return -1;
if (getMode() & std::ios::out)
sync();
std::streamoff adj;
if (mode & std::ios::in)
adj = static_cast<std::streamoff>(egptr() - gptr());
else
adj = 0;
resetBuffers();
int whence = SEEK_SET;
if (dir == std::ios::cur)
{
whence = SEEK_CUR;
off -= adj;
}
else if (dir == std::ios::end)
{
whence = SEEK_END;
}
_pos = lseek(_fd, off, whence);
return _pos;
}
int filebuf::sync()
{
// char* ptr = cur_ptr();
if (pptr() > pbase())
if (do_flush()) return EOF;
if (gptr() != egptr()) {
streampos delta = gptr() - egptr();
if (in_backup())
delta -= eGptr() - Gbase();
if (sys_seek(delta, ios::cur) == EOF)
return EOF;
}
// FIXME: Cleanup - can this be shared?
// setg(base(), ptr, ptr);
return 0;
}
//read to buffer in place (apart from data already buffered)
std::streamsize istreambuf::xsgetn(char *buffer, std::streamsize n) {
LOG("bz::istreambuf::xsgetn (" << n << ")");
//try to satisfy request from buffered input
std::streamsize available = egptr() - gptr();
int read = (available >= n)? n : available;
if (read) {
std::copy(gptr(), gptr() + read, buffer);
gbump(read);
}
//inflate the rest directly into the user's buffer
if (read < n) {
if (end) {
LOG("\tend of stream (EOF)");
//signal the stream has reached it's end
return eof;
}
z_strm->next_out = buffer + read;
z_strm->avail_out = n - read;
if (0 < z_strm->avail_in) {
decompress();
}
while (!(end || 0 == z_strm->avail_out)) {
read_decompress();
}
underflow();
}
return n;
}
ConstrainedFileStreamBuf::pos_type ConstrainedFileStreamBuf::seekoff(off_type offset, std::ios_base::seekdir whence, std::ios_base::openmode mode)
{
if((mode&std::ios_base::out) || !(mode&std::ios_base::in))
return traits_type::eof();
// new file position, relative to mOrigin
std::streampos newPos = traits_type::eof();
switch(whence)
{
case std::ios_base::beg:
newPos = offset + mStart;
break;
case std::ios_base::cur:
newPos = offset + mFile->tellg() - (egptr()-gptr());
break;
case std::ios_base::end:
newPos = offset + mEnd;
break;
default:
return traits_type::eof();
}
if(newPos < mStart || newPos > mEnd)
return traits_type::eof();
if(!mFile->seekg(newPos))
return traits_type::eof();
// Clear read pointers so underflow() gets called on the next read attempt.
setg(0, 0, 0);
return newPos - mStart;
}
std::streambuf::pos_type
DataIStreamBuf::seekoff(off_type off, std::ios_base::seekdir way, std::ios_base::openmode which)
{
pos_type ret = pos_type(off_type(-1));
char* begin = eback();
char* cur = gptr();
char* end = egptr();
off_type newOff = 0;
if (way == std::ios_base::cur)
{
newOff = cur - begin;
}
else if (way == std::ios_base::end)
{
newOff = end - begin;
}
if (newOff + off >= 0 && end - begin >= newOff + off)
{
setg(begin, begin + newOff + off, end);
ret = pos_type(newOff);
}
return ret;
}
CNcbiStreambuf* CRWStreambuf::setbuf(CT_CHAR_TYPE* s, streamsize m)
{
if (!s && !m)
return this;
if (gptr() && gptr() < egptr())
ERR_POST_X(3,Critical << "CRWStreambuf::setbuf(): Read data pending");
if (pbase() && pptr() > pbase())
ERR_POST_X(4,Critical << "CRWStreambuf::setbuf(): Write data pending");
delete[] m_pBuf;
m_pBuf = 0;
size_t n = (size_t) m;
if ( !n ) {
_ASSERT(kDefaultBufSize > 1);
n = (size_t) kDefaultBufSize << (m_Reader && m_Writer ? 1 : 0);
}
if ( !s )
s = n == 1 ? &x_Buf : (m_pBuf = new CT_CHAR_TYPE[n]);
if ( m_Reader ) {
m_BufSize = n == 1 ? 1 : n >> (m_Reader && m_Writer ? 1 : 0);
m_ReadBuf = s;
} else {
int strstreambuf::overflow(int c)
{
/*
- if no room and not dynamic, give error
- if no room and dynamic, allocate (1 more or min) and store
- if and when the buffer has room, store c if not EOF
*/
int temp;
if (pptr() >= epptr())
{
if (!x_dynamic)
return EOF;
if (strstreambuf::doallocate()==EOF)
return EOF;
if (!epptr()) // init if first time through
{
setp(base() + (egptr() - eback()),ebuf());
}
else
{
temp = pptr()-pbase();
setp(pbase(),ebuf());
pbump(temp);
}
}
if (c!=EOF)
{
*pptr() = (char)c;
pbump(1);
}
return(1);
}
// input functions
int_type underflow(
)
{
if (gptr() < egptr())
{
return static_cast<unsigned char>(*gptr());
}
int num_put_back = static_cast<int>(gptr() - eback());
if (num_put_back > max_putback)
{
num_put_back = max_putback;
}
// copy the putback characters into the putback end of the in_buffer
std::memmove(in_buffer+(max_putback-num_put_back), gptr()-num_put_back, num_put_back);
if (read_echoing_select(fd, fd_printf))
return EOF;
int num = read(fd,in_buffer+max_putback, in_buffer_size-max_putback);
if (num <= 0)
{
// an error occurred or the connection is over which is EOF
return EOF;
}
// reset in_buffer pointers
setg (in_buffer+(max_putback-num_put_back),
in_buffer+max_putback,
in_buffer+max_putback+num);
return static_cast<unsigned char>(*gptr());
}
virtual pos_type seekoff(off_type offset, std::ios_base::seekdir whence, std::ios_base::openmode mode)
{
if((mode&std::ios_base::out) || !(mode&std::ios_base::in))
return traits_type::eof();
// new file position, relative to mOrigin
size_t newPos;
switch (whence)
{
case std::ios_base::beg:
newPos = offset;
break;
case std::ios_base::cur:
newPos = (mFile.tell() - mOrigin - (egptr() - gptr())) + offset;
break;
case std::ios_base::end:
newPos = mSize + offset;
break;
default:
return traits_type::eof();
}
if (newPos > mSize)
return traits_type::eof();
mFile.seek(mOrigin+newPos);
// Clear read pointers so underflow() gets called on the next read attempt.
setg(0, 0, 0);
return newPos;
}
int func_parsebuf::underflow()
{
retry:
if (gptr() < egptr())
return *gptr();
if (gptr() != (char*)NewLine+1) {
// Get buffer was line buffer. Move to following '\n'.
setg((char*)NewLine, (char*)NewLine, (char*)NewLine+1);
return *gptr();
}
if (backed_up_to_newline)
// Get buffer was '\n' preceding current line. Move to current line.
backed_up_to_newline = 0;
else {
// Get buffer was '\n' following current line. Read new line.
if (buf_start) free(buf_start);
char *str = (*read_func)(arg);
buf_start = str;
if (str == NULL)
return EOF;
// Initially, _line_length == -1, so pos_at_line_start becomes 0.
pos_at_line_start += _line_length + 1;
_line_length = strlen(str);
buf_end = str + _line_length;
__line_number++;
}
setg(buf_start, buf_start, buf_end);
goto retry;
}
int castorstreambuf::underflow()
{
if ( gptr() && ( gptr()<egptr() ) )
return * reinterpret_cast<unsigned char *>(gptr());
if ( !(mode & std::ios::in) || !opened) return EOF;
// Josuttis' implementation of inbuf
int n_putback = gptr() - eback();
if ( n_putback > 4) n_putback = 4;
memcpy( buffer + (4 - n_putback), gptr() - n_putback, n_putback);
#ifdef CASTOR_USE
signed int num = rfio_read( file_, buffer+4, bufferSize-4);
#else
signed int num = -1;
#endif
if (num <= 0) return EOF;
// reset buffer pointers
setg( buffer + (4 - n_putback), // beginning of putback area
buffer + 4, // read position
buffer + 4 + num); // end of buffer
// return next character
return * reinterpret_cast<unsigned char *>( gptr());
}
std::streamsize buf_base::load()
{
lzma_.next_out = reinterpret_cast<uint8_t *>(&buf_[0]);
if (lzma_.total_out > 0)
{
lzma_.avail_out = buf_.size();
lzma_.total_out = 0;
lzma_ret retval = lzma_code(&lzma_, action_);
if (retval != LZMA_OK && retval != LZMA_STREAM_END) throw compress_error{"Compression failed with liblzma error " + util::t2s(retval)};
if (lzma_.total_out > 0) goto loaded; // Valid use case?
}
lzma_.next_out = reinterpret_cast<uint8_t *>(&buf_[0]);
while (lzma_.total_out == 0)
{
lzma_.total_in = 0;
lzma_.next_in = reinterpret_cast<uint8_t *>(&inbuf_[0]);
std::streamsize insize = fill();
if (insize == 0) action_ = LZMA_FINISH;
lzma_.avail_in = insize;
lzma_.avail_out = buf_.size();
lzma_ret retval = lzma_code(&lzma_, action_);
//std::cout << "Got " << lzma_.total_in << " bytes, compressed to " << lzma_.total_out << "\n";
if (retval == LZMA_STREAM_END) break;
else if (retval != LZMA_OK) throw compress_error{"Compression failed with liblzma error " + util::t2s(retval)};
}
loaded: char *start = &buf_[0], *end = start + lzma_.total_out;
pos_ += egptr() - eback();
setg(start, start, end);
return lzma_.total_out;
}
std::streamsize memrdbuf::load()
{
lzma_.next_out = reinterpret_cast<uint8_t *>(&buf_[0]);
if (lzma_.total_out > 0)
{
lzma_.avail_out = buf_.size();
lzma_.total_out = 0;
lzma_ret retval = lzma_code(&lzma_, action_);
if (retval != LZMA_OK && retval != LZMA_STREAM_END) throw compress_error{"Compression failed with liblzma error " + util::t2s(retval)};
if (lzma_.total_out > 0) goto loaded;
}
lzma_.next_out = reinterpret_cast<uint8_t *>(&buf_[0]);
while (lzma_.total_out == 0)
{
if (lzma_.avail_in == 0) action_ = LZMA_FINISH;
lzma_.avail_out = buf_.size();
lzma_ret retval = lzma_code(&lzma_, action_);
if (retval == LZMA_STREAM_END) break;
else if (retval != LZMA_OK) throw compress_error{"Compression failed with liblzma error " + util::t2s(retval)};
}
loaded: char *start = &buf_[0], *end = start + lzma_.total_out;
pos_ += egptr() - eback();
setg(start, start, end);
return lzma_.total_out;
}
CT_INT_TYPE CConn_Streambuf::underflow(void)
{
_ASSERT(gptr() >= egptr());
if (!m_Conn)
return CT_EOF;
// flush output buffer, if tied up to it
if (m_Tie && x_sync() != 0)
return CT_EOF;
#ifdef NCBI_COMPILER_MIPSPRO
if (m_MIPSPRO_ReadsomeGptrSetLevel && m_MIPSPRO_ReadsomeGptr != gptr())
return CT_EOF;
m_MIPSPRO_ReadsomeGptr = (CT_CHAR_TYPE*)(-1L);
#endif /*NCBI_COMPILER_MIPSPRO*/
// read from connection
size_t n_read;
m_Status = CONN_Read(m_Conn, m_ReadBuf, m_BufSize,
&n_read, eIO_ReadPlain);
_ASSERT(n_read <= m_BufSize);
if (!n_read) {
_ASSERT(m_Status != eIO_Success);
if (m_Status != eIO_Closed)
ERR_POST_X(8, x_Message("underflow(): CONN_Read() failed"));
return CT_EOF;
}
// update input buffer with the data just read
x_GPos += (CT_OFF_TYPE) n_read;
setg(m_ReadBuf, m_ReadBuf, m_ReadBuf + n_read);
return CT_TO_INT_TYPE(*m_ReadBuf);
}
void IOBuffer::beginRead()
{
if(_ioDevice == 0 || _ioDevice->isReading())
return;
if( ! _ibuffer)
_ibuffer = new char[_ibufferSize];
std::size_t putback = _pbmax;
std::size_t leftover = 0;
// Keep chars for putback
if( gptr() )
{
putback = std::min<std::size_t>(gptr() - eback(), _pbmax);
char* to = _ibuffer + _pbmax - putback;
char* from = gptr() - putback;
leftover = egptr() - gptr();
std::memmove(to, from, putback + leftover);
}
std::size_t used = _pbmax + leftover;
if(_ibufferSize == used)
throw std::logic_error(PT_ERROR_MSG("IOBuffer is full"));
_ioDevice->beginRead(_ibuffer + used, _ibufferSize - used);
setg(_ibuffer + (_pbmax - putback), // start of get area
_ibuffer + used, // gptr position
_ibuffer + used); // end of get area
}
void BinaryStreamBuffer::reset()
{
size_t readEndPos = egptr() - eback();
setg(buffer(), buffer(), buffer() + readEndPos);
setp(buffer(), end());
}
std::streambuf::int_type buf_base::underflow()
{
std::streamsize loadsize = load();
if (gptr() >= egptr() && loadsize == 0) return traits_type::eof();
//std::cout << "\033[31mLoaded " << loadsize << " bytes, position " << pos_ << "\033[m\n";
return traits_type::to_int_type(*gptr());
}
std::streamsize sockstreambuf::
xsgetn (
char_type* s,
std::streamsize n
)
{
std::streamsize temp = n;
while (n > 0)
{
int num = static_cast<int>(egptr() - gptr());
if (num >= n)
{
// copy data from our buffer
std::memcpy(s, gptr(), static_cast<size_t>(n));
gbump(static_cast<int>(n));
return temp;
}
// read more data into our buffer
if (num == 0)
{
if (underflow() == EOF)
break;
continue;
}
// copy all the data from our buffer
std::memcpy(s, gptr(), num);
n -= num;
gbump(num);
s += num;
}
return temp-n;
}
int gzstreambuf::underflow() { // used for input buffer only
if (gptr() && (gptr() < egptr()))
return * reinterpret_cast<unsigned char *>(gptr());
if (! (mode & std::ios::in) || !opened)
return EOF;
// Josuttis' implementation of inbuf
int n_putback = (int)(gptr() - eback());
if (n_putback > 4)
n_putback = 4;
memcpy(buffer + (4 - n_putback), gptr() - n_putback, n_putback);
int num = gzread(file, buffer+4, bufferSize-4);
if (num <= 0) // ERROR or EOF
{
if (gzeof(file))
return EOF;
handle_gzerror();
}
// reset buffer pointers
setg(buffer + (4 - n_putback), // beginning of putback area
buffer + 4, // read position
buffer + 4 + num); // end of buffer
// return next character
return * reinterpret_cast<unsigned char *>(gptr());
}
ChunkedReader::int_type ChunkedReader::underflow()
{
log_trace("ChunkedReader::underflow");
while (_state != 0
&& gptr() == egptr()
&& _ib->sgetc() != traits_type::eof())
{
(this->*_state)();
}
if (_state == 0)
{
log_debug("end of chunked data reached");
return traits_type::eof();
}
if (_ib->sgetc() == traits_type::eof())
{
log_debug("end of input stream");
_state = 0;
return traits_type::eof();
}
log_debug("not at eof - return " << charToPrint(*gptr()));
return *gptr();
}
virtual int underflow() { // used for input buffer only
if (gptr() && (gptr() < egptr())) {
return *reinterpret_cast<unsigned char *>(gptr());
}
if (!(mode_ & std::ios::in) || !opened_) {
return EOF;
}
// Josuttis' implementation of inbuf
int n_putback = gptr() - eback();
if (n_putback > 4) {
n_putback = 4;
}
memcpy(buffer_ + (4 - n_putback), gptr() - n_putback, n_putback);
int num = gzread(file_, buffer_ + 4, bufferSize - 4);
if (num <= 0) { // ERROR or EOF
return EOF;
}
// reset buffer pointers
setg(buffer_ + (4 - n_putback), // beginning of putback area
buffer_ + 4, // read position
buffer_ + 4 + num); // end of buffer
// return next character
return *reinterpret_cast<unsigned char *>(gptr());
}
std::ostream &
StrStreambuf::dumpInfo(
std::ostream & dest,
const char * prefix,
bool showVer
)
{
if( showVer )
dest << StrStreambuf::getClassName() << ":\n"
<< StrStreambuf::getVersion() << '\n';
dest << prefix << "length: " << plen() << '\n'
#if defined( STLUTILS_HAVE_STRBUF_BASE )
<< prefix << "base(): " << (void *) base() << '\n'
#endif
#if defined( STLUTILS_HAVE_STRBUF_EBUF )
<< prefix << "ebuf(): " << (void *) ebuf() << '\n'
#endif
<< prefix << "pbase(): " << (void *) pbase() << '\n'
<< prefix << "pptr(): " << (void *) pptr() << '\n'
<< prefix << "epptr(): " << (void *) epptr() << '\n'
<< prefix << "eback(): " << (void *) eback() << '\n'
<< prefix << "gptr(): " << (void *) gptr() << '\n'
<< prefix << "egptr(): " << (void *) egptr() << '\n'
<< prefix << "n - b: " << pptr() - pbase() << '\n'
<< prefix << "string: '" << (void *)cstr() << "'\n"
<< prefix << "pbase(): " << (void *) pbase() << '\n'
<< prefix << "pptr(): " << (void *) pptr() << '\n'
<< prefix << "length: " << plen() << '\n'
<< prefix << "size: " << psize() << '\n'
;
return( dest );
}
void
StrStreambuf::readPrep( void )
{
if( egptr() < pptr() ) {
setg( gptr(), gptr(), pptr() );
}
}
int strstreambuf::doallocate()
{
char * bptr;
int size;
size = __max(x_bufmin,blen() + __max(x_bufmin,1));
long offset = 0;
if (x_alloc)
{
bptr = (char*)(*x_alloc)(size);
}
else
{
bptr = _new_crt char[size];
}
if (!bptr)
return EOF;
if (blen())
{
memcpy(bptr, base(), blen());
offset = bptr - base(); // amount to adjust pointers by
}
if (x_free)
{
(*x_free)(base());
}
else
{
delete base();
}
setb(bptr,bptr+size,0); // we handle deallocation
// adjust get/put pointers too, if necessary
if (offset)
if (egptr())
{
setg(eback()+offset,gptr()+offset,egptr()+offset);
}
if (epptr())
{
size = pptr() - pbase();
setp(pbase()+offset,epptr()+offset);
pbump(size);
}
return(1);
}
/**
* Removes @c n characters from the beginning of the input sequence.
*
* @throws std::length_error If <tt>n > size()</tt>.
*/
void consume(std::size_t n)
{
if (egptr() < pptr())
setg(&buffer_[0], gptr(), pptr());
if (gptr() + n > pptr())
n = pptr() - gptr();
gbump(static_cast<int>(n));
}
int_type underflow()
{
// if there is still data, then return it
if ( gptr() < egptr() )
return static_cast<int_type>(*uptr());
assert ( gptr() == egptr() );
uint64_t const symsleft = ((n+(addterm?1:0))-symsread);
if ( symsleft == 0 )
return traits_type::eof();
uint64_t const lasttermblock = addterm ? ((symsleft <= buffersize)?1:0) : 0;
uint64_t const symstoread = std::min(symsleft-lasttermblock,buffersize);
uint64_t const wordstoread = (symstoread * b + (bitsperentity-1))/bitsperentity;
uint64_t const bytestoread = wordstoread * (bitsperentity/8);
// load packed data into memory
stream.read ( reinterpret_cast<char *>(C.begin()) , bytestoread );
if ( stream.gcount() != static_cast<int64_t>(bytestoread) )
{
::libmaus2::exception::LibMausException se;
se.getStream() << "PacDecoderBuffer::underflow() failed to read " << bytestoread << " bytes." << std::endl;
se.finish();
throw se;
}
// decode array
::libmaus2::bitio::ArrayDecode::decodeArray(
C.begin(), reinterpret_cast<uint8_t *>(buffer.begin()), symstoread, 2
);
if ( addterm )
for ( uint64_t i = 0; i < symstoread; ++i )
buffer[i] += 1;
if ( lasttermblock )
buffer[symstoread] = 0;
setg(buffer.begin(),buffer.begin(),buffer.begin()+symstoread+lasttermblock);
symsread += symstoread+lasttermblock;
return static_cast<int_type>(*uptr());
}
int strstreambuf::underflow()
{
char * tptr;
if (gptr() >= egptr())
{
// try to grow get area if we can...
if (egptr()<pptr())
{
tptr = base() + (gptr()-eback());
setg(base(),tptr,pptr());
}
if (gptr() >= egptr())
return EOF;
}
return (int)(unsigned char) *gptr();
}
stringbuf::pos_type stringbuf::seekoff(off_type __off, ios_base::seekdir __dir, ios_base::openmode __mode /* = ios_base::in | ios_base::out */)
{
__mode &= __M_mode;
bool __imode = (__mode & ios_base::in) != 0;
bool __omode = (__mode & ios_base::out) != 0;
if ((__imode == false) && (__omode == false)) return pos_type(-1);
if ((__imode && (gptr() == 0)) || (__omode && (pptr() == 0))) return pos_type(-1);
STL_ASSERT((eback() <= gptr()) && (gptr() <= egptr()) && (pbase() <= pptr()) && (pptr() <= epptr()));
streamoff __newoff;
switch (__dir)
{
case ios_base::beg:
__newoff = 0;
break;
case ios_base::end:
__newoff = __M_str.size();
break;
case ios_base::cur:
__newoff = __imode ? (gptr() - eback()) : (pptr() - pbase());
if (__off == 0) return pos_type(__newoff);
break;
default:
return pos_type(-1);
}
__off += __newoff;
if (__imode)
{
ptrdiff_t __size = egptr() - eback();
if ((__off < 0) || (__off > __size)) return pos_type(-1);
setg(eback(), eback() + static_cast<ptrdiff_t>(__off), eback() + static_cast<ptrdiff_t>(__size));
}
if (__omode)
{
ptrdiff_t __size = epptr() - pbase();
if ((__off < 0) || (__off > __size)) return pos_type(-1);
setp(pbase(), pbase() + __size);
pbump(static_cast<int>(__off));
}
return pos_type(__off);
}
int_type underflow()
{
// if there is still data, then return it
if ( gptr() < egptr() )
return static_cast<int_type>(*(reinterpret_cast<uint8_t const *>(gptr())));
assert ( gptr() == egptr() );
// number of bytes for putback buffer
uint64_t const putbackcopy = std::min(
static_cast<uint64_t>(gptr() - eback()),
putbackspace
);
// copy bytes
#if 0
std::copy(
gptr()-putbackcopy,
gptr(),
buffer.begin() + putbackspace - putbackcopy
);
#endif
std::memmove(
buffer.begin() + putbackspace - putbackcopy,
gptr()-putbackcopy,
putbackcopy
);
// load data
uint64_t const uncompressedsize = stream.readPart(
buffer.begin()+putbackspace,
buffer.size()-putbackspace
);
// set buffer pointers
setg(
buffer.begin()+putbackspace-putbackcopy,
buffer.begin()+putbackspace,
buffer.begin()+putbackspace+uncompressedsize
);
if ( uncompressedsize )
return static_cast<int_type>(*(reinterpret_cast<uint8_t const *>(gptr())));
else
return traits_type::eof();
}
