service_server.h

#ifndef B0__SERVICE_SERVER_H__INCLUDED
#define B0__SERVICE_SERVER_H__INCLUDED

#include <string>

#include <boost/function.hpp>
#include <boost/bind.hpp>

#include <b0/socket.h>

namespace b0
{

class Node;

class ServiceServer : public Socket
{
public:
    using logger::LogInterface::log;

    ServiceServer(Node *node, std::string service_name, boost::function<void(const std::string&, std::string&)> callback = 0, bool managed = true, bool notify_graph = true);

    template<class TNode>
    ServiceServer(TNode *node, std::string service_name, void (TNode::*callbackMethod)(const std::string&, std::string&), bool managed = true, bool notify_graph = true)
        : ServiceServer(node, service_name, boost::bind(callbackMethod, node, _1, _2), managed, notify_graph)
    {
        // delegate constructor. leave empty
    }

    template<class T>
    ServiceServer(Node *node, std::string service_name, void (T::*callbackMethod)(const std::string&, std::string&), T *callbackObject, bool managed = true, bool notify_graph = true)
        : ServiceServer(node, service_name, boost::bind(callbackMethod, callbackObject, _1, _2), managed, notify_graph)
    {
        // delegate constructor. leave empty
    }

    virtual ~ServiceServer();

    void log(LogLevel level, std::string message) const override;

    virtual void init() override;

    virtual void cleanup() override;

    virtual void spinOnce() override;

    std::string getServiceName();

    virtual void bind(std::string address);

protected:
    virtual void bind();

    virtual void unbind();

    virtual void announce();

    std::string bind_addr_;

    const bool notify_graph_;

    boost::function<void(const std::string&, std::string&)> callback_;
};

} // namespace b0

#endif // B0__SERVICE_SERVER_H__INCLUDED