http/server.h

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

#ifndef ZEROEQ_HTTP_SERVER_H
#define ZEROEQ_HTTP_SERVER_H

#include <zeroeq/http/api.h>
#include <zeroeq/http/request.h>
#include <zeroeq/http/types.h>

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

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

    ZEROEQHTTP_API ~Server();

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

    ZEROEQHTTP_API SocketDescriptor getSocketDescriptor() const;

    bool handle(Method method, const std::string& endpoint, RESTFunc func);

    bool handle(servus::Serializable& object)
    {
        return handlePUT(object) && handleGET(object);
    }

    ZEROEQHTTP_API bool handle(const std::string& endpoint,
                               servus::Serializable& object);

    ZEROEQHTTP_API bool remove(const servus::Serializable& object);

    ZEROEQHTTP_API bool remove(const std::string& endpoint);

    ZEROEQHTTP_API bool handlePUT(servus::Serializable& object);

    ZEROEQHTTP_API bool handlePUT(const std::string& endpoint,
                                  servus::Serializable& object);

    ZEROEQHTTP_API
    bool handlePUT(const std::string& endpoint, const PUTFunc& func);

    ZEROEQHTTP_API bool handlePUT(const std::string& endpoint,
                                  const std::string& schema,
                                  const PUTFunc& func);

    ZEROEQHTTP_API bool handlePUT(const std::string& endpoint,
                                  const PUTPayloadFunc& func);

    ZEROEQHTTP_API bool handlePUT(const std::string& endpoint,
                                  const std::string& schema,
                                  const PUTPayloadFunc& func);
    ZEROEQHTTP_API bool handleGET(const servus::Serializable& object);

    ZEROEQHTTP_API bool handleGET(const std::string& endpoint,
                                  const servus::Serializable& object);

    ZEROEQHTTP_API
    bool handleGET(const std::string& endpoint, const GETFunc& func);

    ZEROEQHTTP_API
    bool handleGET(const std::string& endpoint, const std::string& schema,
                   const GETFunc& func);

    ZEROEQHTTP_API
    std::string getSchema(const servus::Serializable& object) const;

    ZEROEQHTTP_API std::string getSchema(const std::string& endpoint) const;

protected:
    virtual std::future<Response> respondTo(Request& request) const;

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

    // Receiver API
    void addSockets(std::vector<detail::Socket>& entries) final;
    bool process(detail::Socket& socket) final;
};
}
}

#endif