service.hpp

Go to the documentation of this file.

/*
*  Copyright (c) 2015 Samsung Electronics Co., Ltd All Rights Reserved
*
*  Contact: Jan Olszak <j.olszak@samsung.com>
*
*  Licensed under the Apache License, Version 2.0 (the "License");
*  you may not use this file except in compliance with the License.
*  You may obtain a copy of the License at
*
*      http://www.apache.org/licenses/LICENSE-2.0
*
*  Unless required by applicable law or agreed to in writing, software
*  distributed under the License is distributed on an "AS IS" BASIS,
*  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*  See the License for the specific language governing permissions and
*  limitations under the License
*/

#ifndef CARGO_IPC_SERVICE_HPP
#define CARGO_IPC_SERVICE_HPP

#include "cargo-ipc/internals/processor.hpp"
#include "cargo-ipc/internals/acceptor.hpp"
#include "cargo-ipc/types.hpp"
#include "cargo-ipc/result.hpp"
#include "epoll/event-poll.hpp"
#include "logger/logger.hpp"

#include <string>

namespace cargo {
namespace ipc {


class Service {
public:
    Service(epoll::EventPoll& eventPoll,
            const std::string& path,
            const PeerCallback& addPeerCallback = nullptr,
            const PeerCallback& removePeerCallback = nullptr);
    virtual ~Service();

    Service(const Service&) = delete;
    Service& operator=(const Service&) = delete;

    void start();

    bool isStarted();

    void stop(bool wait = true);

    void setNewPeerCallback(const PeerCallback& newPeerCallback);

    void setRemovedPeerCallback(const PeerCallback& removedPeerCallback);

    template<typename SentDataType, typename ReceivedDataType>
    void setMethodHandler(const MethodID methodID,
                          const typename MethodHandler<SentDataType, ReceivedDataType>::type& method);

    template<typename ReceivedDataType>
    void setSignalHandler(const MethodID methodID,
                          const typename SignalHandler<ReceivedDataType>::type& handler);

    void removeMethod(const MethodID methodID);

    bool isHandled(const MethodID methodID);

    template<typename SentDataType, typename ReceivedDataType>
    std::shared_ptr<ReceivedDataType> callSync(const MethodID methodID,
                                               const PeerID& peerID,
                                               const std::shared_ptr<SentDataType>& data,
                                               unsigned int timeoutMS = 5000);

    template<typename SentDataType, typename ReceivedDataType>
    void callAsync(const MethodID methodID,
                   const PeerID& peerID,
                   const std::shared_ptr<SentDataType>& data,
                   const typename ResultHandler<ReceivedDataType>::type& resultCallback =  nullptr);

    template<typename SentDataType, typename ReceivedDataType>
    void callAsyncFromCallback(const MethodID methodID,
                               const PeerID& peerID,
                               const std::shared_ptr<SentDataType>& data,
                               const typename ResultHandler<ReceivedDataType>::type& resultCallback  =  nullptr);

    template<typename SentDataType>
    void signal(const MethodID methodID,
                const std::shared_ptr<SentDataType>& data);
private:
    epoll::EventPoll& mEventPoll;
    Processor mProcessor;
    Acceptor mAcceptor;

    void handle(const FileDescriptor fd, const epoll::Events pollEvents);
};


template<typename SentDataType, typename ReceivedDataType>
void Service::setMethodHandler(const MethodID methodID,
                               const typename MethodHandler<SentDataType, ReceivedDataType>::type& method)
{
    LOGS("Service setMethodHandler, methodID " << methodID);
    mProcessor.setMethodHandler<SentDataType, ReceivedDataType>(methodID, method);
}

template<typename ReceivedDataType>
void Service::setSignalHandler(const MethodID methodID,
                               const typename SignalHandler<ReceivedDataType>::type& handler)
{
    LOGS("Service setSignalHandler, methodID " << methodID);
    mProcessor.setSignalHandler<ReceivedDataType>(methodID, handler);
}

template<typename SentDataType, typename ReceivedDataType>
std::shared_ptr<ReceivedDataType> Service::callSync(const MethodID methodID,
                                                    const PeerID& peerID,
                                                    const std::shared_ptr<SentDataType>& data,
                                                    unsigned int timeoutMS)
{
    LOGS("Service callSync, methodID: " << methodID
         << ", peerID: " << peerID
         << ", timeoutMS: " << timeoutMS);
    return mProcessor.callSync<SentDataType, ReceivedDataType>(methodID, peerID, data, timeoutMS);
}

template<typename SentDataType, typename ReceivedDataType>
void Service::callAsync(const MethodID methodID,
                        const PeerID& peerID,
                        const std::shared_ptr<SentDataType>& data,
                        const typename ResultHandler<ReceivedDataType>::type& resultCallback)
{
    LOGS("Service callAsync, methodID: " << methodID << ", peerID: " << peerID);
    mProcessor.callAsync<SentDataType,
                         ReceivedDataType>(methodID,
                                           peerID,
                                           data,
                                           resultCallback);
}

template<typename SentDataType, typename ReceivedDataType>
void Service::callAsyncFromCallback(const MethodID methodID,
                                    const PeerID& peerID,
                                    const std::shared_ptr<SentDataType>& data,
                                    const typename ResultHandler<ReceivedDataType>::type& resultCallback)
{
    LOGS("Service callAsyncFromCallback, methodID: " << methodID << ", peerID: " << peerID);
    mProcessor.callAsyncNonBlock<SentDataType,
                                 ReceivedDataType>(methodID,
                                                   peerID,
                                                   data,
                                                   resultCallback);
}


template<typename SentDataType>
void Service::signal(const MethodID methodID,
                     const std::shared_ptr<SentDataType>& data)
{
    LOGS("Service signal, methodID: " << methodID);
    mProcessor.signal<SentDataType>(methodID, data);
}

} // namespace ipc
} // namespace cargo

#endif // CARGO_IPC_SERVICE_HPP