Classe Reference#

This section contains all classes tagged with @api.

class ComErrorDomain : public score::result::ErrorDomain#

Error domain for mw::com (CommunicationManagement).

Feature API:

This class implements the ErrorDomain interface for the mw::com API. \requirement SWS_CM_11329 \threadsafe

Public Functions

inline std::string_view MessageFor(const score::result::ErrorCode &code) const noexcept final override#

Translates an error code into a human readable message.

Todo:

Gcc compiler bug leads to a compiler warning if override is not added, even if final keyword is there (https://gcc.gnu.org/bugzilla/show_bug.cgi?id=78010). When bug is fixed, remove the override keyword from the MessageFor function signature and the AUTOSAR.MEMB.VIRTUAL.SPEC klocwork suppression.

Feature API:

This function is required by the std::error_domain interface

Parameters:

code – The error code to translates

Returns:

returns a string view to the human readable message \threadsafe

class FindServiceHandle#

A FindServiceHandle is returned by any StartFindService() method and is used to identify different searches. It needs to be passed to StopFindService() in order to cancel a respective search.

Feature API:

\requirement SWS_CM_00303

Public Functions

FindServiceHandle() = delete#
~FindServiceHandle() noexcept = default#
FindServiceHandle &operator=(const FindServiceHandle &other) = default#

CopyAssignment for FindServiceHandle.

Feature API:

Parameters:

other – The FindServiceHandle *this shall be constructed from

Post:

*this == other

Returns:

The FindServiceHandle that was constructed

FindServiceHandle(const FindServiceHandle &other) = default#

CopyConstructor for FindServiceHandle.

Feature API:

Parameters:

other – The FindServiceHandle to copy from

Returns:

The FindServiceHandle that was constructed

FindServiceHandle(FindServiceHandle &&other) noexcept = default#

MoveAssignment for FindServiceHandle.

Feature API:

Parameters:

other – The FindServiceHandle *this shall be constructed from

Post:

*this == other

Returns:

The FindServiceHandle that was constructed

FindServiceHandle &operator=(FindServiceHandle &&other) noexcept = default#

MoveAssignment for FindServiceHandle.

Feature API:

Parameters:

other – The FindServiceHandle *this shall be constructed from

Post:

*this == other

Returns:

The FindServiceHandle that was constructed

Friends

friend bool operator==(const FindServiceHandle &lhs, const FindServiceHandle &rhs) noexcept#

Compares two instances for equality.

Feature API:

Parameters:

  • lhs – The first instance to check for equality

  • rhs – The second instance to check for equality

Returns:

true if lhs and rhs equal, false otherwise

friend bool operator<(const FindServiceHandle &lhs, const FindServiceHandle &rhs) noexcept#

LessThanComparable operator.

Feature API:

Parameters:
Returns:

true if lhs is less then rhs, false otherwise

friend mw::log::LogStream &operator<<(mw::log::LogStream &log_stream, const FindServiceHandle &find_service_handle)#

Stream operator which enables logging of FindServiceHandle via mw::log::LogStream.

Feature API:

Parameters:

  • log_stream – The log stream to write to

  • find_service_handle – The FindServiceHandle to log

Returns:

The log stream passed in as parameter

friend std::ostream &operator<<(std::ostream &ostream_out, const FindServiceHandle &find_service_handle)#

Stream operator which enables logging of FindServiceHandle via std::ostream.

Feature API:

Parameters:

  • ostream_out – The output stream to write to

  • find_service_handle – The FindServiceHandle to log

Returns:

The output stream passed in as parameter

class GenericProxy : public score::mw::com::impl::ProxyBase#

GenericProxy is a non-binding specific Proxy class which doesn’t require any type information for its events. This means that it can connect to a service providing instance (skeleton) just based on deployment information specified at runtime.

Todo:

The EventMap, events, needs to be populated with actual GenericProxyEvents.

Feature API:

It contains a map of events which can access strongly-typed events in a type-erased way i.e. by accessing a raw memory buffer. It is the generic analogue of a Proxy, which contains strongly-typed events. While the Proxy is usually generated from the IDL, a GenericProxy can be manually instantiated at runtime based on deployment information.

Public Types

using EventMapView = ServiceElementMapView<GenericProxyEvent>#

Public Functions

~GenericProxy() noexcept#
GenericProxy(const GenericProxy&) = delete#
GenericProxy &operator=(const GenericProxy&) = delete#
GenericProxy(GenericProxy &&other) noexcept#
GenericProxy &operator=(GenericProxy &&other) noexcept#
EventMapView GetEvents() const noexcept#

Returns a read-only view to the name-keyed map of events.

Feature API:

Returns:

View to the event map.

Note

The returned view is valid as long as the GenericProxy lives.

Public Static Functions

static Result<GenericProxy> Create(HandleType instance_handle) noexcept#

Exception-less GenericProxy constructor.

Feature API:

Parameters:

instance_handle – Handle to the instance

Returns:

Result containing the created GenericProxy instance or an error code.

Friends

friend class test::GenericProxyAttorney
class InstanceIdentifier#

Represents a specific instance of a given service \requirement SWS_CM_00302.

Feature API:

Public Functions

InstanceIdentifier() = delete#
~InstanceIdentifier() noexcept = default#
InstanceIdentifier &operator=(const InstanceIdentifier &other) = default#

CopyAssignment for InstanceIdentifier.

ctor from serialized representation.

Constructor is required by adaptive AUTOSAR Standard. But it uses exceptions, thus we will not implement it.

explicit InstanceIdentifier(std::string_view value);

Feature API:

Parameters:

other – The InstanceIdentifier *this shall be constructed from

Post:

*this == other

Returns:

The InstanceIdentifier that was constructed

InstanceIdentifier(const InstanceIdentifier&) = default#

Copy constructor for InstanceIdentifier.

Feature API:

Parameters:

other – The InstanceIdentifier to copy from

Returns:

The InstanceIdentifier that was constructed

InstanceIdentifier(InstanceIdentifier&&) noexcept = default#

Move constructor for InstanceIdentifier.

Feature API:

Parameters:

other – The InstanceIdentifier to move from

Post:

*this == other

Returns:

The moved InstanceIdentifier

InstanceIdentifier &operator=(InstanceIdentifier &&other) = default#

MoveAssignment for InstanceIdentifier.

Feature API:

Parameters:

other – The InstanceIdentifier *this shall be constructed from

Post:

*this == other

Returns:

The InstanceIdentifier that was constructed

std::string_view ToString() const noexcept#

Returns the serialized form of the unknown internals of this class as a meaningful string.

Feature API:

Returns:

A non-owning string representation of the internals of this class

Public Static Functions

static score::Result<InstanceIdentifier> Create(std::string &&serialized_format) noexcept#

Exception-less constructor to create InstanceIdentifier from a serialized InstanceIdentifier created with InstanceIdentifier::ToString().

Feature API:

Parameters:

serialized_format – The serialized format to create the InstanceIdentifier from

Returns:

The created InstanceIdentifier or an error

Friends

friend bool operator==(const InstanceIdentifier &lhs, const InstanceIdentifier &rhs) noexcept#

Compares two instances for equality.

Feature API:

Parameters:

  • lhs – The first instance to check for equality

  • rhs – The second instance to check for equality

Returns:

true if other and *this equal, false otherwise

friend bool operator<(const InstanceIdentifier &lhs, const InstanceIdentifier &rhs) noexcept#

LessThanComparable operator.

Feature API:

Parameters:
Returns:

true if *this is less then other, false otherwise

class InstanceSpecifier#

Identifier for an application port. Maps design to deployment. \requirement SWS_CM_00350.

Feature API:

Public Functions

std::string_view ToString() const noexcept#

Convert the InstanceSpecifier to a string representation.

Feature API:

Returns:

A string representation of the InstanceSpecifier.

Public Static Functions

static score::Result<InstanceSpecifier> Create(std::string &&shortname_path) noexcept#

Create an InstanceSpecifier from a shortname path.

Feature API:

Parameters:

shortname_path – The shortname path to create the InstanceSpecifier from.

Returns:

A Result containing the created InstanceSpecifier or an error.

template<typename T>
static inline score::Result<InstanceSpecifier> Create(T &&shortname_path) noexcept#

Create an InstanceSpecifier from various string-like types (deprecated template version).

Converting former static score::Result<InstanceSpecifier> Create(const std::string_view shortname_path) to this method template fixes the potential “ambiguity”, when calling Create() with a string literal. With the former (non-template) signature, there would be an ambiguity between both Create() overloads, one with std::string&& and one with std::string_view. But replacing the std::string_view overload with the method-template solves the ambiguity, because Template Create(T&&) Matches, as T = const char(&)[]

Deprecated:

Use Create(std::string&&) instead for better performance.

Parameters:

shortname_path – The shortname path to create the InstanceSpecifier from (convertible to std::string_view).

Returns:

A Result containing the created InstanceSpecifier or an error.

class ProxyTrait#

Encapsulates all necessary attributes for a proxy.

The main idea of these traits are to ease the interface creation for a user. It reduces the necessary generated code to a bare minimum.

Thanks to these traits a user can construct an interface as follows:

template <typename Trait> class TheInterface : public Trait::Base { public: using Trait::Base::Base;

typename Trait::template Event<DataType1> struct_event_1_{*this, event_name_0}; typename Trait::template Event<DataType2> struct_event_2_{*this, event_name_1};

typename Trait::template Field<DataType1, true, false, true> struct_field_1_{*this, field_name_0}; typename Trait::template Field<DataType2, enable_getter, enable_setter, enable_notifier> struct_field_2_{*this, field_name_1};

typename Trait::template Method<void(InArgType1)> struct_method_1_{*this, method_name_0}; typename Trait::template Method<ReturnType()> struct_method_2_{*this, method_name_1};

}; Notes regarding template args: A field has (besides its data type arg) three bool template args (enable_getter, enable_setter and enable_notifier). The enable_notifier template parameter is only relevant for certain bindings, e.g. the LoLa binding does not distinguish between true/false of this template parameter. A method has a template arg describing the method signature in the form ReturnType(InArgType1, InArgType2, …). InArgs and ReturnType are optional. Therefore, these are valid signatures:

  • void()

  • ReturnType1()

  • void(InArgType1, InArgType2)

  • ReturnType1(InArgType1)

Having a defined interface, it is then possible to interpret this interface as proxy via using TheProxy = AsProxy<TheInterface>, respectively as skeleton via using TheSkeleton = AsSkeleton<TheInterface>.

Feature API:

Defines the trait types used by proxy interfaces following the trait pattern. This trait provides ProxyBase as the base class, ProxyEvent for events, and ProxyField for fields. Used as a template parameter when defining service interfaces that will be instantiated as proxies (client-side).

Public Types

using Base = ProxyBase#
template<typename SampleType>
using Event = ProxyEvent<SampleType>#
template<typename SampleType, bool EnableSet = false, bool EnableGet = false, bool EnableNotifier = false>
using Field = ProxyField<SampleType>#
template<typename MethodSignature>
using Method = ProxyMethod<MethodSignature>#
class SkeletonTrait#

Encapsulates all necessary attributes for a skeleton.

Feature API:

Defines the trait types used by skeleton interfaces following the trait pattern. This trait provides SkeletonBase as the base class, SkeletonEvent for events, and SkeletonField for fields. Used as a template parameter when defining service interfaces that will be instantiated as skeletons (server-side).

Public Types

using Base = SkeletonBase#
template<typename SampleType>
using Event = SkeletonEvent<SampleType>#
template<typename SampleType, bool EnableSet = false, bool EnableNotifier = false>
using Field = SkeletonField<SampleType, EnableSet, EnableNotifier>#
template<typename MethodSignature>
using Method = SkeletonMethod<MethodSignature>#
class RuntimeConfiguration#

RuntimeConfiguration object which a user can construct and pass to the public InitializeRuntime call.

Feature API:

Public Functions

RuntimeConfiguration()#

Default constructor which initialiases the stored configuration path with a default value.

It can be useful for debugging purposes for an application to want to explicitly initialize the runtime using defaults to check configuration parsing.

RuntimeConfiguration(const std::int32_t argc, score::StringLiteral argv[])#

Constructor which initialiases the stored configuration path from command line arguments.

Feature API:

The constructor parses the command line arguments for a specific key to extract the configuration path. If the key is not found, a default path is used.

Parameters:

  • argc – The number of command line arguments.

  • argv – The array of command line arguments.

explicit RuntimeConfiguration(filesystem::Path configuration_path)#

Constructor which initialiases the stored configuration path with the provided path.

Feature API:

Parameters:

configuration_path – The configuration path to be stored.

const filesystem::Path &GetConfigurationPath() const#

Returns the stored configuration path.

Feature API:

Returns:

The stored configuration path.