Namespaces
namespace	std_util
namespace	util
namespace	lang
namespace	detail
namespace	kernel
	Strong type for the unique identifier for a transport timer.
namespace	test
namespace	db

Classes
struct	ShouldBePassedByValue
	Utility to indicate that your class wants to be passed by value in some of the library calls. More...
struct	HasValueType
	return false if T has not an 'using ValueType' or a 'typedef ValueType' More...
struct	HasValueType< T, std::void_t< typename T::ValueType > >
	return true if T has an 'using ValueType' or a 'typedef ValueType' More...
struct	HasOperator
	Allows compile-time check for the presence of various operators. More...
struct	Overloaded
	Helper type for std::variant lambda visitors. More...
struct	IsContained
	Checks if T is on of the types in TypeList. More...
struct	IsVariantMember
	Checks if T is on of the member types of the given VariantType. More...
struct	IsVariantMember< T, std::variant< MemberTypes... > >
	Checks if T is on of the member types of the given VariantType. More...
class	Duration
	A time duration. More...
struct	ShouldBePassedByValue< Duration >
class	GradientNoise
	Utility class for generating n-dimensional noise. Mainly useful in tests and examples. More...
struct	Guarded
	Guarded is a lightweight wrapper class that can be used to protect an objet of type T from concurrent modification. The wrapper only allows access/reads/modifications of the underlying value while holding a lock but does not require the user to hold the lock himself. More...
class	Quantity
	CRTP class that wraps T to ensure it's value stays within a certain range. More...
struct	ShouldBePassedByValue< Quantity< T, D > >
class	Result
	Result<T, E> is a template type that can be used to return and propagate errors. The intent is to replace exceptions in this context. Result<T, E> is an algebraic data type of Ok(T) that represents success and Err(E) representing an error. More...
class	Result< void, E >
	Specialization for Results that just hold error data. More...
class	Result< void, std::monostate >
	Specialization for Results that just hold success indication. More...
class	ScopeGuard
	Runs the function object F on destruction. More...
struct	SourceLocation
	Represents a location in source code. More...
class	Span
	Contiguous view of elements of type T. Inspired by http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p0122r7.pdf. More...
class	StaticVectorBase
	Base class for stack-based, exception-safe and resizable vector with fixed-capacity. More...
class	StaticVector
	Stack-based, exception-free and resizable vector with fixed-capacity. More...
class	StrongTypeBase
	Wraps T to make it a strong type. More...
struct	ShouldBePassedByValue< StrongTypeBase< T > >
class	StrongType
	CRTP class that wraps T to make it a strong type. More...
struct	ShouldBePassedByValue< StrongType< T, D > >
class	TimeStamp
	A point in time. More...
struct	ShouldBePassedByValue< TimeStamp >
class	Uuid
	Universal Unique Identifier. More...
class	UuidRandomGenerator
class	Writer
	Interface for writing to a device. More...
class	BufferWriter
	A writer that owns a fixed size buffer. More...
class	ResizableBufferWriter
	A writer that owns a buffer that gets resized on demand. More...
struct	LittleEndian
	Tag type for referring to little endian encoding. More...
struct	BigEndian
	Tag type for referring to big endian encoding. More...
class	InputStreamBase
	Base class for input streams. More...
class	InputStreamTemplate
	Binary input stream. Deserializes values. In general, I/O operations throw on failure. More...
class	OutputStreamTemplate
	Binary output stream. Serializes values. In general, I/O operations throw on failure. More...
struct	AliasSpec
	Data of an alias type. More...
class	AliasType
	Represents an aliased type. More...
struct	BasicTraits
	Helper class that traits classes can inherit from when the type at hand is basic (native or trivial). More...
struct	Arg
	Holds the information for an argument in the callable. More...
struct	CallableSpec
	Data of a callable. More...
class	Callable
	Represents something that can be called. More...
class	CustomType
	Represents a user-defined type. More...
struct	EnumTraitsBase
	Base class for enum traits. More...
struct	Enumerator
	Holds the information for an enumerator. More...
struct	EnumSpec
	Data of an enum type. More...
class	EnumType
	Represents an enumeration. More...
struct	EventSpec
	Data of an event. More...
class	Event
	Represents an event. More...
struct	NonPropertyRelated
	Indicates that the method is not directly related to any property. More...
struct	PropertyGetter
	Indicates that the method represents a getter of a property. More...
struct	PropertySetter
	Indicates that the method represents a setter of a property. More...
struct	MethodSpec
	Data of a method. More...
class	Method
	Represents a method. More...
class	NativeType
	Represents a native (built-in) type that can be created on the stack or sent in a message. More...
class	NumericType
	Represents a numeric native type. More...
class	IntegralType
	Represents an integral numeric type. More...
class	RealType
	Represents a floating point numeric type. More...
class	VoidType
	Used for indicating that no result value is provided. More...
struct	OptionalTraitsBase
	Base class for enum traits. More...
struct	OptionalSpec
	Data of an optional type. More...
class	OptionalType
	Represents an optional type. More...
struct	PropertySpec
	Data of a property. More...
class	Property
	Represents a property. More...
struct	QuantityTraitsBase
	Base class for quantity traits. More...
struct	QuantitySpec
	Data of a quantity type. More...
class	QuantityType
	Represents a quantity. More...
struct	SequenceTraitsBase
	Base class for sequence traits. More...
struct	ArrayTraitsBase
	Base class for sequence traits. More...
struct	SequenceSpec
	Data of a sequence type. More...
class	SequenceType
	Represents a sequence type. More...
struct	StructTraitsBase
	Base class for struct traits. More...
struct	StructField
	Holds the information for a field in the struct. More...
struct	StructSpec
	Data of struct type. More...
class	StructType
	Represents a structure type. More...
class	DurationType
	Represents a sen::Duration (a time duration). More...
class	TimestampType
	Represents a sen::TimeStamp (a point in time). More...
struct	MetaTypeTrait< Duration >
struct	QuantityTraits< Duration >
struct	VariantTraits< Duration >
struct	SerializationTraits< Duration >
struct	MetaTypeTrait< TimeStamp >
struct	VariantTraits< TimeStamp >
struct	SerializationTraits< TimeStamp >
class	QuantityTraits< TimeStamp >
struct	MemberHash
	The hash of a member. More...
struct	ShouldBePassedByValue< MemberHash >
class	Type
	Represents a type that can be used to define variables and arguments for methods or functions. Types use the GoF Visitor pattern in order to allow easy and fast operation, as double dispatching is faster and cleaner than a (dynamic) cast-based approach. More...
class	TypeHandle
	Handle around a type that, by default, ensures the lifetime of the underlying type. More...
struct	TypeMatchIssue
	Information about a type matching issue. More...
struct	TypesMatch
	Types are compatible. More...
struct	TypesDontMatch
	Types do not match. More...
class	CustomTypeRegistry
	A registry of custom types. More...
struct	MetaTypeTrait
struct	VariantTraits
struct	SerializationTraits
struct	StringConversionTraits
struct	QuantityTraits
struct	SenClassRelation
	Compile-time information about a generated (or built-in) type. More...
struct	SenClassRelation< const T & >
struct	SenClassRelation< T & >
struct	SenClassRelation< const T >
struct	remove_cvref
class	FullTypeVisitor
	A Visitor for constant types. This class is based on the GoF Visitor design pattern. You can use it to perform operations on types without having to do dynamic_casts (or switch-based casts). More...
class	TypeVisitor
	All the apply virtual methods are overriden to empty methods. Use TypeVisitor if you only need to handle some of the types. More...
struct	UnitSpec
	Data about a given unit definition. Given f, x, y: More...
class	Unit
	Represents the definition of a unit. More...
class	UnitRegistry
	A registry of units. More...
struct	Var
	Can hold any supported value type. Wraps std::variant to allow recursion and implements some helpers. More...
struct	IsVariantMember< T, Var >
struct	VariantTraitsBaseBase
struct	VariantTraitsBase
	Base class for variant traits. More...
struct	VariantField
	Holds the information for a field in the variant. More...
struct	VariantSpec
	Data of a variant type. More...
class	VariantType
	Represents a variant type. More...
struct	EventInfo
	Information about an event emission. More...
struct	MethodCallInfo
	Information about a method call. More...
class	Callback
	Base class for event or method callbacks. It stores the queue where to push the response. The queue can be obtained directly as an argument, or through an object. More...
class	ConnectionGuard
	Unregisters a callback on destruction, unless keep() is called. More...
struct	ShouldBePassedByValue< InterestId >
	Unique identifier that represents the interest. More...
struct	BusSpec
	The name/address of a bus. More...
struct	VarInfo
	Information about a variable used in the query. More...
class	Interest
	Declares interest on objects that satisfy a set of conditions. More...
class	NativeObject
	An object instantiated in this process. This is the base class for all user-implemented objects. More...
struct	ShouldBePassedByValue< ConnId >
struct	ShouldBePassedByValue< ObjectId >
	Unique identifier for any object instance. More...
class	Object
	A sen object. More...
class	ObjectFilterBase
	Base class for object filters. More...
class	ObjectFilter
	Allows the discovery of objects based on different criteria. More...
class	ObjectList
	A list of objects that is managed by some source based on user-expressed interests. More...
class	MuxedProviderListener
	An extended ObjectProviderListener that works together with ObjectMux and notifies when objects provided by different ObjectMux sources are added/removed multiple times. More...
class	ObjectMux
	Converts multiple object providers into one. Providers might reside in different threads. Note that addition and removal notifications for objects that are matched by overlapping interests might mention different interest IDs. More...
struct	ShouldBePassedByValue< ObjectOwnerId >
	Identifies the owner of an object. More...
struct	ObjectInstanceDiscovery
	Holds information about an object that has been discovered. More...
struct	RemoteObjectDiscovery
	Holds information about a remote object that has been discovered. More...
struct	ObjectRemoval
	Holds information about an object that has been removed. More...
class	ObjectProviderListener
	Allows reacting to objects being added or removed to an object provider. It automatically unregisters itself from all the providers upon destruction. More...
class	ObjectProvider
	Base class for an entity that is able to produce objects. More...
class	ObjectRef
	Object references may or may not hold an object instance. Their value is set by a provider based on some defined interest which was given during construction. More...
class	ObjectSource
	Allows adding and receiving objects. More...
struct	Subscription
	A list of objects and a reference to its source (to keep it alive). More...
struct	ShouldBePassedByValue< kernel::ProcessId >
struct	ShouldBePassedByValue< kernel::BusId >

Typedefs
template<typename T>
using	AddConstRef = std::add_lvalue_reference_t<std::add_const_t<T>>
	returns 'const T&'
template<typename T>
using	MaybeRef = std::conditional_t<std::is_arithmetic_v<T> \|\| shouldBePassedByValueV<T>, T, AddConstRef<T>>
	returns 'const T&' or 'T' depending on the type
using	BoolResult = Result<void, std::monostate>
	True or false result.
using	InputStream = InputStreamTemplate<LittleEndian>
using	OutputStream = OutputStreamTemplate<LittleEndian>
using	PropertyRelation = std::variant<NonPropertyRelated, PropertyGetter, PropertySetter>
	Information about the relation between a method and a property.
using	NativeFieldValueGetter = std::function<lang::Value(const void*)>
	A function that extracts a native value from a field.
template<typename T>
using	ConstSharedPtr = std::shared_ptr<const T>
	Utility typedef.
template<typename T = Type>
using	ConstTypeHandle = TypeHandle<const T>
template<typename T = Type>
using	MaybeConstTypeHandle = std::optional<ConstTypeHandle<T>>
using	TypeMatch = Result<TypesMatch, TypesDontMatch>
	The result of a type matching analysis.
template<typename T>
using	SenInterfaceTypeT = typename SenClassRelation<T>::InterfaceType
	Determines the interface type for the given type T.
template<typename T, typename BaseClassType = void>
using	SenBaseTypeT = typename detail::TemplatedBaseTypeDispatcher<T, BaseClassType>::DefaultBaseType
	Determines the base type for the given type T.
template<typename T>
using	SenLocalProxyTypeT = typename SenClassRelation<T>::LocalProxyType
	Determines the local proxy type for the given type T.
template<typename T>
using	SenRemoteProxyTypeT = typename SenClassRelation<T>::RemoteProxyType
	Determines the remote proxy type for the given type T.
template<typename T>
using	remove_cvref_t = typename remove_cvref<T>::type
using	VarList = std::vector<Var>
	A list of vars to represent sequences.
using	VarMap = std::map<std::string, Var, std::less<>>
	A map of vars to represent structures.
using	KeyedVar = std::tuple<uint32_t, std::shared_ptr<Var>>
	A key-var tuple, to represent variants.
template<typename R>
using	MethodResult = Result<R, std::exception_ptr>
	The result of a method (which can be an exception in case of error).
template<typename... Args>
using	EventCallback = Callback<EventInfo, Args...>
	An event callback.
template<typename R>
using	MethodCallback = Callback<MethodCallInfo, MethodResult<R>>
	A method callback.
using	PropertyCallback = EventCallback<>
	A property change callback.
using	TypeCondition = std::variant<std::monostate, ConstTypeHandle<ClassType>, std::string>
	A condition set on an object's type.
using	BusCondition = std::optional<BusSpec>
	Bus conditions may be present, but are not mandatory.
using	VarInfoList = std::vector<VarInfo>
	List of variables used in a query expression.
using	StreamCall = sen::std_util::move_only_function<void(OutputStream&)>
using	VariantCall = sen::std_util::move_only_function<void(Var&)>
using	StreamCallForwarder = sen::std_util::move_only_function<void(StreamCall&&)>
using	VariantCallForwarder = sen::std_util::move_only_function<void(VariantCall&&)>
using	ObjectAddition = std::variant<ObjectInstanceDiscovery, RemoteObjectDiscovery>
	Holds information about an object that is already present and we explicitly asked for.
using	ObjectAdditionList = std::vector<ObjectAddition>
	Sequence of object additions.
using	ObjectRemovalList = std::vector<ObjectRemoval>
	Sequence of object removals.

Enumerations
enum class	StaticVectorError : std::uint8_t { StaticVectorError::full , StaticVectorError::badRange , StaticVectorError::empty }
	Things that can go wrong when using a StaticVector. More...
enum class	UuidVariant { UuidVariant::ncs = 0 , UuidVariant::rfc = 1 , UuidVariant::microsoft = 2 , UuidVariant::reserved = 3 }
	Indicated by a bit pattern in octet 8, marked with N in xxxxxxxx-xxxx-xxxx-Nxxx-xxxxxxxxxxxx. More...
enum class	UuidVersion { UuidVersion::none = 0 , UuidVersion::timeBased = 1 , UuidVersion::dceSecurity = 2 , UuidVersion::nameBasedMd5 = 3 , UuidVersion::randomNumberBased = 4 , UuidVersion::nameBasedSha1 = 5 }
	Indicated by a bit pattern in octet 6, marked with M in xxxxxxxx-xxxx-Mxxx-xxxx-xxxxxxxxxxxx. More...
enum class	Constness { Constness::constant , Constness::nonConstant }
	Method constness. More...
enum class	PropertyCategory { PropertyCategory::staticRO , PropertyCategory::staticRW , PropertyCategory::dynamicRW , PropertyCategory::dynamicRO }
	How a property is seen by others. More...
enum class	TransportMode : uint8_t { TransportMode::unicast = 0U , TransportMode::multicast = 1U , TransportMode::confirmed = 2U }
	How to transport information. More...
enum class	TypeMatchProblem { TypeMatchProblem::compatible , TypeMatchProblem::incompatible , TypeMatchProblem::missing }
	Kind of problem found when matching types. More...
enum class	UnitCategory { UnitCategory::length , UnitCategory::mass , UnitCategory::time , UnitCategory::angle , UnitCategory::temperature , UnitCategory::density , UnitCategory::pressure , UnitCategory::area , UnitCategory::force , UnitCategory::frequency , UnitCategory::velocity , UnitCategory::angularVelocity , UnitCategory::acceleration , UnitCategory::angularAcceleration }
	Type of measurement. More...
enum class	Emit { Emit::now , Emit::onCommit }
	How to emit an event. More...

Functions
void	registerTerminateHandler ()
	Installs a custom termination handler.
void	throwRuntimeError (const std::string &err)
	Throws std::exception that attempts to collect the stack trace. We also wrap it to avoid including stdexcept.
void	trace ()
	Prints the current stack trace to stderr.
void	trace (std::string preMessage)
	Prints the current stack trace to stderr.
template<class... Ts>
	Overloaded (Ts...) -> Overloaded< Ts... >
	Explicit deduction guide (not needed as of C++20).
template<typename InputIterator>
u32	crc32 (InputIterator first, InputIterator last) noexcept
	Calculates the CRC32 for any sequence of values. (You could use type traits and a static assert to ensure the values can be converted to 8 bits.).
u32	crc32 (std::string_view str) noexcept
	CRC32 for strings.
template<typename... Types>
u32	hashCombine (u32 seed, const Types &... args) noexcept
	Combines the hash of different values into a single 32-bit hash.
template<typename... Types>
uint_fast32_t	platformDependentHashCombine (uint_fast32_t seed, const Types &... args) noexcept
	Old version of the hashCombine method. The current one replaced this implementation to allow sen processes to discover and connect themselves between platforms (Windows and Linux). We keep this old implementation to enable replaying Sen recordings generated with the old hashes.
unsigned char *	decompressSymbol (const void *compressedData)
	Decompresses a blob into its original shape.
std::string	decompressSymbolToString (const void *compressedData, unsigned int originalSize)
	Decompresses a blob into a string.
bool	fileToCompressedArrayFile (const std::filesystem::path &inputFile, std::string_view symbolName, const std::filesystem::path &outputFile)
	Creates a C++ source file that contains an array representing the contents of another file.
template<typename... Types>
std::uint_fast32_t	platformDependentHashCombine (std::uint_fast32_t seed, const Types &... args) noexcept
template<typename T, typename CleanT = std::decay_t<T>>
impl::Ok< CleanT >	Ok (T &&val) noexcept
	Helper (syntactic sugar) to create Results that indicate success.
template<typename E, typename CleanE = std::decay_t<E>>
impl::Err< CleanE >	Err (E &&val) noexcept
	Helper (syntactic sugar) to create Results that indicate error.
impl::Ok< void >	Ok () noexcept
	If T is void, use the void specialization of Ok.
impl::Err< void >	Err () noexcept
	If E is void, use the void specialization of Err.
template<class F>
auto	makeScopeGuard (F &&f)
	Makes scope guard from a callable taking no arguments.
template<class F>
	ScopeGuard (F) -> ScopeGuard< F >
template<class F>
auto	makeScopeGuard (const F &&f)=delete
template<class F>
auto	makeScopeGuard (F &f)=delete
template<class F>
auto	makeScopeGuard (const F &f)=delete
template<typename InputF>
auto	makeScopeGuard (InputF &&f)
template<typename T>
constexpr bool	operator== (const Span< T > &lhs, const Span< T > &rhs) noexcept
template<typename T>
constexpr bool	operator!= (const Span< T > &lhs, const Span< T > &rhs) noexcept
template<typename T>
constexpr Span< T >	makeSpan (T *ptr, std::size_t size) noexcept
	Takes in a type that can be passed to a contiguous range and returns a Span.
template<typename T, std::size_t n>
constexpr Span< T >	makeSpan (T(&arr)[n]) noexcept
	Takes in a type that can be passed to a contiguous range and returns a Span.
template<typename T>
constexpr Span< T >	makeSpan (T &val) noexcept
	Takes in a type that can be passed to a contiguous range and returns a Span.
template<typename Iterator, typename T = typename std::iterator_traits<Iterator>::value_type>
constexpr Span< T >	makeSpan (Iterator first, Iterator last) noexcept
	Takes in a type that can be passed to a contiguous range and returns a Span.
template<typename T>
constexpr Span< T >	makeSpan (std::vector< T > &vector) noexcept
	Takes in a type that can be passed to a contiguous range and returns a Span.
template<typename T, std::size_t s>
constexpr Span< T >	makeSpan (std::array< T, s > &array) noexcept
	Takes in a type that can be passed to a contiguous range and returns a Span.
template<typename T>
constexpr Span< const T >	makeConstSpan (const T *ptr, std::size_t size) noexcept
	Takes in a type that can be passed to a contiguous range and returns a Span. The element types will be const qualified.
template<typename T, std::size_t n>
constexpr Span< const T >	makeConstSpan (const T(&arr)[n]) noexcept
	Takes in a type that can be passed to a contiguous range and returns a Span. The element types will be const qualified.
template<typename Iterator, typename T = typename std::iterator_traits<Iterator>::value_type>
constexpr Span< const T >	makeConstSpan (Iterator first, Iterator last) noexcept
	Takes in a type that can be passed to a contiguous range and returns a Span. The element types will be const qualified.
template<typename T>
constexpr Span< const T >	makeConstSpan (const std::vector< T > &vector) noexcept
	Takes in a type that can be passed to a contiguous range and returns a Span. The element types will be const qualified.
template<typename T, std::size_t s>
constexpr Span< const T >	makeConstSpan (const std::array< T, s > &array) noexcept
	Takes in a type that can be passed to a contiguous range and returns a Span. The element types will be const qualified.
template<typename T, std::size_t size>
std::enable_if_t< HasOperator< T >::eq, bool >	operator== (StaticVector< T, size > const &lhs, StaticVector< T, size > const &rhs) noexcept
	Checks if the contents of lhs and rhs are equal, that is, they have the same number of elements and each element in lhs compares equal with the element in rhs at the same position.
template<typename T, std::size_t size>
std::enable_if_t< HasOperator< T >::ne, bool >	operator!= (StaticVector< T, size > const &lhs, StaticVector< T, size > const &rhs) noexcept
	Equivalent to negating operator ==.
constexpr bool	operator== (const Uuid &lhs, const Uuid &rhs)
constexpr bool	operator!= (const Uuid &lhs, const Uuid &rhs)
constexpr bool	operator< (const Uuid &lhs, const Uuid &rhs)
std::ostream &	operator<< (std::ostream &s, const Uuid &id)
template<typename T>
T	toValue (const Var &var)
template<typename T>
Var	toVariant (const T &val)
bool	operator== (const EventSpec &lhs, const EventSpec &rhs) noexcept
bool	operator!= (const EventSpec &lhs, const EventSpec &rhs) noexcept
const Span< ConstTypeHandle<> const > &	getNativeTypes ()
	All the native types.
std::ostream &	operator<< (std::ostream &out, const Duration &val)
std::ostream &	operator<< (std::ostream &out, const TimeStamp &val)
template<typename T>
	TypeHandle (std::shared_ptr< T > type) -> TypeHandle< T >
template<typename T>
TypeHandle< T >	makeNonOwningTypeHandle (T *typePtr)
	Creates a non-owning type handle from a type pointer.
template<typename T, typename U>
std::optional< TypeHandle< T > >	dynamicTypeHandleCast (const TypeHandle< U > &handle)
	Downcasts the type inside the type handle to the specified one, if possible.
TypeMatch	canConvert (const Type &from, const Type &to)
	Analyze if a type can be converted to another.
void	iterateOverDependentTypes (const Type &type, std::function< void(ConstTypeHandle<> type)> &callback)
	Helper that iterates over dependent types. The callback function is invoked for all used sub-types recursively.
std::string	toJson (const Var &var, int indent=2)
	Converts a variant into its Json representation. See https://www.Json.org/Json-en.html for details.
Var	fromJson (const std::string &str)
	Inverse as toJson.
std::vector< std::uint8_t >	toBson (const Var &var)
	Converts a variant into its bson (Binary JSON) representation. See https://bsonspec.org/ for details.
Var	fromBson (const std::vector< std::uint8_t > &bson)
	Inverse as toBson.
std::vector< std::uint8_t >	toCbor (const Var &var)
	Converts a variant into its MessagePack representation. See https://msgpack.org/ for details.
Var	fromCbor (const std::vector< std::uint8_t > &cbor)
	Inverse as toCbor.
std::vector< std::uint8_t >	toMsgpack (const Var &var)
	Converts a variant into its msgpack representation. See https://cbor.io/ for details.
Var	fromMsgpack (const std::vector< std::uint8_t > &msgpack)
	Inverse as toMsgpack.
std::vector< std::uint8_t >	toUbjson (const Var &var)
	Converts a variant into its UBJSON (Universal Binary JSON Specification) representation. See https://ubjson.org/ for details.
Var	fromUbjson (const std::vector< std::uint8_t > &ubson)
	Inverse as toUbjson.
Duration	stringToDuration (const std::string &str)
	Converts a string to a duration.
template<typename To, bool checkedConversion = false>
To	getCopyAs (const Var &var)
	Tries to transform the stored value to T. For expensive types, like strings, maps or lists is better use:
const Var &	findElement (const VarMap &map, const std::string &key, const std::string &errorMessage)
	Finds an element in a map or throws std::exception containing the provided string otherwise.
template<typename T>
T	findElementAs (const VarMap &map, const std::string &key, const std::string &errorMessage)
	Finds an element in a map or throws std::exception containing the provided string otherwise.
std::string	asString (const BusSpec &spec)
	Converts a BusSpec into a session.bus string representation.
std::string_view	extractQualifiedTypeName (const TypeCondition &condition)
	Gets the qualified type name from a type condition.
ObjectId	getObjectId (const ObjectAddition &discovery)
ObjectOwnerId	getObjectOwnerId (const ObjectAddition &discovery)
InterestId	getInterestId (const ObjectAddition &discovery)
Object *	getObjectInstance (const ObjectAddition &discovery)
ObjectRemoval	makeRemoval (const ObjectAddition &discovery)

Variables
template<typename T>
constexpr bool	shouldBePassedByValueV = ShouldBePassedByValue<T>::value
constexpr u32	hashSeed = 23835769U
	Initial seed for all hashes.
constexpr u32	propertyHashSeed = 19830715U
constexpr u32	methodHashSeed = 93580253U
constexpr u32	eventHashSeed = 12125807U
constexpr u32	nonPresentTypeHash = 18121997U
	This hash is combined when no Type is found in a certain spec.
template<typename T>
constexpr bool	isSenBaseTypeTemplateV = SenClassRelation<T>::isBaseTypeTemplate
	Checks if the given sen type has a templated base class.
template<typename T>
constexpr bool	isVarTypeMemberV = IsVariantMember<T, Var>::value

Class Documentation

◆ sen::LittleEndian

struct sen::LittleEndian

Tag type for referring to little endian encoding.

◆ sen::BigEndian

struct sen::BigEndian

Tag type for referring to big endian encoding.

◆ sen::remove_cvref

struct sen::remove_cvref

template<typename T>
struct sen::remove_cvref< T >

Class Members
typedef remove_cv_t< remove_reference_t< T > >	type std::remove_cv_t<std::remove_reference_t<T>>

Typedef Documentation

◆ OutputStream

using sen::OutputStream = OutputStreamTemplate<LittleEndian>

◆ remove_cvref_t

template<typename T>

using sen::remove_cvref_t = typename remove_cvref<T>::type

Function Documentation

◆ platformDependentHashCombine()

template<typename... Types>

std::uint_fast32_t sen::platformDependentHashCombine	(	std::uint_fast32_t	seed,
		const Types &...	args )

inlinenoexcept

◆ makeScopeGuard()

template<typename InputF>

auto sen::makeScopeGuard ( InputF && f )

◆ operator<<() [1/2]

std::ostream & sen::operator<<	(	std::ostream &	out,
		const Duration &	val )

◆ operator<<() [2/2]

std::ostream & sen::operator<<	(	std::ostream &	out,
		const TimeStamp &	val )

Namespaces

Classes

Typedefs

Enumerations

Functions

Variables