aboutsummaryrefslogtreecommitdiff
path: root/components/service/locator/standalone/standalone_service_context.cpp
blob: 5e53ebe2bac78a37e8312373961fa1436768e6f4 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
/*
 * Copyright (c) 2020, Arm Limited and Contributors. All rights reserved.
 *
 * SPDX-License-Identifier: BSD-3-Clause
 */

#include "standalone_service_context.h"
#include <cassert>

/* Concrete C service_context methods */
static rpc_session_handle standalone_service_context_open(void *context, struct rpc_caller **caller);
static void standalone_service_context_close(void *context, rpc_session_handle session_handle);
static void standalone_service_context_relinquish(void *context);


standalone_service_context::standalone_service_context(const char *sn) :
    m_sn(sn),
    m_ref_count(0),
    m_service_context(),
    m_call_ep(NULL)
{
    m_service_context.context = this;
    m_service_context.open = standalone_service_context_open;
    m_service_context.close = standalone_service_context_close;
    m_service_context.relinquish = standalone_service_context_relinquish;
}

standalone_service_context::~standalone_service_context()
{

}

void standalone_service_context::init()
{
    assert(m_ref_count >= 0);

    if (!m_ref_count) do_init();
    ++m_ref_count;
}

void standalone_service_context::deinit()
{
    assert(m_ref_count > 0);

    --m_ref_count;
    if (!m_ref_count) do_deinit();
}

rpc_session_handle standalone_service_context::open(struct rpc_caller **caller)
{
    struct rpc_session *session = new rpc_session(m_call_ep);
    *caller = session->m_rpc_caller;
    return static_cast<rpc_session_handle>(session);
}

void standalone_service_context::close(rpc_session_handle session_handle)
{
    struct rpc_session *session = reinterpret_cast<struct rpc_session*>(session_handle);
    delete session;
}

const std::string &standalone_service_context::get_service_name() const
{
    return m_sn;
}

struct service_context *standalone_service_context::get_service_context()
{
    return &m_service_context;
}

void standalone_service_context::set_call_ep(call_ep *ep)
{
    m_call_ep = ep;
}

standalone_service_context::rpc_session::rpc_session(struct call_ep *call_ep) :
    m_direct_caller(),
    m_rpc_caller()
{
    m_rpc_caller = direct_caller_init_default(&m_direct_caller, call_ep);
}

standalone_service_context::rpc_session::~rpc_session()
{
    direct_caller_deinit(&m_direct_caller);
}

static rpc_session_handle standalone_service_context_open(void *context, struct rpc_caller **caller)
{
    rpc_session_handle handle = NULL;
    standalone_service_context *this_context = reinterpret_cast<standalone_service_context*>(context);

    if (this_context) {
        handle = this_context->open(caller);
    }

    return handle;
}

static void standalone_service_context_close(void *context, rpc_session_handle session_handle)
{
    standalone_service_context *this_context = reinterpret_cast<standalone_service_context*>(context);

    if (this_context) {
        this_context->close(session_handle);
    }
}

static void standalone_service_context_relinquish(void *context)
{
    standalone_service_context *this_context = reinterpret_cast<standalone_service_context*>(context);

    if (this_context) {
        this_context->deinit();
    }
}