samchon::protocol::IWebServer Class Reference

An interface for a physical server following web-socket. More...

#include <IWebServer.hpp>

Collaboration diagram for samchon::protocol::IWebServer:

Public Member Functions
	IWebServer ()
	Default Constructor. More...
virtual void	open () override
	Open the web-socket server. More...
Public Member Functions inherited from samchon::protocol::IServer
	IServer ()
	Default Constructor. More...
virtual void	close ()
	Close the server. More...

Additional Inherited Members
Protected Member Functions inherited from samchon::protocol::IServer
virtual auto	MY_IP () const -> std::string
	(optional) Server's IP More...
virtual auto	PORT () const -> int=NULL
	Port number of the server. More...
virtual void	addClient (Socket *)=0
	Handling connection of a physical client. More...
Protected Attributes inherited from samchon::protocol::IServer
Acceptor *	acceptor
	An acceptor for clients. More...

Detailed Description

An interface for a physical server following web-socket.

IWebServer is a IServer following web-socket protocol.

[Inherited]

IServer provides methods for opening a server.

IServer is one of the basic 3 + 1 components that can make any type of network system in Samchon Framework with IProtocol and IClient. Looking around classes in Samchon Framework, you can see all servers are implemented from the IServer.

When a client connects to the server, the abstract method IServer::addClient() is called with a new thread. If you want to accept only a client at a time, use OneToOneServer instead.

Example source

A simple chat server running on console

example/console_chat_server/ChatServer.hpp

#pragma once
#include <samchon/protocol/IServer.hpp>
#include <samchon/protocol/IProtocol.hpp>

#include <set>
#include <samchon/library/RWMutex.hpp>

namespace samchon
{
    namespace example
    {
        namespace console_chat_server
        {
            class ChatClient;

            class ChatServer
                : public protocol::IServer,
                public protocol::IProtocol
            {
            private:
                typedef protocol::IServer super;

                std::set<ChatClient*> clientSet;

                library::RWMutex rwMutex;

            public:
                ChatServer();
                virtual ~ChatServer() = default;

                void eraseClient(ChatClient *client);

            protected:
                virtual auto PORT() const -> int override
                {
                    return 37749;
                };

                virtual void addClient(protocol::Socket *socket) override;

            public:
                virtual void replyData(std::shared_ptr<protocol::Invoke>) override;

                virtual void sendData(std::shared_ptr<protocol::Invoke>) override;
            };
        };
    };
};

example/console_chat_server/ChatServer.cpp

#include <samchon/examples/console_chat_server/ChatServer.hpp>
#include <samchon/examples/console_chat_server/ChatClient.hpp>

#include <thread>
#include <samchon/protocol/Invoke.hpp>

using namespace std;
using namespace samchon::library;
using namespace samchon::protocol;
using namespace samchon::example::console_chat_server;

ChatServer::ChatServer()
    : super()
{
}
void ChatServer::addClient(Socket *socket)
{
    ChatClient *client = new ChatClient(this, socket);

    UniqueWriteLock uk(rwMutex);
    clientSet.insert(client);

    thread(&ChatClient::listen, client).detach();
}
void ChatServer::eraseClient(ChatClient *client)
{
    UniqueWriteLock uk(rwMutex);
    clientSet.erase(client);
}

void ChatServer::replyData(shared_ptr<Invoke> invoke)
{
    sendData(invoke);
}
void ChatServer::sendData(shared_ptr<Invoke> invoke)
{
    UniqueReadLock uk(rwMutex);

    for(auto it = clientSet.begin(); it != clientSet.end(); it++)
        (*it)->sendData(invoke);
}

example/console_chat_server/ChatClient.hpp

#pragma once
#include <samchon/protocol/IClient.hpp>

namespace samchon
{
    namespace example
    {
        namespace console_chat_server
        {
            class ChatServer;

            class ChatClient
                : public protocol::IClient
            {
            private:
                typedef protocol::IClient super;

                ChatServer *server;

            public:
                ChatClient(ChatServer*, protocol::Socket*);

                virtual ~ChatClient();

                virtual void replyData(std::shared_ptr<protocol::Invoke>) override;
            };
        };
    };
};

example/console_chat_server/ChatClient.cpp

#include <samchon/examples/console_chat_server/ChatClient.hpp>
#include <samchon/examples/console_chat_server/ChatServer.hpp>

#include <samchon/protocol/Invoke.hpp>

using namespace std;
using namespace samchon::library;
using namespace samchon::protocol;
using namespace samchon::example::console_chat_server;

ChatClient::ChatClient(ChatServer *server, Socket *socket)
    : super()
{
    this->server = server;
    this->socket = socket;
}
ChatClient::~ChatClient()
{
    server->eraseClient(this);
}

void ChatClient::replyData(shared_ptr<Invoke> invoke)
{
    server->replyData(invoke);
}

example/console_chat_server/main.cpp

#include <iostream>
#include <samchon/examples/console_chat_server/ChatServer.hpp>

#ifdef _WIN64
#   ifdef _DEBUG
#       pragma comment(lib, "x64/Debug/SamchonFramework.lib")
#   else
#       pragma comment(lib, "x64/Release/SamchonFramework.lib")
#   endif
#else
#   ifdef _DEBUG
#       pragma comment(lib, "Debug/SamchonFramework.lib")
#   else
#       pragma comment(lib, "Release/SamchonFramework.lib")
#   endif
#endif

using namespace samchon::example::console_chat_server;

void main()
{
    ChatServer chatServer;
    chatServer.open();

    system("pause");
}

Author

Jeongho Nam http://samchon.org

Definition at line 19 of file IWebServer.hpp.

Constructor & Destructor Documentation

IWebServer::IWebServer

(

)

Default Constructor.

Definition at line 21 of file IWebServer.cpp.

Member Function Documentation

void IWebServer::open ( )

overridevirtual

Open the web-socket server.

Accepts clients and handshake with them following web-socket protocol.

Note

It monopolies a thread.

Reimplemented from samchon::protocol::IServer.

Definition at line 25 of file IWebServer.cpp.

References samchon::protocol::IServer::acceptor, samchon::protocol::IServer::addClient(), samchon::WeakString::between(), samchon::protocol::IServer::MY_IP(), samchon::protocol::IServer::PORT(), samchon::ByteArray::read(), and samchon::ByteArray::writeReversely().

Here is the call graph for this function:

---

The documentation for this class was generated from the following files:

• D:/OneDrive/Project/Samchon/framework/cpp/samchon/protocol/IWebServer.hpp
• D:/OneDrive/Project/Samchon/framework/cpp/samchon/protocol/IWebServer.cpp