NetReadStr.h

Go to the documentation of this file.

#ifndef NETREADSTR_H
#define NETREADSTR_H

#include "carma/szaarrayutils/netbuf.h"
#include "carma/szaarrayutils/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 sza {
  namespace util {
    
    class NetReadStr {
    public:
      
      enum NetReadId {   
        
        // The message byte-count is being read 
        
        NET_READ_SIZE   = sza::array::NetReadStr::NET_READ_SIZE,
        
        // The message body is being read 
        
        NET_READ_DATA   = sza::array::NetReadStr::NET_READ_DATA,
        
        // The message has been completely read 
        
        NET_READ_DONE   = sza::array::NetReadStr::NET_READ_DONE,
        
        // Closed connection detected at start of message 
        
        NET_READ_CLOSED = sza::array::NetReadStr::NET_READ_CLOSED,
        
        // I/O error detected while reading 
        
        NET_READ_ERROR  = sza::array::NetReadStr::NET_READ_ERROR
      };
      
      NetReadStr();
      
      NetReadStr(int fd, unsigned long 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(long ndata, unsigned char *data);
      
      void getShort(long ndata, unsigned short *data);
      
      void getLong(long ndata, unsigned long *data);
      
      void getFloat(long ndata, float *data);
      
      void getDouble(long ndata, double *data);
      
      void getObj(const NetObjTable* types, int id, void *obj);
      
      void incNget(long nbytes);
      
      void installReadHandler(NET_READ_HANDLER(*handler), void* arg);

      void installErrorHandler(NET_ERROR_HANDLER(*handler), void* arg);

    private:
      
      void privateConstructor(int fd, unsigned long size);
      
      sza::array::NetReadStr* netStream_;
      
      bool netBufAllocated_;
      
      bool attached_;
      
      NetReadId privateRead(int fd);
      
      NetReadId privateState(sza::array::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 sza

#endif // End #ifndef