Socket.h

#ifndef __Socket_h__
#define __Socket_h__
 
#include "includes"
#include "Object.h"
#include "ZString.h"
 
namespace core {
 
   class EPoll;
 
 
   class Socket {
 
    public:
 
 
      Socket(EPoll &ePoll, std::string text = "");
 
 
      virtual ~Socket();
 
 
      void shutdown(std::string text = "unknown");
 
 
      void setDescriptor(int descriptor); 
 
      int getDescriptor(); 
 
 
      bool eventReceived(struct epoll_event event, long long eventId); 
 
 
      int write(std::string data);
      void write(char *buffer, int length);
 
      void output(std::stringstream &out);
 
 
      virtual void onRegister(); 
      virtual void onRegistered(); 
 
      virtual void onUnregister();
 
 
      virtual void onUnregistered(); 
 
      bool needsToWrite();
 
      bool reset = false;
 
      volatile bool shutDown = false;
 
      void enableSocket();
      void disableSocket();
 
    protected:
 
      EPoll &ePoll;           // The EPoll control object.
 
      void setBufferSize(int length);
 
      int getBufferSize();
 
 
//      virtual void onConnected(); ///< Called when socket is open and ready to communicate.
 
 
//   virtual void onDisconnected(); ///< Called when socket is closing and no longer ready to communicate.
 
 
      virtual void onDataReceived(std::string data); 
 
 
      virtual void onDataReceived(coreutils::ZString &data);
 
 
      virtual void receiveData(coreutils::ZString &buffer);
 
    private:
 
      std::string text;
      int descriptor = -1;
      std::mutex outlock;
      bool readHangup = false;
        volatile bool inHandler = false;
 
      //-------------------------------------------------------------------------------------
      // the writeSocket is called when epoll has received a write request for a socket.
      // Writing data to this socket is queued in the streambuf and permission is requested
      // to write to the socket. This routine handles the writing of the streambuf data
      // buffer to the socket.
      //-------------------------------------------------------------------------------------
 
      void writeSocket();
 
 //  int_type underflow();
//   int_type uflow();
//   int_type pbackfail(int_type ch);
//   streamsize showmanyc();
 
      char *buffer;     // This is a pointer to the managed buffer space.
      int length;       // This is the length of the buffer.
 
      std::queue<std::string> fifo;
 
      void resetSocket();
 
      std::mutex lock;
 
   };
 
}
 
#endif