iodevice.h

Go to the documentation of this file.

 
#ifndef iodevice_h_included
#define iodevice_h_included
 
#include "convert.h" // BincStream
//#include <iostream>
#include <string>
#include <unistd.h> // ::write
 
const char CMS_END_OF_LINE[4] = { 0x0d, '\n', 0x00, 0x00 };
 
namespace Binc {
  class IODevice {
  public:
    enum Flags {
      None = 0,
      FlushesOnEndl = 1 << 0,
      HasInputLimit = 1 << 1,
      HasOutputLimit = 1 << 2,
      IsEnabled = 1 << 3,
      HasTimeout = 1 << 4
    };
 
    enum Error {
      Unknown,
      Timeout
    };
 
    IODevice(int f = 0);
 
    virtual ~IODevice(void);
 
    void clear(void);
 
    void setFlags(unsigned int f);
 
    void clearFlags(unsigned int f);
 
    void setMaxInputBufferSize(unsigned int max);
 
    void setMaxOutputBufferSize(unsigned int max);
 
    void setTimeout(unsigned int t);
 
    unsigned int getTimeout(void) const;
 
    enum LogLevel {
      ErrorLevel,
      InfoLevel,
      WarningLevel,
      DebugLevel
    };
    
    void setOutputLevel(LogLevel level);
 
    LogLevel getOutputLevel(void) const;
 
    void setOutputLevelLimit(LogLevel level);
 
    LogLevel getOutputLevelLimit(void) const;
 
    unsigned int getReadCount(void) const;
 
    unsigned int getWriteCount(void) const;
 
    void enableProtocolDumping(void);
 
    template <class T> IODevice &operator << (const T &source);
 
    IODevice &operator << (std::ostream &(*source)(std::ostream &));
 
    virtual bool canRead(void) const;
 
    bool readStr(std::string *dest, unsigned int max = 0);
 
    bool readChar(char *dest = 0);
 
    void unreadChar(char c);
 
    void unreadStr(const std::string &s);
 
    bool skipTo(char c);
 
    bool flush(void);
 
    Error getLastError(void) const;
 
    std::string getLastErrorString(void) const;
 
    virtual std::string service(void) const;
    
  protected:
    virtual bool waitForWrite(void) const;
 
    virtual bool waitForRead(void) const;
 
    enum WriteResult {
      WriteWait = 0,
      WriteDone = 1 << 0,
      WriteError = 1 << 1
    };
 
    virtual WriteResult write(void);
 
    virtual bool fillInputBuffer(void);
 
    BincStream inputBuffer;
    BincStream outputBuffer;
 
    unsigned int flags;
    unsigned int maxInputBufferSize;
    unsigned int maxOutputBufferSize;
 
    unsigned int timeout;
 
    unsigned int readCount;
    unsigned int writeCount;
 
    LogLevel outputLevel;
    LogLevel outputLevelLimit;
 
    mutable Error error;
    mutable std::string errorString;
 
    int dumpfd;
  };
 
  //----------------------------------------------------------------------
  template <class T> IODevice &IODevice::operator << (const T &source)
  {
    if ((flags & IsEnabled) && outputLevel <= outputLevelLimit) {
      outputBuffer << source;
 
     if (dumpfd) {
              BincStream ss;
        ss << source;
              ::write(dumpfd, ss.str().c_str(), ss.getSize());
      }
 
      if (flags & HasInputLimit)
              if (outputBuffer.getSize() > maxOutputBufferSize)
                flush();
    }
 
    return *this;
  }
}
 
#endif