Socket.h

#ifndef __Socket_h__
#define __Socket_h__

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

namespace core {

   class EPoll;


   class Socket : public std::streambuf,
                  public core::Object {
   
    public:

      Socket(EPoll &ePoll);
      ~Socket();


      void shutdown();

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

      class {
         int value;
   
       public:
         int & operator = (const int &i) { return value = i; }
         operator int () const { return value; }
   
      } bufferSize; 
         
   
      void eventReceived(struct epoll_event event); 

         
      void write(std::string data);
      void write(char *buffer, int length);

      void output(std::stringstream &out);


      virtual void onRegistered(); 


      virtual void onUnregistered(); 

      void enable(bool mode); 

    protected:

      EPoll &ePoll;           // The EPoll control object.

      bool shutDown = false;

      void setBufferSize(int length);
   
   
      virtual void onConnected(); 

      virtual void onTLSInit();


//   virtual void onDisconnected(); ///< Called when socket is closing and no longer ready to communicate.
   
   
      virtual void onDataReceived(std::string data) = 0; 
   

      virtual void receiveData(char *buffer, int bufferLength);
          
    private:
   
      int descriptor = -1;
      std::mutex lock;
      bool readHangup = false;

      struct epoll_event event;  // Event selection construction structure.

      //--------------------------------------------------
      // These are used to schedule the socket activity.
      //--------------------------------------------------

      void setRead(); 
      void setWrite(); 
      void setReadWrite();
      void resetRead();
      void resetWrite();;
      void resetReadWrite();
      void clear();

      //-------------------------------------------------------------------------------------
      // 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;
   
      bool active = false;
   
   };

}

#endif