Socket.hpp

//
//  Copyright PHOENIX CONTACT Electronics GmbH
//
#pragma once
#include "Arp/System/Core/Arp.h"
#include "Arp/System/Commons/Net/IpAddress.hpp"
#include "Arp/System/Commons/Net/SocketType.hpp"
#include "Arp/System/Commons/Net/SelectMode.hpp"
#include "Arp/System/Commons/Net/SocketError.hpp"
#include "Arp/System/Commons/Net/SocketDomain.hpp"
#include "Arp/System/Commons/Net/SocketOptionName.hpp"

// forwards
namespace Arp { namespace System { namespace Ve
{
class ISocketService;
}}}

namespace Arp { namespace System { namespace Commons { namespace Net
{

enum class SocketBlockingMode
{
    None = 0,
    Blocking = 1,
    NoneBlocking = 2
};

class Socket
{
public: // typedefs/usings

    typedef std::shared_ptr<Socket> Ptr;

public: // friends
    friend class TlsSocket;

public: // construction/destruction

    Socket(SocketType type, SocketDomain domain, SocketBlockingMode blockingMode);

    Socket(const Socket& arg) = delete;

    Socket& operator=(const Socket& arg) = delete;

    ~Socket(void);

public: // operators

public: // static operations

public: // setter/getter operations

    SocketType      GetSocketType(void) const;

    SocketDomain    GetSocketDomain(void) const;

    bool            IsBlocking(void) const;

    bool            IsConnected(void) const;

    IpAddress          GetRemoteIpAddress(void) const;

    int          GetRemotePort(void) const;

public: // operations

    Ptr             Accept(IpAddress& ip4address, int& port, SocketError& error);

    SocketError     Bind(const IpAddress& ip4Address, int port);

    SocketError     Connect(const IpAddress& ip4Address, int port);

    SocketError     Listen(size_t backlog);

    SocketError     Shutdown(void);

    SocketError     Close(void);

    int             Send(const void *pBuffer, size_t length, SocketError& error);

    int             SendTo(const void *pBuffer, size_t length, IpAddress ip4Adress, int port, SocketError& error);

    int             Receive(void *pBuffer, size_t length, SocketError& error);

    int             ReceiveFrom(void *pBuffer, size_t length, IpAddress& ip4Adress, int& port, SocketError& error);

    bool            Select(SelectMode mode, Microseconds timeout, SocketError& error);

    SocketError     SetSocketOption(SocketOptionName optionName, const void* optionValue, size_t optionLength);

    SocketError     GetSocketOption(SocketOptionName optionName, void* optionValue, size_t *optionLength) const;

    SocketError     SetOptionReuseAddress(bool enabled);

    SocketError     GetOptionReuseAddress(bool& enabled) const;

    SocketError     SetOptionKeepAlive(bool enabled);

    SocketError     GetOptionKeepAlive(bool& enabled) const;

    SocketError     SetOptionBroadcast(bool enabled);

    SocketError     GetOptionBroadcast(bool& enabled) const;

    SocketError     SetOptionNoDelay(bool enabled);

    SocketError     GetOptionNoDelay(bool& enabled) const;

    SocketError     SetOptionBlocking(bool enable);

    SocketError     SetOptionLinger(bool enable, size_t timeout);

    SocketError     GetOptionLinger(bool& enable, size_t& timeout);

protected: // operations

private: // usings/typedefs

    using ISocketService = Arp::System::Ve::ISocketService;

private: // construction/destruction

    Socket(ISocketService *pSocket); //contruct a new Socket Object from a given ISocketService

private: // static methods

private: // methods

private: // fields
    ISocketService *pSocketService;

    SocketType socketType;
    SocketDomain socketDomain;
    bool isBlocking;
    IpAddress remoteIpAddress;
    int remotePort;
    bool isConnected;

private: // static fields

};

// inline methods of class Socket

inline SocketType Socket::GetSocketType(void) const
{
    return socketType;
}

inline SocketDomain Socket::GetSocketDomain(void) const
{
    return socketDomain;
}

inline bool Socket::IsBlocking(void) const
{
    return isBlocking;
}

inline IpAddress Socket::GetRemoteIpAddress(void) const
{
    return remoteIpAddress;
}

inline int Socket::GetRemotePort(void) const
{
    return remotePort;
}

inline bool Socket::IsConnected(void) const
{
    return this->isConnected;
}

}}}} // end of namespace Arp::System::Commons::Net