LogEntryBuffer::int_type LogEntryBuffer::overflow(int_type ch) {
if (traits_type::eof() == ch) {
return traits_type::eof();
}
auto size = pptr() - m_base;
if (!m_largeBuffer) {
m_largeBuffer.reset(new std::vector<char>(ACSDK_LOG_ENTRY_BUFFER_SMALL_BUFFER_SIZE * 2));
memcpy(m_largeBuffer->data(), m_base, size);
} else {
m_largeBuffer->resize(m_largeBuffer->size() * 2);
}
auto newBase = m_largeBuffer->data();
auto delta = newBase - m_base;
// -1 so there is always room to append a null terminator.
auto newEnd = newBase + m_largeBuffer->size() - 1;
setp(newBase + size, newEnd);
setg(newBase, gptr() + delta, newEnd);
m_base = newBase;
*pptr() = ch;
pbump(1);
return ch;
}
int FileOutputStreambuf::sync()
{
std::ptrdiff_t n = pptr() - pbase();
pbump(int(-n));
return std::fwrite(_buffer.get(), 1, n, _file.get()) != size_t(n) ? -1 : 0;
}
Socket::int_type Socket::overflow(int_type c) {
if(sync() == EOF)
return EOF;
*pbase() = c;
pbump(1);
return c;
}
virtual int overflow(int ch = EOF) {
std::string line = "";
for (char *cp = pbase(); cp < pptr(); cp++) {
if (*cp == '\n') {
// puts(line.c_str());
outputPrinted += line.length();
if (outputLimit > 0 && outputPrinted > outputLimit) {
error("excessive output printed");
}
line = "";
} else {
line += *cp;
}
}
if (line != "") {
// puts(line.c_str());
outputPrinted += line.length();
if (outputLimit > 0 && outputPrinted > outputLimit) {
error("excessive output printed");
}
}
setp(outBuffer, outBuffer + BUFFER_SIZE);
if (ch != EOF) {
outBuffer[0] = ch;
pbump(1);
}
return ch != EOF;
}
streambuf::int_type streambuf::overflow(streambuf::int_type c)
{
log_debug("streambuf::overflow");
if (pptr())
{
Stream::size_type N = pptr() - m_buffer; // bytes to write
Stream::size_type n = m_stream.write(m_buffer, N, false);
if (n <= 0)
return traits_type::eof();
if (n < N)
{
// there are bytes left - move them to the start of our buffer
memmove(m_buffer, m_buffer + n, N - n);
setp(m_buffer + N - n, m_buffer + m_bufsize);
}
else
setp(m_buffer, m_buffer + m_bufsize);
}
else
setp(m_buffer, m_buffer + m_bufsize);
if (c != traits_type::eof())
{
*pptr() = traits_type::to_char_type(c);
pbump(1);
}
return 0;
}
int rpcbuf::overflow(int c) {
if (!_opened || allocate() == EOF) {
return EOF;
}
if (c == EOF) {
finish_request();
}
if (rptr() == pbase() && pptr() >= epptr() && !expand_p()) {
error("rpcbuf::overflow: out of memory");
return EOF;
}
int nwrite = (rptr() >= pbase()) ? rptr() - pbase() : out_waiting();
int count = 0;
while (count < nwrite) {
int nsent = write(_fd, pbase() + count, nwrite - count);
if (nsent < 0) {
sys_error("rpcbuf::overflow: write");
return EOF;
}
count += nsent;
}
if (rptr() > pbase()) {
Memory::copy(rptr(), pbase(), pptr() - rptr());
rbump(-nwrite);
}
pbump(-nwrite);
if (c != EOF) {
sputc(c);
}
return zapeof(c);
}
mem_streambuf::int_type mem_streambuf::pbackfail( int_type c ) {
if ( !traits_type::eq_int_type( c, traits_type::eof() ) ) {
*pptr() = traits_type::to_char_type( c );
pbump( -1 );
}
return traits_type::to_int_type( *pptr() );
}
stringbuf::pos_type stringbuf::seekpos(pos_type __pos, 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);
const off_type __offset = __pos - pos_type(0);
if (__imode)
{
if ((__offset < 0) || (__offset > (egptr() - eback()))) return pos_type(-1);
setg(eback(), eback() + static_cast<ptrdiff_t>(__offset), egptr());
}
if (__omode)
{
if ((__offset < 0) || (size_t(__offset) > __M_str.size())) return pos_type(-1);
setp(__M_str.begin(), __M_str.end());
pbump(static_cast<int>(__offset));
}
return __pos;
}
std::streambuf::int_type Md5streambuf::overflow(
std::streambuf::int_type ch)
{
if (pptr() == 0)
{
// Ausgabepuffer ist leer - initialisieren
log_debug("initialize MD5");
cxxtools_MD5Init(context);
}
else
{
// konsumiere Zeichen aus dem Puffer
log_debug("process " << (pptr() - pbase()) << " bytes of data");
cxxtools_MD5Update(context,
(const unsigned char*)pbase(),
pptr() - pbase());
}
// setze Ausgabepuffer
setp(buffer, buffer + bufsize);
if (ch != traits_type::eof())
{
// das Zeichen, welches den overflow ausgelöst hat, stecken
// wir in den Puffer.
*pptr() = traits_type::to_char_type(ch);
pbump(1);
}
return 0;
}
strstreambuf::pos_type
strstreambuf::seekpos(pos_type __sp, ios_base::openmode __which)
{
off_type __p(-1);
bool pos_in = (__which & ios::in) != 0;
bool pos_out = (__which & ios::out) != 0;
if (pos_in || pos_out)
{
if (!((pos_in && gptr() == nullptr) || (pos_out && pptr() == nullptr)))
{
off_type newoff = __sp;
char* seekhigh = epptr() ? epptr() : egptr();
if (0 <= newoff && newoff <= seekhigh - eback())
{
char* newpos = eback() + newoff;
if (pos_in)
setg(eback(), newpos, _VSTD::max(newpos, egptr()));
if (pos_out)
{
// min(pbase, newpos), newpos, epptr()
off_type temp = epptr() - newpos;
setp(min(pbase(), newpos), epptr());
pbump(static_cast<int>((epptr() - pbase()) - temp));
}
__p = newoff;
}
}
}
return pos_type(__p);
}
std::streamsize xsputn(const char_type * s, std::streamsize n)
{
const char_type * end = s + n;
size_t c = std::min<size_t>(end - s, epptr() - pptr());
memcpy(pptr(), s, c);
pbump(static_cast<int>(c));
s += c;
if(s != end)
{
size_t c;
cur_->next = new Buffer;
cur_ = cur_->next;
for(;;)
{
c = std::min<size_t>(end - s, bufferSize);
memcpy(&cur_->data[0], s, c);
s += c;
if(s == end)
break;
cur_->next = new Buffer;
cur_ = cur_->next;
}
char * begin = &cur_->data[0];
std::streambuf::setp(begin + c, begin + bufferSize);
}
return n;
}
int sync() override
{
std::ptrdiff_t n = pptr() - pbase();
for (auto ptr = pbase(); ptr != pptr(); ptr++) {
CharT ch = *ptr;
if (ch == '\r' || ch == '\n') {
if (_lastc != ch && (_lastc == '\r' || _lastc == '\n')) {
ch = 0;
}
else {
_linebuffer.push_back(0);
auto now = std::chrono::system_clock::now();
auto in_time_t = std::chrono::system_clock::to_time_t(now);
std::basic_stringstream<CharT, TraitsT> ss;
ss << "[" << std::put_time(std::localtime(&in_time_t), "%Y-%m-%d %X") << "]:" << _linebuffer.data() << std::endl;
output_visualstudio(ss.str().c_str());
_linebuffer.clear();
}
}
else _linebuffer.push_back(ch);
_lastc = ch;
}
pbump(-n);
return 0;
}
/**
* Called when the internal buffer should be synchronized
* @return int
*/
int StreamBuf::sync()
{
// current buffer size
size_t size = pptr() - pbase();
// is this the error stream or the regular output stream?
if (_error)
{
// write to error (the zend_error() method is a varargs function,
// which means that we have to include a printf() like format as first
// parameter. We can not specify pbase() directly, because (1) it is
// not null terminated and (2) it could contain % signs and allow all
// sorts of buffer overflows.
zend_error(_error, "%.*s", (int)size, pbase());
}
else
{
// write to zend
zend_write(pbase(), size);
}
// reset the buffer
pbump(-size);
// done
return 0;
}
strstreambuf::int_type
strstreambuf::overflow (int_type c)
{
if (c == char_traits<char>::eof())
return ' ';
if (pptr() == epptr())
{
if (_CS_m_dynamic == 0 || _CS_m_frozen == 1)
return char_traits<char>::eof();
streamsize n = epptr() - eback();
char* tmp = _CS_m_alloc == 0
? new char[n + _CS_m_chunk_size]
: static_cast<char*>(_CS_m_alloc(n + _CS_m_chunk_size));
char_traits<char>::copy(tmp, eback(), n);
char* del = eback();
setg(tmp, tmp + (gptr() - del), tmp + (egptr() - del));
setp(tmp + (pptr() - del), tmp + n + _CS_m_chunk_size);
if (_CS_m_allocated != 0)
_CS_m_free == 0? delete[] del: _CS_m_free(del);
_CS_m_allocated = 1;
}
*pptr() = static_cast<unsigned char>(c);
pbump(1);
return c;
}
streamsize CCompressionStreambuf::xsputn(const CT_CHAR_TYPE* buf,
streamsize count)
{
// Check processor's state
if ( !IsStreamProcessorOkay(CCompressionStream::eWrite) ) {
return CT_EOF;
}
if ( m_Writer->m_State == CSP::eFinalize ) {
return CT_EOF;
}
// Check parameters
if ( !buf || count <= 0 ) {
return 0;
}
// The number of chars copied
streamsize done = 0;
// Loop until no data is left
while ( done < count ) {
// Get the number of chars to write in this iteration
// (we've got one more char than epptr thinks)
size_t block_size = min(size_t(count-done), size_t(epptr()-pptr()+1));
// Write them
memcpy(pptr(), buf + done, block_size);
// Update the write pointer
pbump((int)block_size);
// Process block if necessary
if ( pptr() >= epptr() && !ProcessStreamWrite() ) {
break;
}
done += block_size;
}
return done;
};
_CRTIMP2 streampos strstreambuf::seekpos(streampos sp,
ios::openmode which)
{ // seek to memorized position
streamoff off = (streamoff)sp;
if (pptr() != 0 && _Seekhigh < pptr())
_Seekhigh = pptr();
if (off == _BADOFF)
;
else if (which & ios::in && gptr() != 0)
{ // set input (and maybe output) pointer
if (0 <= off && off <= _Seekhigh - eback())
{ // set valid offset
gbump(eback() - gptr() + off);
if (which & ios::out && pptr() != 0)
setp(pbase(), gptr(), epptr());
}
else
off = _BADOFF;
}
else if (which & ios::out && pptr() != 0)
{ // set output pointer
if (0 <= off && off <= _Seekhigh - eback())
pbump(eback() - pptr() + off);
else
off = _BADOFF;
}
else // nothing to set
off = _BADOFF;
return (streampos(off));
}
/**
* Appends @c n characters from the start of the output sequence to the input
* sequence. The beginning of the output sequence is advanced by @c n
* characters.
*
* Requires a preceding call <tt>prepare(x)</tt> where <tt>x >= n</tt>, and
* no intervening operations that modify the input or output sequence.
*
* @throws std::length_error If @c n is greater than the size of the output
* sequence.
*/
void commit(std::size_t n)
{
if (pptr() + n > epptr())
n = epptr() - pptr();
pbump(static_cast<int>(n));
setg(eback(), gptr(), pptr());
}
int gzfilebuf::overflow( int c ) {
if ( !is_open() || !(mode & ios::out) )
return EOF;
if ( !base() ) {
if ( allocate() == EOF )
return EOF;
setg(0,0,0);
} else {
if (in_avail()) {
return EOF;
}
if (out_waiting()) {
if (flushbuf() == EOF)
return EOF;
}
}
int bl = blen();
setp( base(), base() + bl);
if ( c != EOF ) {
*pptr() = c;
pbump(1);
}
return 0;
}
void LoggerBuffer::reserve(std::streamsize n)
{
if (n <= _buffer_len)
{
return;
}
//不超过最大大小
if (n > MAX_BUFFER_LENGTH)
{
n = MAX_BUFFER_LENGTH;
}
int len = pptr() - pbase();
char_type * p = new char_type[n];
memcpy(p, _buffer, len);
delete[] _buffer;
_buffer = p;
_buffer_len = n;
setp(_buffer, _buffer + _buffer_len);
pbump(len);
return;
}
GnuTls_streambuf::int_type GnuTls_streambuf::overflow(GnuTls_streambuf::int_type c)
{
try
{
if (pptr() != pbase())
{
int n = m_stream.sslWrite(pbase(), pptr() - pbase());
if (n <= 0)
return traits_type::eof();
}
setp(m_buffer, m_buffer + m_bufsize);
if (c != traits_type::eof())
{
*pptr() = (char_type)c;
pbump(1);
}
return 0;
}
catch (const std::exception& e)
{
log_error("error int GnuTls_streambuf::overflow: " << e.what());
return traits_type::eof();
}
}
int gzstreambuf::flush_buffer() {
int w = pptr() - pbase();
if (gzwrite(file, pbase(), w) != w)
return EOF;
pbump(-w);
return w;
}
strstreambuf::pos_type
strstreambuf::seekoff(off_type __off, ios_base::seekdir __way, ios_base::openmode __which)
{
off_type __p(-1);
bool pos_in = (__which & ios::in) != 0;
bool pos_out = (__which & ios::out) != 0;
bool legal = false;
switch (__way)
{
case ios::beg:
case ios::end:
if (pos_in || pos_out)
legal = true;
break;
case ios::cur:
if (pos_in != pos_out)
legal = true;
break;
}
if (pos_in && gptr() == nullptr)
legal = false;
if (pos_out && pptr() == nullptr)
legal = false;
if (legal)
{
off_type newoff;
char* seekhigh = epptr() ? epptr() : egptr();
switch (__way)
{
case ios::beg:
newoff = 0;
break;
case ios::cur:
newoff = (pos_in ? gptr() : pptr()) - eback();
break;
case ios::end:
newoff = seekhigh - eback();
break;
default:
return pos_type(off_type(-1));
}
newoff += __off;
if (0 <= newoff && newoff <= seekhigh - eback())
{
char* newpos = eback() + newoff;
if (pos_in)
setg(eback(), newpos, _VSTD::max(newpos, egptr()));
if (pos_out)
{
// min(pbase, newpos), newpos, epptr()
__off = epptr() - newpos;
setp(min(pbase(), newpos), epptr());
pbump(static_cast<int>((epptr() - pbase()) - __off));
}
__p = newoff;
}
}
return pos_type(__p);
}
void doSync()
{
uint64_t n = pptr()-pbase();
pbump(-n);
char * p = pbase();
while ( n )
{
ssize_t const w = ::write(fd,p,n);
if ( w < 0 )
{
int const error = errno;
switch ( error )
{
case EINTR:
case EAGAIN:
break;
default:
{
libmaus2::exception::LibMausException se;
se.getStream() << "LinuxStreamingPosixFdOutputStreamBuffer::doSync(): write() failed: " << strerror(error) << std::endl;
se.finish();
throw se;
}
}
}
else
{
assert ( w <= static_cast<int64_t>(n) );
#if defined(__GLIBC__)
#if __GLIBC_PREREQ(2,6)
// non block buffer cache flush request for range we have just written
if ( w )
{
::sync_file_range(fd, prevwrite.first+prevwrite.second, w, SYNC_FILE_RANGE_WRITE);
}
if ( prevwrite.second )
{
// blocking buffer cache flush request for previous buffer
::sync_file_range(fd, prevwrite.first, prevwrite.second, SYNC_FILE_RANGE_WAIT_BEFORE|SYNC_FILE_RANGE_WRITE|SYNC_FILE_RANGE_WAIT_AFTER);
// tell kernel we no longer need the pages
::posix_fadvise(fd, prevwrite.first, prevwrite.second, POSIX_FADV_DONTNEED);
}
#endif
#endif
prevwrite.first = prevwrite.first + prevwrite.second;
prevwrite.second = w;
n -= w;
}
}
assert ( ! n );
}
streamsize mem_streambuf::xsputn( char_type const *buf, streamsize size ) {
streamsize const remaining = epptr() - pptr();
if ( size > remaining )
size = remaining;
::memcpy( pptr(), buf, static_cast<size_t>( size ) );
pbump( static_cast<int>(size) );
return size;
}
int sync() override {
std::ptrdiff_t n = pptr() - pbase();
for (auto ptr = pbase(); ptr != pptr(); ptr++) {
push(*ptr);
}
pbump(-n);
return 0;
}
// Write characters to output buffer.
// We compensate for character-splitting. This is necessary because
// MSVC does not support a UTF8 locale and as such streams interpret
// narrow characters in the default locale. This implementation
// assumes the stream will treat each byte of a multibyte narrow
// chracter as an individual single byte character.
std::streambuf::int_type unicode_streambuf::overflow(
std::streambuf::int_type character)
{
// Add a single explicitly read byte to the buffer.
// The narrow buffer is underexposed by 1 byte to accomodate this.
if (character != traits_type::eof())
{
*pptr() = static_cast<char>(character);
pbump(sizeof(char));
}
// This will be in the range 0..4, indicating the number of bytes that were
// not written in the conversion. A nonzero value results when the buffer
// terminates within a utf8 multiple byte character.
uint8_t unwritten = 0;
// Get the number of bytes in the buffer to convert.
const auto write = pptr() - pbase();
if (write > 0)
{
// Convert utf8 to utf16, returning chars written and bytes unread.
const auto chars = to_utf16(wide_, narrow_size_, narrow_, write,
unwritten);
// Write to the wide output buffer.
const auto written = wide_buffer_->sputn(wide_, chars);
// Handle write failure as an EOF.
if (written != chars)
return traits_type::eof();
}
// Copy the fractional character to the beginning of the buffer.
memcpy(narrow_, &narrow_[write - unwritten], unwritten);
// Reset the pptr to the buffer start, leave pbase and epptr.
// We could use just pbump for this if it wasn't limited to 'int' width.
setp(narrow_, &narrow_[narrow_size_ - 1]);
// Reset pptr just after the fractional character.
pbump(unwritten);
// Return the overflow byte or EOF sentinel.
return character;
};
// flush the characters in the buffer
int flushBuffer () {
int num = pptr()-pbase();
if (write (1, buffer, num) != num) {
return EOF;
}
pbump (-num); // reset put pointer accordingly
return num;
}
std::streamsize sockbuf::xsputn (const char_type* s, std::streamsize n)
{
std::streamsize wval = epptr () - pptr ();
if (n <= wval) {
memcpy (pptr (), s, (size_t)(n * sizeof (char_type)));
pbump ((int)n);
return n;
}
memcpy (pptr (), s, (size_t)(wval * sizeof (char_type)));
pbump ((int)wval);
if (overflow () != eof)
return wval + xsputn (s + wval, n - wval);
return wval;
}
void MemoryStreamBuf::position(UInt32 pos) {
written(); // Save nb char written
setp(_pBuffer,_pBuffer + _bufferSize);
if(pos>_bufferSize)
pos = _bufferSize;
pbump((int)pos);
setg(_pBuffer,_pBuffer+pos,_pBuffer + _bufferSize);
}
streamsize stringbuf::_M_xsputnc(char_type __char, streamsize __count)
{
if (((__M_mode & ios_base::out) == 0) || (__count <= 0)) return 0;
streamsize __nwritten = 0;
// If the put pointer is somewhere in the middle of the string, then overwrite instead of append.
if (pbase() == __M_str.begin())
{
ptrdiff_t __avail = __M_str.end() - pptr();
if (__avail >= __count)
{
VOS_memset_s(pptr(), epptr() - pptr(), __char, static_cast<size_t>(__count));
pbump(static_cast<int>(__count));
return __count;
}
else
{
VOS_memset_s(pptr(), epptr() - pptr(), __char, __avail);
__nwritten += __avail;
__count -= __avail;
}
}
// At this point we know we're appending.
size_t __app_size = static_cast<size_t>(__count);
char_type* __data_ptr;
if (__M_mode & ios_base::in)
{
ptrdiff_t __get_offset = gptr() - eback();
__M_str.append(__app_size, __char);
__data_ptr = __M_str.begin();
setg(__data_ptr, __data_ptr + __get_offset, __M_str.end());
}
else
{
__M_str.append(__app_size, __char);
__data_ptr = __M_str.begin();
}
setp(__data_ptr, __M_str.end());
pbump(static_cast<int>(__M_str.size()));
__nwritten += __app_size;
return __nwritten;
}
