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
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
|
/* Copyright (C) 2013 BMW Group
* Author: Manfred Bathelt (manfred.bathelt@bmw.de)
* Author: Juergen Gehring (juergen.gehring@bmw.de)
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#if !defined (COMMONAPI_INTERNAL_COMPILATION)
#error "Only <CommonAPI/CommonAPI.h> can be included directly, this file may disappear or change contents."
#endif
#ifndef COMMONAPI_RUNTIME_H_
#define COMMONAPI_RUNTIME_H_
#include "MiddlewareInfo.h"
#include "MainLoopContext.h"
#include <memory>
#include <fstream>
#include <unordered_map>
#include <dlfcn.h>
#include <string>
#include <cassert>
#include <cstring>
namespace CommonAPI {
class Factory;
class Runtime;
class MainLoopContext;
class ServicePublisher;
/**
* \brief Represents the CommonAPI runtime bindings available.
*
* Represents the CommonAPI runtime bindings available.
*/
class Runtime {
public:
/**
* \brief Loads the default runtime.
*
* Loads the runtime for the default middleware binding. This either is the only binding available,
* or the one defined as default in the configuration.
*
* @return The runtime object for the default binding
*/
static std::shared_ptr<Runtime> load();
/**
* \brief Loads specified runtime.
*
* Loads the runtime for the specified middleware binding. The given middleware ID can be either
* the well known name defined by a binding, or a configured alias for a binding.
*
* @return The runtime object for specified binding
*/
static std::shared_ptr<Runtime> load(const std::string& middlewareId);
/**
* \brief Called by bindings to register their runtime loaders. Do not call from applications.
*
* Called by bindings to register their runtime loaders. Do not call from applications.
*/
static void registerRuntimeLoader(std::string middlewareName, MiddlewareRuntimeLoadFunction middlewareRuntimeLoadFunction);
virtual ~Runtime() {}
/**
* \brief Returns new MainLoopContext
*
* Creates and returns a new MainLoopContext object. This context can be used to take
* complete control over the order and time of execution of the abstract middleware
* dispatching mechanism.
*
* @return A new MainLoopContext object
*/
std::shared_ptr<MainLoopContext> getNewMainLoopContext() const;
/**
* \brief Create a factory for the loaded runtime.
*
* Create a factory for the loaded runtime
*
* @param mainLoopContext: In case mainloop integration shall be used, a std::shared_ptr<MainLoopContext> can be passed in.
* If no parameter is given, internal threading will handle sending and receiving of messages automatically.
* If the mainloop context is not initialized, no factory will be returned. See documentation of
* MainLoopContext::isInitialized().
*
* @param factoryName: If additional configuration parameters for the specific middleware factory shall be provided,
* the appropriate set of parameters may be identified by this name. See accompanying documentation for
* usage of configuration files.
*
* @param nullOnInvalidName: If a factoryName is provided, this parameter determines whether the standard configuration
* for factories shall be used if the specific parameter set cannot be found, or if instead no factory
* shall be returned in this case.
*
* @return Factory object for this runtime
*/
virtual std::shared_ptr<Factory> createFactory(std::shared_ptr<MainLoopContext> mainLoopContext = std::shared_ptr<MainLoopContext>(NULL),
const std::string factoryName = "",
const bool nullOnInvalidName = false);
/**
* \brief Create a factory for the loaded runtime.
*
* Create a factory for the loaded runtime
*
* @param factoryName: If additional configuration parameters for the specific middleware factory shall be provided,
* the appropriate set of parameters may be identified by this name. See accompanying documentation for
* usage of configuration files.
*
* @param nullOnInvalidName: If a factoryName is provided, this parameter determines whether the standard configuration
* for factories shall be used if the specific parameter set cannot be found, or if instead no factory
* shall be returned in this case.
*
* @return Factory object for this runtime
*/
virtual std::shared_ptr<Factory> createFactory(const std::string factoryNamey,
const bool nullOnInvalidName = false);
/**
* \brief Returns the ServicePublisher object for this runtime.
*
* Returns the ServicePublisher object for this runtime. Use the interface
* provided by the ServicePublisher to publish and de-publish the services that
* your application will provide to the outside world over the middleware
* represented by this runtime. A ServicePublisher exists once per middleware.
*
* @return The ServicePublisher object for this runtime
*/
virtual std::shared_ptr<ServicePublisher> getServicePublisher() = 0;
protected:
virtual std::shared_ptr<Factory> doCreateFactory(std::shared_ptr<MainLoopContext> mainLoopContext,
const std::string factoryName,
const bool nullOnInvalidName = false) = 0;
};
} // namespace CommonAPI
#endif // COMMONAPI_RUNTIME_H_
|
