diff options
Diffstat (limited to 'src/test/src-gen/core/v1_0/fake/legacy')
6 files changed, 563 insertions, 0 deletions
diff --git a/src/test/src-gen/core/v1_0/fake/legacy/service/LegacyInterface.hpp b/src/test/src-gen/core/v1_0/fake/legacy/service/LegacyInterface.hpp new file mode 100644 index 0000000..e9efaf6 --- /dev/null +++ b/src/test/src-gen/core/v1_0/fake/legacy/service/LegacyInterface.hpp @@ -0,0 +1,54 @@ +/* +* This file was generated by the CommonAPI Generators. +* Used org.genivi.commonapi.core 3.1.2.v201506150834. +* Used org.franca.core 0.9.1.201412191134. +* +* 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/. +*/ +#ifndef FAKE_LEGACY_SERVICE_LEGACY_INTERFACE_HPP_ +#define FAKE_LEGACY_SERVICE_LEGACY_INTERFACE_HPP_ + + + + +#if !defined (COMMONAPI_INTERNAL_COMPILATION) +#define COMMONAPI_INTERNAL_COMPILATION +#endif + +#include <CommonAPI/Types.hpp> + +#undef COMMONAPI_INTERNAL_COMPILATION + +namespace v1_0 { +namespace fake { +namespace legacy { +namespace service { + +class LegacyInterface { +public: + virtual ~LegacyInterface() { } + + static inline const char* getInterface(); + static inline CommonAPI::Version getInterfaceVersion(); +}; + +const char* LegacyInterface::getInterface() { + return ("fake.legacy.service.LegacyInterface"); +} + +CommonAPI::Version LegacyInterface::getInterfaceVersion() { + return CommonAPI::Version(1, 0); +} + + +} // namespace service +} // namespace legacy +} // namespace fake +} // namespace v1_0 + +namespace CommonAPI { +} + +#endif // FAKE_LEGACY_SERVICE_LEGACY_INTERFACE_HPP_ diff --git a/src/test/src-gen/core/v1_0/fake/legacy/service/LegacyInterfaceProxy.hpp b/src/test/src-gen/core/v1_0/fake/legacy/service/LegacyInterfaceProxy.hpp new file mode 100644 index 0000000..d163090 --- /dev/null +++ b/src/test/src-gen/core/v1_0/fake/legacy/service/LegacyInterfaceProxy.hpp @@ -0,0 +1,211 @@ +/* +* This file was generated by the CommonAPI Generators. +* Used org.genivi.commonapi.core 3.1.2.v201506150834. +* Used org.franca.core 0.9.1.201412191134. +* +* 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/. +*/ +#ifndef FAKE_LEGACY_SERVICE_Legacy_Interface_PROXY_HPP_ +#define FAKE_LEGACY_SERVICE_Legacy_Interface_PROXY_HPP_ + +#include <v1_0/fake/legacy/service/LegacyInterfaceProxyBase.hpp> + + +#if !defined (COMMONAPI_INTERNAL_COMPILATION) +#define COMMONAPI_INTERNAL_COMPILATION +#endif + + +#undef COMMONAPI_INTERNAL_COMPILATION + +namespace v1_0 { +namespace fake { +namespace legacy { +namespace service { + +template <typename ... _AttributeExtensions> +class LegacyInterfaceProxy + : virtual public LegacyInterface, + virtual public LegacyInterfaceProxyBase, + public _AttributeExtensions... { +public: + LegacyInterfaceProxy(std::shared_ptr<CommonAPI::Proxy> delegate); + ~LegacyInterfaceProxy(); + + typedef LegacyInterface InterfaceType; + + + + + /** + * Calls TestMethod with synchronous semantics. + * + * All const parameters are input parameters to this method. + * All non-const parameters will be filled with the returned values. + * The CallStatus will be filled when the method returns and indicate either + * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus + * will be set. + */ + virtual void TestMethod(const int32_t &_input, CommonAPI::CallStatus &_status, int32_t &_val1, int32_t &_val2, const CommonAPI::CallInfo *_info = nullptr); + /** + * Calls TestMethod with asynchronous semantics. + * + * The provided callback will be called when the reply to this call arrives or + * an error occurs during the call. The CallStatus will indicate either "SUCCESS" + * or which type of error has occurred. In case of any error, ONLY the CallStatus + * will have a defined value. + * The std::future returned by this method will be fulfilled at arrival of the reply. + * It will provide the same value for CallStatus as will be handed to the callback. + */ + virtual std::future<CommonAPI::CallStatus> TestMethodAsync(const int32_t &_input, TestMethodAsyncCallback _callback, const CommonAPI::CallInfo *_info = nullptr); + /** + * Calls OtherTestMethod with synchronous semantics. + * + * All non-const parameters will be filled with the returned values. + * The CallStatus will be filled when the method returns and indicate either + * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus + * will be set. + */ + virtual void OtherTestMethod(CommonAPI::CallStatus &_status, std::string &_greeting, int32_t &_identifier, const CommonAPI::CallInfo *_info = nullptr); + /** + * Calls OtherTestMethod with asynchronous semantics. + * + * The provided callback will be called when the reply to this call arrives or + * an error occurs during the call. The CallStatus will indicate either "SUCCESS" + * or which type of error has occurred. In case of any error, ONLY the CallStatus + * will have a defined value. + * The std::future returned by this method will be fulfilled at arrival of the reply. + * It will provide the same value for CallStatus as will be handed to the callback. + */ + virtual std::future<CommonAPI::CallStatus> OtherTestMethodAsync(OtherTestMethodAsyncCallback _callback, const CommonAPI::CallInfo *_info = nullptr); + /** + * Calls finish with synchronous semantics. + * + * The CallStatus will be filled when the method returns and indicate either + * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus + * will be set. + */ + virtual void finish(CommonAPI::CallStatus &_status, const CommonAPI::CallInfo *_info = nullptr); + /** + * Calls finish with asynchronous semantics. + * + * The provided callback will be called when the reply to this call arrives or + * an error occurs during the call. The CallStatus will indicate either "SUCCESS" + * or which type of error has occurred. In case of any error, ONLY the CallStatus + * will have a defined value. + * The std::future returned by this method will be fulfilled at arrival of the reply. + * It will provide the same value for CallStatus as will be handed to the callback. + */ + virtual std::future<CommonAPI::CallStatus> finishAsync(FinishAsyncCallback _callback, const CommonAPI::CallInfo *_info = nullptr); + + + /** + * Returns the CommonAPI address of the remote partner this proxy communicates with. + */ + virtual const CommonAPI::Address &getAddress() const; + + /** + * Returns true if the remote partner for this proxy is currently known to be available. + */ + virtual bool isAvailable() const; + + /** + * Returns true if the remote partner for this proxy is available. + */ + virtual bool isAvailableBlocking() const; + + /** + * Returns the wrapper class that is used to (de-)register for notifications about + * the availability of the remote partner of this proxy. + */ + virtual CommonAPI::ProxyStatusEvent& getProxyStatusEvent(); + + /** + * Returns the wrapper class that is used to access version information of the remote + * partner of this proxy. + */ + virtual CommonAPI::InterfaceVersionAttribute& getInterfaceVersionAttribute(); + + private: + std::shared_ptr<LegacyInterfaceProxyBase> delegate_; +}; + +typedef LegacyInterfaceProxy<> LegacyInterfaceProxyDefault; + + +// +// LegacyInterfaceProxy Implementation +// +template <typename ... _AttributeExtensions> +LegacyInterfaceProxy<_AttributeExtensions...>::LegacyInterfaceProxy(std::shared_ptr<CommonAPI::Proxy> delegate): + _AttributeExtensions(*(std::dynamic_pointer_cast<LegacyInterfaceProxyBase>(delegate)))..., + delegate_(std::dynamic_pointer_cast<LegacyInterfaceProxyBase>(delegate)) { +} + +template <typename ... _AttributeExtensions> +LegacyInterfaceProxy<_AttributeExtensions...>::~LegacyInterfaceProxy() { +} + +template <typename ... _AttributeExtensions> +void LegacyInterfaceProxy<_AttributeExtensions...>::TestMethod(const int32_t &_input, CommonAPI::CallStatus &_status, int32_t &_val1, int32_t &_val2, const CommonAPI::CallInfo *_info) { + delegate_->TestMethod(_input, _status, _val1, _val2, _info); +} + +template <typename ... _AttributeExtensions> +std::future<CommonAPI::CallStatus> LegacyInterfaceProxy<_AttributeExtensions...>::TestMethodAsync(const int32_t &_input, TestMethodAsyncCallback _callback, const CommonAPI::CallInfo *_info) { + return delegate_->TestMethodAsync(_input, _callback, _info); +} +template <typename ... _AttributeExtensions> +void LegacyInterfaceProxy<_AttributeExtensions...>::OtherTestMethod(CommonAPI::CallStatus &_status, std::string &_greeting, int32_t &_identifier, const CommonAPI::CallInfo *_info) { + delegate_->OtherTestMethod(_status, _greeting, _identifier, _info); +} + +template <typename ... _AttributeExtensions> +std::future<CommonAPI::CallStatus> LegacyInterfaceProxy<_AttributeExtensions...>::OtherTestMethodAsync(OtherTestMethodAsyncCallback _callback, const CommonAPI::CallInfo *_info) { + return delegate_->OtherTestMethodAsync(_callback, _info); +} +template <typename ... _AttributeExtensions> +void LegacyInterfaceProxy<_AttributeExtensions...>::finish(CommonAPI::CallStatus &_status, const CommonAPI::CallInfo *_info) { + delegate_->finish(_status, _info); +} + +template <typename ... _AttributeExtensions> +std::future<CommonAPI::CallStatus> LegacyInterfaceProxy<_AttributeExtensions...>::finishAsync(FinishAsyncCallback _callback, const CommonAPI::CallInfo *_info) { + return delegate_->finishAsync(_callback, _info); +} + +template <typename ... _AttributeExtensions> +const CommonAPI::Address &LegacyInterfaceProxy<_AttributeExtensions...>::getAddress() const { + return delegate_->getAddress(); +} + +template <typename ... _AttributeExtensions> +bool LegacyInterfaceProxy<_AttributeExtensions...>::isAvailable() const { + return delegate_->isAvailable(); +} + +template <typename ... _AttributeExtensions> +bool LegacyInterfaceProxy<_AttributeExtensions...>::isAvailableBlocking() const { + return delegate_->isAvailableBlocking(); +} + +template <typename ... _AttributeExtensions> +CommonAPI::ProxyStatusEvent& LegacyInterfaceProxy<_AttributeExtensions...>::getProxyStatusEvent() { + return delegate_->getProxyStatusEvent(); +} + +template <typename ... _AttributeExtensions> +CommonAPI::InterfaceVersionAttribute& LegacyInterfaceProxy<_AttributeExtensions...>::getInterfaceVersionAttribute() { + return delegate_->getInterfaceVersionAttribute(); +} + + +} // namespace service +} // namespace legacy +} // namespace fake +} // namespace v1_0 + + +#endif // FAKE_LEGACY_SERVICE_Legacy_Interface_PROXY_HPP_ diff --git a/src/test/src-gen/core/v1_0/fake/legacy/service/LegacyInterfaceProxyBase.hpp b/src/test/src-gen/core/v1_0/fake/legacy/service/LegacyInterfaceProxyBase.hpp new file mode 100644 index 0000000..62d43e5 --- /dev/null +++ b/src/test/src-gen/core/v1_0/fake/legacy/service/LegacyInterfaceProxyBase.hpp @@ -0,0 +1,57 @@ +/* +* This file was generated by the CommonAPI Generators. +* Used org.genivi.commonapi.core 3.1.2.v201506150834. +* Used org.franca.core 0.9.1.201412191134. +* +* 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/. +*/ +#ifndef FAKE_LEGACY_SERVICE_Legacy_Interface_PROXY_BASE_HPP_ +#define FAKE_LEGACY_SERVICE_Legacy_Interface_PROXY_BASE_HPP_ + +#include <v1_0/fake/legacy/service/LegacyInterface.hpp> + + + +#if !defined (COMMONAPI_INTERNAL_COMPILATION) +#define COMMONAPI_INTERNAL_COMPILATION +#endif + +#include <vector> + +#include <CommonAPI/Proxy.hpp> +#include <functional> +#include <future> + +#undef COMMONAPI_INTERNAL_COMPILATION + +namespace v1_0 { +namespace fake { +namespace legacy { +namespace service { + +class LegacyInterfaceProxyBase + : virtual public CommonAPI::Proxy { +public: + + typedef std::function<void(const CommonAPI::CallStatus&, const int32_t&, const int32_t&)> TestMethodAsyncCallback; + typedef std::function<void(const CommonAPI::CallStatus&, const std::string&, const int32_t&)> OtherTestMethodAsyncCallback; + typedef std::function<void(const CommonAPI::CallStatus&)> FinishAsyncCallback; + + + + virtual void TestMethod(const int32_t &_input, CommonAPI::CallStatus &_status, int32_t &_val1, int32_t &_val2, const CommonAPI::CallInfo *_info = nullptr) = 0; + virtual std::future<CommonAPI::CallStatus> TestMethodAsync(const int32_t &_input, TestMethodAsyncCallback _callback, const CommonAPI::CallInfo *_info = nullptr) = 0; + virtual void OtherTestMethod(CommonAPI::CallStatus &_status, std::string &_greeting, int32_t &_identifier, const CommonAPI::CallInfo *_info = nullptr) = 0; + virtual std::future<CommonAPI::CallStatus> OtherTestMethodAsync(OtherTestMethodAsyncCallback _callback, const CommonAPI::CallInfo *_info = nullptr) = 0; + virtual void finish(CommonAPI::CallStatus &_status, const CommonAPI::CallInfo *_info = nullptr) = 0; + virtual std::future<CommonAPI::CallStatus> finishAsync(FinishAsyncCallback _callback, const CommonAPI::CallInfo *_info = nullptr) = 0; +}; + +} // namespace service +} // namespace legacy +} // namespace fake +} // namespace v1_0 + +#endif // FAKE_LEGACY_SERVICE_Legacy_Interface_PROXY_BASE_HPP_ diff --git a/src/test/src-gen/core/v1_0/fake/legacy/service/LegacyInterfaceStub.hpp b/src/test/src-gen/core/v1_0/fake/legacy/service/LegacyInterfaceStub.hpp new file mode 100644 index 0000000..f38834c --- /dev/null +++ b/src/test/src-gen/core/v1_0/fake/legacy/service/LegacyInterfaceStub.hpp @@ -0,0 +1,112 @@ +/* +* This file was generated by the CommonAPI Generators. +* Used org.genivi.commonapi.core 3.1.2.v201506150834. +* Used org.franca.core 0.9.1.201412191134. +* +* 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/. +*/ +#ifndef FAKE_LEGACY_SERVICE_Legacy_Interface_STUB_HPP_ +#define FAKE_LEGACY_SERVICE_Legacy_Interface_STUB_HPP_ + +#include <functional> + + + + +#include <v1_0/fake/legacy/service/LegacyInterface.hpp> + +#if !defined (COMMONAPI_INTERNAL_COMPILATION) +#define COMMONAPI_INTERNAL_COMPILATION +#endif + +#include <vector> + +#include <CommonAPI/Stub.hpp> + +#undef COMMONAPI_INTERNAL_COMPILATION + +namespace v1_0 { +namespace fake { +namespace legacy { +namespace service { + +/** + * Receives messages from remote and handles all dispatching of deserialized calls + * to a stub for the service LegacyInterface. Also provides means to send broadcasts + * and attribute-changed-notifications of observable attributes as defined by this service. + * An application developer should not need to bother with this class. + */ +class LegacyInterfaceStubAdapter + : virtual public CommonAPI::StubAdapter, + public LegacyInterface { + public: + + + + virtual void deactivateManagedInstances() = 0; +protected: + /** + * Defines properties for storing the ClientIds of clients / proxies that have + * subscribed to the selective broadcasts + */ +}; + +/** + * Defines the necessary callbacks to handle remote set events related to the attributes + * defined in the IDL description for LegacyInterface. + * For each attribute two callbacks are defined: + * - a verification callback that allows to verify the requested value and to prevent setting + * e.g. an invalid value ("onRemoteSet<AttributeName>"). + * - an action callback to do local work after the attribute value has been changed + * ("onRemote<AttributeName>Changed"). + * + * This class and the one below are the ones an application developer needs to have + * a look at if he wants to implement a service. + */ +class LegacyInterfaceStubRemoteEvent +{ +public: + virtual ~LegacyInterfaceStubRemoteEvent() { } + +}; + +/** + * Defines the interface that must be implemented by any class that should provide + * the service LegacyInterface to remote clients. + * This class and the one above are the ones an application developer needs to have + * a look at if he wants to implement a service. + */ +class LegacyInterfaceStub + : public virtual CommonAPI::Stub<LegacyInterfaceStubAdapter, LegacyInterfaceStubRemoteEvent> +{ +public: + typedef std::function<void (int32_t _val1, int32_t _val2)>TestMethodReply_t; + typedef std::function<void (std::string _greeting, int32_t _identifier)>OtherTestMethodReply_t; + typedef std::function<void ()>finishReply_t; + + virtual ~LegacyInterfaceStub() {} + virtual const CommonAPI::Version& getInterfaceVersion(std::shared_ptr<CommonAPI::ClientId> clientId) = 0; + + + /// This is the method that will be called on remote calls on the method TestMethod. + virtual void TestMethod(const std::shared_ptr<CommonAPI::ClientId> _client, int32_t _input, TestMethodReply_t _reply) = 0; + /// This is the method that will be called on remote calls on the method OtherTestMethod. + virtual void OtherTestMethod(const std::shared_ptr<CommonAPI::ClientId> _client, OtherTestMethodReply_t _reply) = 0; + /// This is the method that will be called on remote calls on the method finish. + virtual void finish(const std::shared_ptr<CommonAPI::ClientId> _client, finishReply_t _reply) = 0; + + using CommonAPI::Stub<LegacyInterfaceStubAdapter, LegacyInterfaceStubRemoteEvent>::initStubAdapter; + typedef CommonAPI::Stub<LegacyInterfaceStubAdapter, LegacyInterfaceStubRemoteEvent>::StubAdapterType StubAdapterType; + typedef CommonAPI::Stub<LegacyInterfaceStubAdapter, LegacyInterfaceStubRemoteEvent>::RemoteEventHandlerType RemoteEventHandlerType; + typedef LegacyInterfaceStubRemoteEvent RemoteEventType; + typedef LegacyInterface StubInterface; +}; + +} // namespace service +} // namespace legacy +} // namespace fake +} // namespace v1_0 + +#endif // FAKE_LEGACY_SERVICE_Legacy_Interface_STUB_HPP_ diff --git a/src/test/src-gen/core/v1_0/fake/legacy/service/LegacyInterfaceStubDefault.cpp b/src/test/src-gen/core/v1_0/fake/legacy/service/LegacyInterfaceStubDefault.cpp new file mode 100644 index 0000000..e9e58f0 --- /dev/null +++ b/src/test/src-gen/core/v1_0/fake/legacy/service/LegacyInterfaceStubDefault.cpp @@ -0,0 +1,60 @@ +/* +* This file was generated by the CommonAPI Generators. +* Used org.genivi.commonapi.core 3.1.2.v201506150834. +* Used org.franca.core 0.9.1.201412191134. +* +* 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/. +*/ +#include <v1_0/fake/legacy/service/LegacyInterfaceStubDefault.hpp> +#include <assert.h> + +namespace v1_0 { +namespace fake { +namespace legacy { +namespace service { + +LegacyInterfaceStubDefault::LegacyInterfaceStubDefault(): + remoteEventHandler_(this), + interfaceVersion_(LegacyInterface::getInterfaceVersion()) { +} + +const CommonAPI::Version& LegacyInterfaceStubDefault::getInterfaceVersion(std::shared_ptr<CommonAPI::ClientId> _client) { + return interfaceVersion_; +} + +LegacyInterfaceStubRemoteEvent* LegacyInterfaceStubDefault::initStubAdapter(const std::shared_ptr<LegacyInterfaceStubAdapter> &_adapter) { + CommonAPI::Stub<LegacyInterfaceStubAdapter, LegacyInterfaceStubRemoteEvent>::stubAdapter_ = _adapter; + return &remoteEventHandler_; +} + + +void LegacyInterfaceStubDefault::TestMethod(const std::shared_ptr<CommonAPI::ClientId> _client, int32_t _input, TestMethodReply_t _reply) { + int32_t val1 = 0; + int32_t val2 = 0; + _reply(val1, val2); +} + +void LegacyInterfaceStubDefault::OtherTestMethod(const std::shared_ptr<CommonAPI::ClientId> _client, OtherTestMethodReply_t _reply) { + std::string greeting = ""; + int32_t identifier = 0; + _reply(greeting, identifier); +} + +void LegacyInterfaceStubDefault::finish(const std::shared_ptr<CommonAPI::ClientId> _client, finishReply_t _reply) { + _reply(); +} + + + + +LegacyInterfaceStubDefault::RemoteEventHandler::RemoteEventHandler(LegacyInterfaceStubDefault *_defaultStub) + : + defaultStub_(_defaultStub) { +} + +} // namespace service +} // namespace legacy +} // namespace fake +} // namespace v1_0 diff --git a/src/test/src-gen/core/v1_0/fake/legacy/service/LegacyInterfaceStubDefault.hpp b/src/test/src-gen/core/v1_0/fake/legacy/service/LegacyInterfaceStubDefault.hpp new file mode 100644 index 0000000..4326894 --- /dev/null +++ b/src/test/src-gen/core/v1_0/fake/legacy/service/LegacyInterfaceStubDefault.hpp @@ -0,0 +1,69 @@ +/* +* This file was generated by the CommonAPI Generators. +* Used org.genivi.commonapi.core 3.1.2.v201506150834. +* Used org.franca.core 0.9.1.201412191134. +* +* 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/. +*/ +#ifndef FAKE_LEGACY_SERVICE_Legacy_Interface_STUB_DEFAULT_HPP_ +#define FAKE_LEGACY_SERVICE_Legacy_Interface_STUB_DEFAULT_HPP_ + + +#include <v1_0/fake/legacy/service/LegacyInterfaceStub.hpp> +#include <sstream> + +namespace v1_0 { +namespace fake { +namespace legacy { +namespace service { + +/** + * Provides a default implementation for LegacyInterfaceStubRemoteEvent and + * LegacyInterfaceStub. Method callbacks have an empty implementation, + * remote set calls on attributes will always change the value of the attribute + * to the one received. + * + * Override this stub if you only want to provide a subset of the functionality + * that would be defined for this service, and/or if you do not need any non-default + * behaviour. + */ +class LegacyInterfaceStubDefault + : public virtual LegacyInterfaceStub { +public: + LegacyInterfaceStubDefault(); + + LegacyInterfaceStubRemoteEvent* initStubAdapter(const std::shared_ptr<LegacyInterfaceStubAdapter> &_adapter); + + const CommonAPI::Version& getInterfaceVersion(std::shared_ptr<CommonAPI::ClientId> _client); + + + virtual void TestMethod(const std::shared_ptr<CommonAPI::ClientId> _client, int32_t _input, TestMethodReply_t _reply); + virtual void OtherTestMethod(const std::shared_ptr<CommonAPI::ClientId> _client, OtherTestMethodReply_t _reply); + virtual void finish(const std::shared_ptr<CommonAPI::ClientId> _client, finishReply_t _reply); + + + +protected: + class RemoteEventHandler: public virtual LegacyInterfaceStubRemoteEvent { + public: + RemoteEventHandler(LegacyInterfaceStubDefault *_defaultStub); + + + private: + LegacyInterfaceStubDefault *defaultStub_; + }; +private: + LegacyInterfaceStubDefault::RemoteEventHandler remoteEventHandler_; + + + CommonAPI::Version interfaceVersion_; +}; + +} // namespace service +} // namespace legacy +} // namespace fake +} // namespace v1_0 + +#endif // FAKE_LEGACY_SERVICE_Legacy_Interface_STUB_DEFAULT |