Server<T> good approach?

Hi all,
I am trying to figure out a good way to implement a Server class which would not be to hard to reuse and I come up with this:

Server

Code:

---

template <typename Handler>
class Server
{
public:
//....
private:
//...
Handler & m_handler;
};

---

There the Handler requires to have two methods:

void init(Server<Handler>&) throw();
void newConnection(boost::asio::ip::tcp::socket*);

But I wonder, is this really a good approach?

If someone didn't exactly understood me so here comes a example:

Server.hpp

Code:

---

#ifndef H_HEADER_SERVER_H
#define H_HEADER_SERVER_H

#include <boost/thread.hpp>
#include <boost/asio.hpp>
#include <string>
#include <boost/bind.hpp>
#include <boost/unordered_set.hpp> //delete if not used
#include <iostream>


namespace details
{
        template <typename T>
        class IsRunning
        {
        private:
                T & var;
        public:
                IsRunning(T & a)
                        : var(a)
                {
                        var = true;
                }
                ~IsRunning()
                {
                        var = false;
                }
        };

        class ServiceInvoker
        {
        private:
                boost::asio::io_service & service;
        public:
                ServiceInvoker(boost::asio::io_service &);
                void run();
        };
       
        ServiceInvoker::ServiceInvoker(boost::asio::io_service & ser)
                : service(ser)
        {
        }

       
        void ServiceInvoker::run()
        {
                while(true)
                {
                        try
                        {
                                service.run();
                                break;
                        }
                        catch(std::exception & exception)
                        {
                                std::cerr << "Exception catched:\n" << exception.what() << "\n"; // may add more error handling here later
                        }
                        catch(...)
                        {
                                std::cerr << "Unkown exception catched\n"; // may add more error handling here later
                        }
                }
        }
}
/*
Handler most have the follow methods:

void init(Server<Handler>&) throw();
        The server constructor will invoke this method

void newConnection(boost::asio::ip::tcp::socket*);
        Every incoming connection will be passed to this method.
        The method most then delete the pointer because the Server will not.

*/
template <typename Handler>
class Server
{
public:
        Server(Handler &, boost::asio::io_service &);
        ~Server();
        /* set the io_service object */
        bool setPort(unsigned short int);
        unsigned short int getPort() const;

        bool setAddress(const std::string &, const std::string &);
        std::string getAddress() const;

        bool setPoolsize(unsigned);
        unsigned getPoolsize() const;

        boost::asio::io_service & getService();
        const boost::asio::io_service & getService() const;

        boost::asio::ip::tcp::acceptor & getAcceptor();
        const boost::asio::ip::tcp::acceptor & getAcceptor() const;

        bool isRunning() const;
        void stop();
        void stopListen();
        bool isListen();
        void startListen();
        void startAccept();
        bool isAccept();
        void stopAccept();
        void secureStop();
        void run();
private:
        void handle_accept(const boost::system::error_code& e);

        std::size_t m_pool_size;
        bool m_accept;
        bool m_is_running;
        boost::asio::ip::tcp::acceptor m_acceptor;
        boost::asio::ip::tcp::socket* m_next_socket;       
        boost::asio::io_service & m_io_service;
        Handler & m_handler;
};


template <typename Handler>
Server<Handler>::Server(Handler & handler, boost::asio::io_service & service)
        : m_acceptor(service), m_next_socket(new boost::asio::ip::tcp::socket(service)),
        m_io_service(service), m_handler(handler), m_accept(false), m_is_running(false),
      m_pool_size(boost::thread::hardware_concurrency())
{
        m_handler.init(*this);
}

template <typename Handler>
Server<Handler>::~Server()
{
        delete m_next_socket;
}

template <typename Handler>
bool Server<Handler>::setPort(unsigned short int p)
{
        if(isRunning())
        {
                return false;
        }
        m_acceptor.local_endpoint().port(p);
        return true;
}

template <typename Handler>
unsigned short int Server<Handler>::getPort() const
{
        return m_acceptor.local_endpoint().port();
}
template <typename Handler>
bool Server<Handler>::setAddress(const std::string & address, const std::string &port)
{
        if(isRunning())
        {
                return false;
        }
        boost::asio::ip::tcp::resolver resolver(m_io_service);
        boost::asio::ip::tcp::resolver::query query(address, port);
        boost::asio::ip::tcp::endpoint endpoint = *resolver.resolve(query);
       
        m_acceptor.open(endpoint.protocol());
        m_acceptor.set_option(boost::asio::ip::tcp::acceptor::reuse_address(true)); // try without this later
        m_acceptor.bind(endpoint);
        return true;
}
template <typename Handler>
std::string Server<Handler>::getAddress() const
{
        return m_acceptor.local_endpoint().address().to_string();
}
template <typename Handler>
bool Server<Handler>::setPoolsize(unsigned size)
{
        if(isRunning())
        {
                return false;
        }
        m_pool_size = size;
        return true;
}
template <typename Handler>
unsigned Server<Handler>::getPoolsize() const
{
        return m_pool_size;
}

template <typename Handler>
boost::asio::io_service & Server<Handler>::getService()
{
        return m_io_service;
}
template <typename Handler>
const boost::asio::io_service & Server<Handler>::getService() const
{
        return m_io_service;
}
template <typename Handler>
boost::asio::ip::tcp::acceptor & Server<Handler>::getAcceptor()
{
        return m_acceptor;
}
template <typename Handler>
const boost::asio::ip::tcp::acceptor & Server<Handler>::getAcceptor() const
{
        return m_acceptor;
}
template <typename Handler>
bool Server<Handler>::isRunning() const
{
        return m_is_running;
}
template <typename Handler>
void Server<Handler>::stop()
{
        m_io_service.stop();
}
template <typename Handler>
void Server<Handler>::stopListen()
{
        m_acceptor.close();
}
template <typename Handler>
bool Server<Handler>::isListen()
{
        m_acceptor.is_open();
}
template <typename Handler>
void Server<Handler>::startListen()
{
        m_acceptor.listen();
}

template <typename Handler>
void Server<Handler>::startAccept()
{
        m_accept = true;
        m_acceptor.async_accept(*m_next_socket,
          boost::bind(&Server::handle_accept, this,
                boost::asio::placeholders::error));
}
template <typename Handler>
void Server<Handler>::secureStop()
{
        stopListen(); // should maybe be stopAccept(); instead
        while(isRunning())
        {
                boost::thread::yield();
        }
}

template <typename Handler>
void Server<Handler>::run()
{
        details::IsRunning<bool> isrunning(this->m_is_running);
       
        startListen();
        startAccept();
        details::ServiceInvoker invoker(this->m_io_service);
        std::vector<boost::shared_ptr<boost::thread> > threads;
        threads.reserve(m_pool_size-1);
        // the serviceinvoker class make sure the io_service will be invoked again if the io_service cast an exception
        for(int i = 0; i < m_pool_size-1; i++)
        {
                threads.push_back(boost::shared_ptr<boost::thread>(new boost::thread(boost::bind(&details::ServiceInvoker::run, &invoker))));
        }
        invoker.run();
        for (std::size_t i = 0; i < threads.size(); ++i)
        {
                threads[i]->join();
        }
        return;
}

template <typename Handler>
void Server<Handler>::handle_accept(const boost::system::error_code& error)
{
        if(error)
        {
                return;
        }
        m_handler.newConnection(m_next_socket);
       
        m_next_socket = new boost::asio::ip::tcp::socket(this->m_acceptor.io_service());
        if(m_accept)
        {
                m_acceptor.async_accept(*m_next_socket,
                        boost::bind(&Server::handle_accept, this,
                          boost::asio::placeholders::error));
        }
       
}

#endif

---

main.cpp

Code:

---

#include "server.hpp"
#include <iostream>


class ConnectionHandler
{
public:
        void init(Server<ConnectionHandler> & server)
        {
                std::cout << "Initialized" << std::endl;
                server.setAddress("localhost","9999");
        }
        void newConnection(boost::asio::ip::tcp::socket* p)
        {
                std::cout << "Connection..." << std::endl;
                delete p;
        }
private:
};



int main(int argc, char* argv[])
{
       

        try
        {
                const std::string host = "localhost";
                const std::string port = "8219";
                boost::asio::io_service io_service;

                ConnectionHandler handler;
                Server<ConnectionHandler> server(handler, io_service);
                server.run();
        }
        catch (std::exception& e)
        {
                std::cerr << e.what() << std::endl;
        }
        std::cin.get();
        return 0;
}

---

Mostly of the code did I wrote when I was tired so there is surely some logical bugs or something, but you get the point.


Thanks in advance!