Socket.h

#ifndef __Socket_h__
#define __Socket_h__

#include "includes"
#include "Object.h"

namespace core {

   class EPoll;


   class Socket : public core::Object {
   
    public:

      Socket(EPoll &ePoll);
      Socket(EPoll &ePoll, std::string text);
      ~Socket();


      void shutdown(std::string text = "unknown");

      
      void setDescriptor(int descriptor); 
   
      int getDescriptor(); 

      class {
         int value;
   
       public:
         int & operator = (const int &i) { return value = i; }
         operator int () const { return value; }
   
      } bufferSize; 
         
   
      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(); 

      bool needsToWrite();

      bool active = false;

    protected:

      EPoll &ePoll;           // The EPoll control object.

      bool shutDown = false;

      void setBufferSize(int length);
   
   
//      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(char *buffer, int len); 
      

      virtual void receiveData(char *buffer, int bufferLength);
          
    private:

      std::string text;
      int descriptor = -1;
      std::mutex lock;
      std::mutex socketLock;
      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