NewNet/nnsocket.h

/*  NewNet - A networking framework in C++
    Copyright (C) 2006 Ingmar K. Steen (iksteen@gmail.com)

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 */

#ifndef NEWNET_SOCKET_H
#define NEWNET_SOCKET_H

#include "nnobject.h"
#include "nnrefptr.h"
#include "nnweakrefptr.h"
#include "nnratelimiter.h"

namespace NewNet
{
  class Reactor;


  class Socket : public Object
  {
  public:

    typedef enum
    {
      SocketUninitialized, 
      SocketListening,     
      SocketConnecting,    
      SocketConnected,     
      SocketDisconnecting, 
      SocketDisconnected,  
      SocketException      
    } SocketState;


    typedef enum
    {
      StateSend = 1,       
      StateReceive = 2,    
      StateException = 4   
    } ReadyState;


    typedef enum
    {
      ErrorNoError,        
      ErrorCannotResolve,  
      ErrorInvalidPath,    
      ErrorCannotConnect,  
      ErrorCannotBind,     
      ErrorCannotListen,   
      ErrorUnknown         
    } SocketError;


    Socket() : m_Reactor(0), m_FD(-1), m_SocketState(SocketUninitialized),
              m_ReadyState(0), m_SocketError(ErrorNoError),
              m_DataWaiting(false)
    {
    }


    Reactor * reactor() const
    {
      return m_Reactor;
    }


    void setReactor(Reactor * reactor)
    {
      m_Reactor = reactor;
    }


    int descriptor() const
    {
      return m_FD;
    }


    void setDescriptor(int fd)
    {
      m_FD = fd;
    }


    SocketState socketState() const
    {
      return m_SocketState;
    }


    void setSocketState(SocketState socketState)
    {
      m_SocketState = socketState;
    }


    int readyState() const
    {
      return m_ReadyState;
    }


    void setReadyState(int readyState)
    {
      m_ReadyState = readyState;
    }


    SocketError socketError() const
    {
      return m_SocketError;
    }


    void setSocketError(SocketError socketError)
    {
      m_SocketError = socketError;
      setSocketState(SocketException);
    }


    bool dataWaiting() const
    {
      return m_DataWaiting;
    }


    void setDataWaiting(bool dataWaiting)
    {
      m_DataWaiting = dataWaiting;
    }


    RateLimiter * downRateLimiter()
    {
      return m_DownRateLimiter;
    }


    void setDownRateLimiter(RateLimiter * limiter)
    {
      m_DownRateLimiter = limiter;
    }


    RateLimiter * upRateLimiter()
    {
      return m_UpRateLimiter;
    }


    void setUpRateLimiter(RateLimiter * limiter)
    {
      m_DownRateLimiter = limiter;
    }


    virtual void process()
    {
    }

  private:
    Reactor * m_Reactor;
    int m_FD;
    SocketState m_SocketState;
    int m_ReadyState;
    SocketError m_SocketError;
    bool m_DataWaiting;
    RefPtr<RateLimiter> m_DownRateLimiter, m_UpRateLimiter;
  };
}

#endif // NEWNET_SOCKET_H

---