socket.hpp

/*
  ANCH Framework: ANother C++ Hack is a C++ framework based on C++11 standard
  Copyright (C) 2012 Vincent Lachenal

  This file is part of ANCH Framework.

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

  ANCH Framework 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 Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public License
  along with ANCH Framework.  If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef _ANCH_NETWORK_SOCKET_H_
#define _ANCH_NETWORK_SOCKET_H_

#include <iostream>

#include "events/observable.hpp"
#include "network/socketEvent.hpp"
#include "network/ioException.hpp"


// Microsoft Windows operating systems defintions +
#ifdef ANCH_WINDOWS
typedef int socklen_t;
// Microsoft Windows operating systems defintions -

// POSIX operating systems definitions +
#elif defined ANCH_POSIX
#include <netdb.h>
#define INVALID_SOCKET -1
#define SOCKET_ERROR -1
typedef int SOCKET;
typedef struct sockaddr_in SOCKADDR_IN;
typedef struct sockaddr SOCKADDR;
#endif
// POSIX operating systems definitions -


namespace anch {
  namespace network {

    enum SocketType {
      UNKNOWN = 0,

      TCP,

      UDP,

#ifdef ANCH_POSIX

      POSIX,
#endif
    };

    enum Direction {
      RECEPTION = 0,

      TRANSMISSION = 1,

      BOTH = 2,
    };

    class Socket : public anch::events::Observable<anch::network::SocketEvent> {

    private:
      // Attributes +
      std::string _ipAddress;

      uint16_t _port;

      SocketType _type;

    protected:
      SOCKET _sock;

      int _backlog;

      addrinfo* _address;
      // Attributes -

      // Constructors +
    protected:
      Socket(anch::network::SocketType type);

    public:
      Socket(const std::string& ipAddress,
             uint16_t port,
             anch::network::SocketType type = anch::network::SocketType::UNKNOWN)
        throw(anch::network::IOException);
      // Constructors -

      // Destructor +
      virtual ~Socket() noexcept;
      // Destructor -

    public:
      // Methods +
      virtual void bind() throw(anch::network::IOException);

      virtual void connect() throw(anch::network::IOException);

      virtual void listen() throw(anch::network::IOException);

      virtual void accept(Socket& socket) throw(anch::network::IOException);

      virtual void send(const std::string& message) throw(anch::network::IOException) = 0;

      virtual void receive(std::string& message) throw(anch::network::IOException) = 0;

      virtual void receive() throw(anch::network::IOException);

      virtual void shutdown(anch::network::Direction how = anch::network::Direction::BOTH)
        throw(anch::network::IOException);

      virtual void close() noexcept;
      // Methods -

    public:
      // Accessors +
      virtual int getDomain() const = 0;

      virtual int getType() const = 0;

      inline const std::string& getIpAddress() const {
        return _ipAddress;
      }

      inline void setIpAddress(const std::string& ipAddress) {
        _ipAddress = ipAddress;
      }

      inline uint16_t getPort() const {
        return _port;
      }

      inline void setIpAddress(uint16_t port) {
        _port = port;
      }

      inline anch::network::SocketType getSocketType() const {
        return _type;
      }

      inline void setSocketType(SocketType type) {
        _type = type;
      }

      inline int getBacklog() const {
        return _backlog;
      }

      inline void setBacklog(int backlog) {
        _backlog = backlog;
      }
      // Accessors -

    };

  }
}

#endif // _ANCH_NETWORK_SOCKET_H_