21    d->_readChannels.clear();
 
   23      d->_readChannels.push_back( 
IOBuffer( d->_readBufChunkSize ) );
 
 
   34    d->_readChannels.clear();
 
 
   40      d->_readChannels.resize( channels );
 
 
   47    if ( channel >= d->_readChannels.size() ) {
 
   53    d->_sigReadChannelFinished.emit( channel );
 
 
   61    if ( channel >= d->_readChannels.size() ) {
 
   65    d->_currentReadChannel = channel;
 
 
   74    return d->_currentReadChannel;
 
 
   82    return d->_readChannels.size();
 
 
  124    return readAll( d->_currentReadChannel );
 
 
  129    if ( !
canRead() || maxSize <= 0 )
 
  131    return read( d_func()->_currentReadChannel, maxSize );
 
 
  139    return read( d->_currentReadChannel, buf, maxSize );
 
 
  157    if ( !
canRead() || maxSize <= 0 )
 
  161    const auto r = 
read( channel, res.data(), maxSize );
 
 
  169    if ( !
canRead() || maxSize < 0 )
 
  172    if ( channel >= d->_readChannels.size() ) {
 
  177    int64_t readSoFar = d->_readChannels[ channel ].read( buf, maxSize );
 
  180    if ( readSoFar < maxSize ) {
 
  181      int64_t readFromDev = 
readData( channel, buf+readSoFar, maxSize - readSoFar );
 
  182      if ( readFromDev > 0 )
 
  183        return readSoFar + readFromDev;
 
  191    if ( !
canRead() || maxSize < 0 )
 
  194    if ( channel >= d->_readChannels.size() ) {
 
  201    const auto maxBArrSize = int64_t( std::min( 
ByteArray::maxSize(), std::size_t(std::numeric_limits<int64_t>::max()) ) );
 
  202    if ( maxSize > maxBArrSize ) {
 
  203      ERR << 
"Calling channelReadUntil with maxSize > int64_t(ByteArray::maxSize) " << std::endl;
 
  204      maxSize = maxBArrSize - 1;
 
  208    int64_t readSoFar = 0;
 
  212    if ( maxSize == 0 || maxSize >= (maxBArrSize - 1) ) {
 
  215      maxSize = maxBArrSize;
 
  218      int64_t lastReadSize = 0;
 
  221        result.resize( std::min( std::size_t(maxSize), std::size_t(result.size() + d->_readBufChunkSize )) );
 
  222        lastReadSize = 
channelReadUntil( channel, result.data() + readSoFar, delim, result.size() - readSoFar );
 
  223        if ( lastReadSize > 0)
 
  224          readSoFar += lastReadSize;
 
  229      } 
while( lastReadSize == d->_readBufChunkSize
 
  230                && result[readSoFar-1] != delim );
 
  233      result.resize( maxSize );
 
  234      readSoFar = 
channelReadUntil( channel, result.data(), delim, result.size() );
 
  237    if ( readSoFar > 0 ) {
 
  239      result.resize( readSoFar );
 
  245    result.shrink_to_fit();
 
 
  264    if ( !
canRead() || maxSize < 0 )
 
  267    if ( channel >= d->_readChannels.size() ) {
 
  273      ERR << 
"channelReadUntil needs at least a buffsize of 2" << std::endl;
 
  277    int64_t toRead    = maxSize - 1; 
 
  278    int64_t readSoFar = 0;
 
  279    if ( d->_readChannels[channel].size () > 0 )
 
  280      readSoFar = d->_readChannels[channel].readUntil( buf, delimiter, toRead + 1  );
 
  282    if ( readSoFar == toRead || ( readSoFar > 0 && buf[readSoFar-1] == delimiter ) ) {
 
  283      buf[readSoFar] = 
'\0';
 
  287    bool hasError = 
false;
 
  290    while ( readSoFar < toRead ) {
 
  291      const auto r = 
readData( channel, buf+readSoFar, 1 );
 
  302      if ( buf[readSoFar-1] == delimiter )
 
  306    if ( readSoFar == 0 )
 
  307      return hasError ? -1 : 0;
 
  309    buf[readSoFar] = 
'\0';
 
 
  326    return d->_readChannels[channel].size();
 
 
  332    if ( !
canRead() || channel >= d->_readChannels.size() )
 
  334    return d->_readChannels[channel].canReadUntil( delim );
 
 
  340    if ( !
canRead() || channel >= d->_readChannels.size() )
 
  342    return d->_readChannels[channel].canReadLine();
 
 
  349    return write( data.data(), data.size() );
 
 
  370    return d_func()->_readyRead;
 
 
  375    return d_func()->_channelReadyRead;
 
 
  380    return d_func()->_sigBytesWritten;
 
 
  385    return d_func()->_sigAllBytesWritten;
 
 
  390    return d_func()->_sigReadChannelFinished;
 
 
  400      return traits_type::eof();
 
  403    if ( 
_dev->write ( &buf, 1 ) == 1 ) {
 
  404      return traits_type::not_eof(__c);
 
  406    return traits_type::eof();
 
 
 
 
 
static std::size_t maxSize()
IODeviceOStreamBuf(IODeviceRef dev)
int_type overflow(int_type __c) override
IODevicePrivate(IODevice &p)
ByteArray channelReadUntil(uint channel, const char delim, int64_t maxSize=0)
virtual void readChannelChanged(uint channel)=0
virtual int64_t writeData(const char *data, int64_t count)=0
virtual ByteArray readLine(const int64_t maxSize=0)
SignalProxy< void(uint)> sigChannelReadyRead()
SignalProxy< void(uint) > sigReadChannelFinished()
void setReadChannelCount(uint channels)
SignalProxy< void()> sigReadyRead()
virtual int64_t bytesAvailable() const
virtual int64_t rawBytesAvailable(uint channel) const =0
SignalProxy< void(int64_t)> sigBytesWritten()
virtual int64_t readData(uint channel, char *buffer, int64_t bufsize)=0
bool waitForReadyRead(int timeout)
void finishReadChannel(uint channel)
bool canReadUntil(uint channel, const char delim) const
int64_t readBufferCount() const
SignalProxy< void()> sigAllBytesWritten()
void setReadChannel(uint channel)
uint currentReadChannel() const
ByteArray read(int64_t maxSize)
ByteArray channelReadLine(uint channel, int64_t maxSize=0)
int64_t write(const ByteArray &data)
virtual bool open(const OpenMode mode)
int readChannelCount() const
constexpr std::string_view outOfRangeErrMsg("Channel index out of range")
#define ZYPP_IMPL_PRIVATE(Class)