NetReadStr.h

Go to the documentation of this file.

#ifndef NETREADSTR_H
#define NETREADSTR_H

#include "gcp/control/code/unix/libunix_src/common/netbuf.h"
#include "gcp/control/code/unix/libunix_src/common/netobj.h"

#define NET_READ_HANDLER(fn) void (fn)(void* arg)

#ifdef NET_ERROR_HANDLER
#undef NET_ERROR_HANDLER
#endif

#define NET_ERROR_HANDLER(fn) void (fn)(void* arg)

namespace gcp {

  namespace control {
    class NetReadStr;
  };

  namespace util {
    
    class NetReadStr {
    public:
      
      enum NetReadId {   
    
    // The message byte-count is being read 
    
    NET_READ_SIZE   = gcp::control::NetReadStr::NET_READ_SIZE,
    
    // The message body is being read 
    
    NET_READ_DATA   = gcp::control::NetReadStr::NET_READ_DATA,
    
    // The message has been completely read 
    
    NET_READ_DONE   = gcp::control::NetReadStr::NET_READ_DONE,
    
    // Closed connection detected at start of message 
    
    NET_READ_CLOSED = gcp::control::NetReadStr::NET_READ_CLOSED,
    
    // I/O error detected while reading 
    
    NET_READ_ERROR  = gcp::control::NetReadStr::NET_READ_ERROR
      };
      
      NetReadStr();
      
      NetReadStr(int fd, unsigned int size);
      
      virtual ~NetReadStr();
      
      void attach(int fd);
      
      void setBuffer(void* buffer, unsigned int size);
      
      NetReadId read();
      
      NetReadId read(int fd);
      
      NetReadId state();
      
      int getFd();
      
      void startGet(int *opcode);
      
      void endGet();
      
      void getChar(int ndata, unsigned char *data);
      
      void getShort(int ndata, unsigned short *data);
      
      void getInt(int ndata, unsigned int *data);
      
      void getFloat(int ndata, float *data);
      
      void getDouble(int ndata, double *data);
      
      void getObj(const NetObjTable* types, int id, void *obj);
      
      void incNget(int nbytes);
      
      void installReadHandler(NET_READ_HANDLER(*handler), void* arg);
      
      void installErrorHandler(NET_ERROR_HANDLER(*handler), void* arg);
      
    private:
      
      void privateConstructor(int fd, unsigned int size);
      
      gcp::control::NetReadStr* netStream_;
      
      bool netBufAllocated_;
      
      bool attached_;
      
      NetReadId privateRead(int fd);
      
      NetReadId privateState(gcp::control::NetReadStr::NetReadId id);
      
      // Handler functions
      
      NET_READ_HANDLER(*readHandler_);
      
      void* readArg_;
      
      NET_READ_HANDLER(*errorHandler_);
      
      void* errorArg_;
      
    }; // End class NetReadStr
    
  } // End namespace util
} // End namespace gcp


#endif // End #ifndef