server.h

/* Copyright (c) 2016, Human Brain Project
 *                     Stefan.Eilemann@epfl.ch
 */

#ifndef ZEROEQ_HTTP_SERVER_H
#define ZEROEQ_HTTP_SERVER_H

#include <zeroeq/receiver.h> // base class
#include <zeroeq/log.h>

namespace zeroeq
{
namespace http
{
class Server : public zeroeq::Receiver
{
public:
    ZEROEQ_API Server( const URI& uri, Receiver& shared );
    ZEROEQ_API explicit Server( const URI& uri );
    ZEROEQ_API explicit Server( Receiver& shared );
    ZEROEQ_API explicit Server();
    ZEROEQ_API explicit Server( Server& shared )
        : Server( static_cast< Receiver& >( shared )) {}
    ZEROEQ_API virtual ~Server();

    ZEROEQ_API static std::unique_ptr< Server > parse( int argc,
                                                       const char* const* argv);
    ZEROEQ_API static std::unique_ptr< Server > parse( int argc,
                                                       const char* const* argv,
                                                       Receiver& shared );
    ZEROEQ_API const URI& getURI() const;

    ZEROEQ_API SocketDescriptor getSocketDescriptor() const;

    bool add( servus::Serializable& object )
        { return subscribe( object ) && register_( object );}

    bool remove( const servus::Serializable& object )
        { return unsubscribe( object ) && unregister( object );}

    ZEROEQ_API bool subscribe( servus::Serializable& object );

    ZEROEQ_API bool subscribe( const std::string& event, const PUTFunc& func );

    ZEROEQ_API bool subscribe( const std::string& event,
                               const PUTPayloadFunc& func );

    ZEROEQ_API bool unsubscribe( const servus::Serializable& object );

    ZEROEQ_API bool unsubscribe( const std::string& event );

    ZEROEQ_API bool register_( servus::Serializable& object );

    ZEROEQ_API bool register_( const std::string& event, const GETFunc& func );

    ZEROEQ_API bool unregister( const servus::Serializable& object );

    ZEROEQ_API bool unregister( const std::string& event );

private:
    class Impl;
    std::unique_ptr< Impl > _impl;

    // Receiver API
    void addSockets( std::vector< detail::Socket >& entries ) final;
    void process( detail::Socket& socket, uint32_t timeout ) final;
    void addConnection( const std::string& ) final { ZEROEQDONTCALL; } // LCOV_EXCL_LINE
};
}
}

#endif