erpc_client_manager.h

Go to the documentation of this file.

/*
 * Copyright (c) 2014-2016, Freescale Semiconductor, Inc.
 * Copyright 2016-2017 NXP
 * Copyright 2020-2021 ACRIOS Systems s.r.o.
 * All rights reserved.
 *
 *
 * SPDX-License-Identifier: BSD-3-Clause
 */

#ifndef _EMBEDDED_RPC__CLIENT_MANAGER_H_
#define _EMBEDDED_RPC__CLIENT_MANAGER_H_

#ifdef __cplusplus
#include "erpc_client_server_common.hpp"
#if ERPC_NESTED_CALLS
#include "erpc_server.hpp"
#include "erpc_threading.h"
#endif

extern "C" {
#else
#include "erpc_common.h"
#endif

typedef void (*client_error_handler_t)(erpc_status_t err,
                                       uint32_t functionID); 
typedef struct ClientType *erpc_client_t;

#ifdef __cplusplus
}

// Classes

namespace erpc {
class RequestContext;
#if ERPC_NESTED_CALLS
class Server;
#endif

class ClientManager : public ClientServerCommon
{
public:
    ClientManager(void) :
    ClientServerCommon(), m_sequence(0), m_errorHandler(NULL)
#if ERPC_NESTED_CALLS
    ,
    m_server(NULL), m_serverThreadId(NULL)
#endif
    {
    }

    virtual ~ClientManager(void) {}

    virtual RequestContext createRequest(bool isOneway);

    virtual void performRequest(RequestContext &request);

    virtual void releaseRequest(RequestContext &request);

    void setErrorHandler(client_error_handler_t error_handler) { m_errorHandler = error_handler; }

    void callErrorHandler(erpc_status_t err, uint32_t functionID);

#if ERPC_NESTED_CALLS

    void setServer(Server *server) { m_server = server; }

    void setServerThreadId(Thread::thread_id_t serverThreadId) { m_serverThreadId = serverThreadId; }
#endif

protected:
    uint32_t m_sequence;                   
    client_error_handler_t m_errorHandler; 
#if ERPC_NESTED_CALLS
    Server *m_server;                     
    Thread::thread_id_t m_serverThreadId; 
#endif

    virtual void performClientRequest(RequestContext &request);

#if ERPC_NESTED_CALLS

    virtual void performNestedClientRequest(RequestContext &request);
#endif

    virtual void verifyReply(RequestContext &request);

    Codec *createBufferAndCodec(void);

private:
    ClientManager(const ClientManager &other);            
    ClientManager &operator=(const ClientManager &other); 
};

class RequestContext
{
public:
    RequestContext(uint32_t sequence, Codec *codec, bool argIsOneway) :
    m_sequence(sequence), m_codec(codec), m_oneway(argIsOneway)
    {
    }

    Codec *getCodec(void) { return m_codec; }

    uint32_t getSequence(void) const { return m_sequence; }

    bool isOneway(void) const { return m_oneway; }

    void setIsOneway(bool oneway) { m_oneway = oneway; }

protected:
    uint32_t m_sequence; 
    Codec *m_codec;      
    bool m_oneway;       
};

} // namespace erpc

#endif

#endif // _EMBEDDED_RPC__CLIENT_MANAGER_H_