client.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_CLIENT_HPP
#define CARGO_IPC_CLIENT_HPP

#include "cargo-ipc/internals/processor.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 Client {
public:
    Client(epoll::EventPoll& eventPoll, const std::string& serverPath);
    ~Client();

    Client(const Client&) = delete;
    Client& operator=(const Client&) = 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& signal);

    void removeMethod(const MethodID methodID);

    bool isHandled(const MethodID methodID);

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

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


    template<typename SentDataType, typename ReceivedDataType>
    void callAsyncFromCallback(const MethodID methodID,
                               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;
    PeerID mServiceID;
    Processor mProcessor;
    std::string mSocketPath;

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

};

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

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

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

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

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

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

} // namespace ipc
} // namespace cargo

#endif // CARGO_IPC_CLIENT_HPP