NetSendStr.h

Go to the documentation of this file.

#ifndef NETSENDSTR_H
#define NETSENDSTR_H

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

#define NET_SEND_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 NetSendStr;
  };

  namespace util {    
    
    class NetSendStr {
    public:
      
      enum NetSendId {   
    
    // The message body is being sent 
    
    NET_SEND_DATA   = gcp::control::NetSendStr::NET_SEND_DATA,
    
    // The message has been completely sent 
    
    NET_SEND_DONE   = gcp::control::NetSendStr::NET_SEND_DONE,
    
    // Closed connection detected at start of message 
    
    NET_SEND_CLOSED = gcp::control::NetSendStr::NET_SEND_CLOSED,
    
    // I/O error detected while sending 
    
    NET_SEND_ERROR  = gcp::control::NetSendStr::NET_SEND_ERROR
      };
      
      NetSendStr();
      
      NetSendStr(int fd, unsigned int size);
      
      virtual ~NetSendStr();
      
      void attach(int fd);
      
      void setBuffer(void* buffer, unsigned int size);
      
      NetSendId send();
      
      NetSendId send(int fd);
      
      NetSendId state();
      
      int getFd();
      
      void startPut(int opcode);
      
      void endPut();
      
      void putChar(int ndata, unsigned char *data);
      
      void putShort(int ndata, unsigned short *data);
      
      void putInt(int ndata, unsigned int *data);
      
      void putFloat(int ndata, float *data);    
      
      void putDouble(int ndata, double *data);
      
      void putObj(const NetObjTable* types, int id, void *obj);
      
      void incNput(int nbytes);
      
      void installSendHandler(NET_SEND_HANDLER(*handler), void* arg);
      
      void installErrorHandler(NET_ERROR_HANDLER(*handler), void* arg);
      
    private:
      
      void privateConstructor(int fd, unsigned int size);
      
      gcp::control::NetSendStr* netStream_;
      
      bool netBufAllocated_;
      
      bool attached_;
      
      NetSendId privateSend(int fd);
      
      NetSendId privateState(gcp::control::NetSendStr::NetSendId id);
      
      // Handler functions
      
      NET_SEND_HANDLER(*sendHandler_);
      
      void* sendArg_;
      
      NET_SEND_HANDLER(*errorHandler_);
      
      void* errorArg_;
      
    }; // End class NetSendStr
    
  } // End namespace util
} // End namespace gcp


#endif // End #ifndef