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 = "");
 
 
      ~Socket();
 
 
      void shutdown(std::string text = "unknown");
 
      
      void setDescriptor(int descriptor); 
   
      int getDescriptor(); 
         
   
      bool eventReceived(struct epoll_event event); 
 
         
      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;
 
    protected:
 
      EPoll &ePoll;           // The EPoll control object.
      
      bool shutDown = false;
 
      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 lock;
      std::mutex outlock;
      bool readHangup = false;
 
//      struct epoll_event event;  // Event selection construction structure.
 
      //-------------------------------------------------------------------------------------
      // 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.
 
//   const char * const begin_;
//   const char * const end_;
//   const char * const current_;
 
      std::queue<std::string> fifo;
      
   };
 
}
 
#endif