iodevice.h

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                          ____ _   __ __ ___                          |
|                         |__  / \ / / . \ . \                         |
|                           / / \ V /|  _/  _/                         |
|                          / /__ | | | | | |                           |
|                         /_____||_| |_| |_|                           |
|                                                                      |
\----------------------------------------------------------------------/
*
* This file contains private API, this might break at any time between releases.
* You have been warned!
*
*/
 
#ifndef ZYPPNG_IO_IODEVICE_DEFINED
#define ZYPPNG_IO_IODEVICE_DEFINED
 
#include <zypp-core/base/Flags.h>
#include <zypp-core/zyppng/base/Base>
#include <zypp-core/zyppng/base/Signals>
#include <zypp-core/zyppng/core/ByteArray>
 
namespace zyppng {
 
  class IODevicePrivate;
  ZYPP_FWD_DECL_TYPE_WITH_REFS(IODevice);

  class IODevice : public Base
  {
    ZYPP_DECLARE_PRIVATE(IODevice)
  public:
 
    enum OpenModeFlag {
      Closed = 0x0,
      ReadOnly = 0x1,
      WriteOnly = 0x2,
      ReadWrite = ReadOnly | WriteOnly
    };
    ZYPP_DECLARE_FLAGS( OpenMode, OpenModeFlag );
 
    using Ptr = std::shared_ptr<IODevice>;
    using WeakPtr = std::weak_ptr<IODevice>;
 
    IODevice();
    virtual void close ();
 
    void setReadChannel ( uint channel );
    uint currentReadChannel () const;
    int  readChannelCount () const;
 
    bool canRead () const;
    bool canWrite () const;
    bool isOpen () const;
 
    ByteArray readAll ();
    ByteArray read ( int64_t maxSize );
    int64_t read ( char *buf, int64_t maxSize );
    virtual ByteArray readLine (const int64_t maxSize = 0 );
    virtual int64_t bytesAvailable () const;
    int64_t readBufferCount() const;
    bool canReadLine () const;
 
    ByteArray readAll ( uint channel );
    ByteArray read ( uint channel, int64_t maxSize );
    int64_t read ( uint channel, char *buf, int64_t maxSize );
 

    ByteArray channelReadUntil ( uint channel, const char delim, int64_t maxSize = 0 );

    ByteArray channelReadLine ( uint channel, int64_t maxSize = 0 );

    int64_t channelReadLine ( uint channel, char *buf, const int64_t maxSize );
    virtual int64_t bytesAvailable( uint channel ) const;

    int64_t readBufferCount( uint channel ) const;

    virtual int64_t channelReadUntil ( uint channel, char *buf, const char delimiter, const int64_t maxSize );

    bool canReadLine ( uint channel ) const;

    bool canReadUntil ( uint channel, const char delim ) const;
 
 
    int64_t write ( const ByteArray &data );
    int64_t write ( const char *data, int64_t len );

    virtual int64_t bytesPending() const = 0;

    bool waitForReadyRead(int timeout);

    virtual bool waitForReadyRead(uint channel, int timeout) = 0;
 

    SignalProxy<void ()> sigReadyRead ();

    SignalProxy<void (uint)> sigChannelReadyRead ();

    SignalProxy< void (int64_t)> sigBytesWritten ();

    SignalProxy< void ()> sigAllBytesWritten ();

    SignalProxy< void(uint) >sigReadChannelFinished();
 
  protected:
    IODevice( IODevicePrivate &d );
    virtual bool open ( const OpenMode mode );
    virtual int64_t rawBytesAvailable ( uint channel ) const = 0;
    virtual int64_t writeData ( const char *data, int64_t count ) = 0;
    virtual int64_t readData  ( uint channel, char *buffer, int64_t bufsize ) = 0;
    virtual void  readChannelChanged ( uint channel ) = 0;
    void setReadChannelCount ( uint channels );
    void finishReadChannel ( uint channel );
  };
  ZYPP_DECLARE_OPERATORS_FOR_FLAGS( IODevice::OpenMode );
 

  class IODeviceOStreamBuf : public std::streambuf
  {
    public:
      IODeviceOStreamBuf( IODeviceRef dev );
      IODeviceOStreamBuf(const IODeviceOStreamBuf &) = default;
      IODeviceOStreamBuf(IODeviceOStreamBuf &&) = default;
      IODeviceOStreamBuf &operator=(const IODeviceOStreamBuf &) = default;
      IODeviceOStreamBuf &operator=(IODeviceOStreamBuf &&) = default;
 
      // basic_streambuf interface
  protected:
      int_type overflow(int_type __c) override;
 
  private:
      IODeviceRef _dev;
  };
}
 
#endif