Namespaces
namespace	async

namespace	csa_helpers
	A sub-namespace in order not to expose the classes to the ChimeraTK namespace.

namespace	DataConsistencyGroupDetail

namespace	LNMBackend

namespace	numeric

namespace	numeric_address

namespace	parserUtilities

namespace	proxies
	We are using temporary proxy classes to realise element access with fixed point conversion.

namespace	RawConverter

namespace	Rebot

namespace	testable_rebot_sleep

namespace	Utilities

Classes
class	AccessModeFlags
	Set of AccessMode flags with additional functionality for an easier handling. More...

class	BackendFactory
	BackendFactory is a the factory class to create devices. More...

class	BackendRegisterCatalogue
	Interface for backends to the register catalogue. More...

class	BackendRegisterCatalogueBase
	Pure virtual implementation base class for the register catalogue. More...

class	BackendRegisterCatalogueImplIterator
	Non-const iterator for iterating through the registers in the catalogue, used by backend implementations only. More...

class	BackendRegisterInfoBase
	DeviceBackend-independent register description. More...

class	Base

class	Boolean
	Wrapper Class to avoid vector<bool> problems. More...

class	const_BackendRegisterCatalogueImplIterator
	Implementation of the catalogue const iterator which is templated to the actual BackendRegisterInfo implementation provided by the backend. More...

class	const_RegisterCatalogueImplIterator
	Virtual base class for the catalogue const iterator. More...

class	ConvertingDecorator

class	ConvertingRawDecorator

class	copmaredRegisterInfosByName2_functor
	Provides predicate to compare devices by device file by name. More...

struct	CopyRegisterDecorator
	Decorator for NDRegisterAccessors which makes a copy of the data from the target accessor. More...

struct	CopyRegisterDecoratorTrait
	Runtime type trait to identify CopyRegisterDecorators independent of their type. More...

class	CtrlIntf

class	DataConsistencyDecorator
	A quasi-decorator to be used to decorate targets which should provide data updates only when data is consistent (i.e. More...

class	DataConsistencyGroup
	Group several registers (= TransferElement) which ensures data consistency across multiple variables through an algorithm which matches the VersionNumber. More...

class	DataDescriptor
	Class describing the actual payload data format of a register in an abstract manner. More...

class	DataType
	A class to describe which of the supported data types is used. More...

class	DecoratorFactory

struct	DecoratorMapKey
	Key type for the global decorator map. More...

class	DecoratorTypeHolder

class	Derived1

class	Derived2

class	Device
	Class allows to read/write registers from device. More...

class	DeviceBackend
	The base class for backends providing IO functionality for the Device class. More...

class	DeviceBackendImpl
	DeviceBackendImpl implements some basic functionality which should be available for all backends. More...

struct	DeviceDescriptor
	This structure holds the information of an ChimeraTK device descriptor. More...

class	DeviceFile

class	DeviceInfoMap

class	DmaIntf

class	DMapFileParser
	Provides method to parse DMAP file. More...

class	DoubleBufferAccessor

class	DummyBackend
	The dummy device opens a mapping file instead of a device, and implements all registers defined in the mapping file in memory. More...

class	DummyBackendBase
	Base class for DummyBackends, provides common functionality. More...

class	DummyInterruptTriggerAccessor
	The DummyInterruptTriggerAccessor class. More...

class	DummyMultiplexedRegisterAccessor
	Register accessor for accessing multiplexed 2D array registers internally of a DummyBackend implementation. More...

struct	DummyProtocol0
	Only put commands which don't exist in all versions, or behave differently. More...

struct	DummyProtocol1
	Only put commands which don't exist in all versions, or behave differently. More...

class	DummyRegisterAccessor
	Register accessor for accessing single word or 1D array registers internally of a DummyBackend implementation. More...

class	DummyRegisterRawAccessor
	Accessor for raw 32 bit integer access to the underlying memory space. More...

class	EventFile

class	EventThread

class	ExceptionDummy

struct	ExceptionDummyPollDecorator
	A decorator that returns invalid data for polled variables. More...

struct	ExceptionDummyPollDecoratorBase

struct	ExceptionDummyPushDecorator

struct	ExceptionDummyPushDecoratorBase

class	ExperimentalFeatures
	Class for handling the experimental feature enable flag. More...

class	findDevByName_pred
	Provides predicate to search device by name. More...

class	FixedUserTypeMap
	Map of UserType to a value of a single type (same for evey user type) More...

class	FixedUserTypeMapNoVoid
	Just like TemplateUserTypeMap, only without the ChimeraTK::Void type. More...

struct	ImgHeader
	Image header. More...

class	ImgView
	provides convenient matrix-like access for MappedImage More...

class	InstantiateLogicalNameMappingBackendFunctions

class	LNMBackendBitAccessor

class	LNMBackendChannelAccessor

class	LNMBackendRegisterInfo
	RegisterInfo structure for the LogicalNameMappingBackend. More...

class	LNMBackendVariableAccessor

struct	LNMVariable

class	logic_error
	Exception thrown when a logic error has occured. More...

class	LogicalNameMapParser
	Logical name map: store information from xlmap file and provide it to the LogicalNameMappingBackend and its register accessors. More...

class	LogicalNameMappingBackend
	Backend to map logical register names onto real hardware registers. More...

class	MapFileParser

class	MappedImage
	interface to an image that is mapped onto a 1D array of ValType More...

class	MappedStruct
	Provides interface to a struct that is mapped onto a 1D array of ValType StructHeader must be derived from OpaqueStructHeader. More...

class	MetadataCatalogue
	Container for backend metadata. More...

class	NDRegisterAccessor
	N-dimensional register accessor. More...

class	NDRegisterAccessorAbstractor
	Base class for the register accessor abstractors (ScalarRegisterAccessor, OneDRegisterAccessor and TwoDRegisterAccessor). More...

class	NDRegisterAccessorDecorator
	Base class for decorators of the NDRegisterAccessor. More...

class	NumericAddressedBackend
	Base class for address-based device backends (e.g. More...

class	NumericAddressedBackendASCIIAccessor
	Implementation of the NDRegisterAccessor for NumericAddressedBackends for ASCII data. More...

class	NumericAddressedBackendMuxedRegisterAccessor
	Implementation of the NDRegisterAccessor for NumericAddressedBackends for multiplexd 2D registers. More...

class	NumericAddressedBackendRegisterAccessor
	Implementation of the NDRegisterAccessor for NumericAddressedBackends for scalar and 1D registers. More...

class	NumericAddressedLowLevelTransferElement
	Implementation of the NDRegisterAccessor for NumericAddressedBackends, responsible for the underlying raw data access. More...

class	NumericAddressedRegisterCatalogue

class	NumericAddressedRegisterInfo

class	OneDRegisterAccessor
	Accessor class to read and write registers transparently by using the accessor object like a vector of the type UserType. More...

struct	OpaqueStructHeader
	generic header for opaque struct handling It has fields needed for communication in the same process, e.g. More...

class	PcieBackend
	A class to provide the Pcie device functionality. More...

class	ReadAnyGroup
	Group several registers (= TransferElement) to allow waiting for an update of any of the registers. More...

class	RebotBackend

class	RebotDummyServer

class	RebotDummySession

struct	RebotProtocol0

struct	RebotProtocol1

struct	RebotProtocolImplementor
	This is the base class of the code which implements the ReboT protocol. More...

struct	RebotSleepSynchroniser

class	RebotTestableClock

class	RegisterCatalogue
	Catalogue of register information. More...

class	RegisterInfo

class	RegisterPath
	Class to store a register path name. More...

class	runtime_error
	Exception thrown when a runtime error has occured. More...

class	ScalarRegisterAccessor
	Accessor class to read and write scalar registers transparently by using the accessor object like a variable of the type UserType. More...

class	ScalarRegisterAccessor< ChimeraTK::Boolean, std::nullptr_t >
	Template specialisation for ChimeraTK::Boolean. More...

class	ScalarRegisterAccessor< std::string >

struct	Sdm
	This structure holds the information of an SDM. More...

class	SharedDummyBackend
	The shared dummy device opens a mapping file defining the registers and implements them in shared memory instead of connecting to the real device. More...

class	SubdeviceBackend
	Backend for subdevices which are passed through some register or area of another device (subsequently called target device). More...

class	SubdeviceRegisterAccessor

class	SubdeviceRegisterWindowAccessor
	The RegisterRawType is determined by the number of bytes in the SubDevice mapfile The ReadWriteDataType is determined by the number of bits in the target ReadData and WriteData registers. More...

struct	SystemTags
	A list of pre-defined tags that can be used to mark registers. More...

class	TemplateUserTypeMap
	Map of UserType to a class template with the UserType as template argument. More...

class	TemplateUserTypeMapNoVoid
	Just like TemplateUserTypeMap, only without the ChimeraTK::Void type. More...

struct	TestCapabilities
	Descriptor for the test capabilities for each register. More...

struct	ThreadInformerMutex

class	TransferElement
	Base class for register accessors which can be part of a TransferGroup. More...

class	TransferElementAbstractor
	Base class for register accessors abstractors independent of the UserType. More...

class	TransferElementID
	Simple class holding a unique ID for a TransferElement. More...

class	TransferElementTestAccessor
	Special accessor used to test the behaviour of the TransferElement base class and the TransferGroup. More...

class	TransferGroup
	Group multiple data accessors to efficiently trigger data transfers on the whole group. More...

class	TwoDRegisterAccessor
	Accessor class to read and write 2D registers. More...

class	TypeChangingDecorator
	Strictly this is not a real decorator. More...

class	TypeChangingDirectCastDecorator
	This decorator does not do mathematical rounding and range checking, but directly assigns the data types (C-style direct conversion). More...

class	TypeChangingDirectCastDecorator< ChimeraTK::Void, ChimeraTK::Void >
	template specialisation for Void as user type and string as impl type. More...

class	TypeChangingDirectCastDecorator< ChimeraTK::Void, IMPL_T >
	Partial template specialisation for Void as user type. More...

class	TypeChangingDirectCastDecorator< ChimeraTK::Void, std::string >
	template specialisation for Void as user type and string as impl type. More...

class	TypeChangingDirectCastDecorator< std::string, ChimeraTK::Void >
	template specialisation for Void as impl type and string as user type. More...

class	TypeChangingDirectCastDecorator< std::string, IMPL_T >
	Partial template specialisation for strings as user type. More...

class	TypeChangingDirectCastDecorator< T, ChimeraTK::Void >
	Partial template specialisation for Void as impl type. More...

class	TypeChangingDirectCastDecorator< T, std::string >
	Partial template specialisation for strings as impl type. More...

class	TypeChangingRangeCheckingDecorator
	This decorator uses ChimeraTK::numeric::convert() for proper conversion with clamping and rounding. More...

class	TypeChangingRangeCheckingDecorator< ChimeraTK::Void, ChimeraTK::Void >

class	TypeChangingRangeCheckingDecorator< ChimeraTK::Void, IMPL_T >

class	TypeChangingRangeCheckingDecorator< ChimeraTK::Void, std::string >

class	TypeChangingRangeCheckingDecorator< std::string, ChimeraTK::Void >

class	TypeChangingRangeCheckingDecorator< std::string, IMPL_T >

class	TypeChangingRangeCheckingDecorator< T, ChimeraTK::Void >

class	TypeChangingRangeCheckingDecorator< T, std::string >

class	TypeChangingStringImplDecorator
	This class is intended as a base class. More...

class	TypeChangingStringImplDecorator< ChimeraTK::Void, ChimeraTK::Void >
	The actual partial implementation for Void as user type and Void as impl type. More...

class	TypeChangingStringImplDecorator< ChimeraTK::Void, IMPL_T >
	The actual partial implementation for Void as user type. More...

class	TypeChangingStringImplDecorator< ChimeraTK::Void, std::string >
	The actual partial implementation for Void as user type and std::string as impl type. More...

class	TypeChangingStringImplDecorator< std::string, ChimeraTK::Void >
	The actual partial implementation for std::string as user type and Void as impl type. More...

class	TypeChangingStringImplDecorator< std::string, IMPL_T >
	The actual partial implementation for strings as user type. More...

class	TypeChangingStringImplDecorator< T, ChimeraTK::Void >
	The actual partial implementation for Void as impl type. More...

class	TypeChangingStringImplDecorator< T, std::string >
	The actual partial implementation for strings as impl type. More...

class	TypeChangingVoidImplDecorator
	This class is intended as a base class. More...

class	UioAccess
	Implements a generic userspace interface for UIO devices. More...

class	UioBackend

class	UnifiedBackendTest
	Class to test any backend for correct behaviour. More...

class	VersionNumber
	Class for generating and holding version numbers without exposing a numeric representation. More...

class	Void
	Wrapper Class for void. More...

class	VoidRegisterAccessor
	Accessor class to read and write void-typed registers. More...

class	XdmaBackend

class	XdmaIntfAbstract

Concepts
concept	accessor_abstractor
	Concept requiring a type to be an NDRegisterAccessorAbstractor-derived type.

concept	user_type
	Concept requiring a type to be one of the supported ChimeraTK UserTypes.

concept	raw_type
	Concept requiring a type to be one of the supported ChimeraTK RawTypes.

Typedefs
using	DeviceInfoMapPointer = boost::shared_ptr< DeviceInfoMap >
	Introduce specialisation of shared_pointer template for pointers to RegisterInfoMap object as a DeviceInfoMapPointer.

using	HiddenRange = boost::any_range< BackendRegisterInfoBase, boost::forward_traversal_tag, const BackendRegisterInfoBase &, std::ptrdiff_t >
	Forward range with type-erasure, used to get a range of hidden registers.

using	userTypeMap = boost::fusion::map< boost::fusion::pair< int8_t, int8_t >, boost::fusion::pair< uint8_t, uint8_t >, boost::fusion::pair< int16_t, int16_t >, boost::fusion::pair< uint16_t, uint16_t >, boost::fusion::pair< int32_t, int32_t >, boost::fusion::pair< uint32_t, uint32_t >, boost::fusion::pair< int64_t, int64_t >, boost::fusion::pair< uint64_t, uint64_t >, boost::fusion::pair< float, float >, boost::fusion::pair< double, double >, boost::fusion::pair< std::string, std::string >, boost::fusion::pair< Boolean, Boolean >, boost::fusion::pair< Void, Void > >
	Map of UserType to value of the UserType.

using	userTypeMapNoVoid = boost::fusion::map< boost::fusion::pair< int8_t, int8_t >, boost::fusion::pair< uint8_t, uint8_t >, boost::fusion::pair< int16_t, int16_t >, boost::fusion::pair< uint16_t, uint16_t >, boost::fusion::pair< int32_t, int32_t >, boost::fusion::pair< uint32_t, uint32_t >, boost::fusion::pair< int64_t, int64_t >, boost::fusion::pair< uint64_t, uint64_t >, boost::fusion::pair< float, float >, boost::fusion::pair< double, double >, boost::fusion::pair< std::string, std::string >, boost::fusion::pair< Boolean, Boolean > >
	Just like userTypeMap, only without the ChimeraTK::Void type.

template<typename T >
using	SingleTypeUserTypeMap = boost::fusion::map< boost::fusion::pair< int8_t, T >, boost::fusion::pair< uint8_t, T >, boost::fusion::pair< int16_t, T >, boost::fusion::pair< uint16_t, T >, boost::fusion::pair< int32_t, T >, boost::fusion::pair< uint32_t, T >, boost::fusion::pair< int64_t, T >, boost::fusion::pair< uint64_t, T >, boost::fusion::pair< float, T >, boost::fusion::pair< double, T >, boost::fusion::pair< std::string, T >, boost::fusion::pair< Boolean, T >, boost::fusion::pair< Void, T > >
	Map of UserType to a single type.

template<typename T >
using	SingleTypeUserTypeMapNoVoid = boost::fusion::map< boost::fusion::pair< int8_t, T >, boost::fusion::pair< uint8_t, T >, boost::fusion::pair< int16_t, T >, boost::fusion::pair< uint16_t, T >, boost::fusion::pair< int32_t, T >, boost::fusion::pair< uint32_t, T >, boost::fusion::pair< int64_t, T >, boost::fusion::pair< uint64_t, T >, boost::fusion::pair< float, T >, boost::fusion::pair< double, T >, boost::fusion::pair< std::string, T >, boost::fusion::pair< Boolean, T > >
	Just like SingleTypeUserTypeMap, only without the ChimeraTK::Void type.

using	UserTypeTuple = std::tuple< ChimeraTK::Boolean, int8_t, uint8_t, int16_t, uint16_t, int32_t, uint32_t, int64_t, uint64_t, float, double, std::string, ChimeraTK::Void >
	Convenience type definition of a std::tuple with all possible UserTypes.

using	UserTypeTupleNoVoid = std::tuple< ChimeraTK::Boolean, int8_t, uint8_t, int16_t, uint16_t, int32_t, uint32_t, int64_t, uint64_t, float, double, std::string >
	Like UserTypeVariUserTypeTupleant but without ChimeraTK::Void.

template<template< typename > class TPL>
using	UserTypeTemplateTuple = std::tuple< TPL< ChimeraTK::Boolean >, TPL< int8_t >, TPL< uint8_t >, TPL< int16_t >, TPL< uint16_t >, TPL< int32_t >, TPL< uint32_t >, TPL< int64_t >, TPL< uint64_t >, TPL< float >, TPL< double >, TPL< std::string >, TPL< ChimeraTK::Void > >
	Convenience type definition of a std::tuple with the given class template instantiated for all all possible UserTypes.

template<template< typename > class TPL>
using	UserTypeTemplateTupleNoVoid = std::tuple< TPL< ChimeraTK::Boolean >, TPL< int8_t >, TPL< uint8_t >, TPL< int16_t >, TPL< uint16_t >, TPL< int32_t >, TPL< uint32_t >, TPL< int64_t >, TPL< uint64_t >, TPL< float >, TPL< double >, TPL< std::string > >
	Like UserTypeTemplateTuple but without ChimeraTK::Void.

using	RawTypeTuple = std::tuple< uint8_t, uint16_t, uint32_t, uint64_t >
	Convenience type definition of a std::tuple with all possible RawTypes.

using	UserTypeVariant = std::variant< ChimeraTK::Boolean, int8_t, uint8_t, int16_t, uint16_t, int32_t, uint32_t, int64_t, uint64_t, float, double, std::string, ChimeraTK::Void >
	Convenience type definition of a std::variant with all possible UserTypes.

using	UserTypeVariantNoVoid = std::variant< ChimeraTK::Boolean, int8_t, uint8_t, int16_t, uint16_t, int32_t, uint32_t, int64_t, uint64_t, float, double, std::string >
	Like UserTypeVariant but without ChimeraTK::Void.

template<template< typename > class TPL>
using	UserTypeTemplateVariant = std::variant< TPL< ChimeraTK::Boolean >, TPL< int8_t >, TPL< uint8_t >, TPL< int16_t >, TPL< uint16_t >, TPL< int32_t >, TPL< uint32_t >, TPL< int64_t >, TPL< uint64_t >, TPL< float >, TPL< double >, TPL< std::string >, TPL< ChimeraTK::Void > >
	Convenience type definition of a std::variant with the given class template instantiated for all all possible UserTypes.

template<template< typename > class TPL>
using	UserTypeTemplateVariantNoVoid = std::variant< TPL< ChimeraTK::Boolean >, TPL< int8_t >, TPL< uint8_t >, TPL< int16_t >, TPL< uint16_t >, TPL< int32_t >, TPL< uint32_t >, TPL< int64_t >, TPL< uint64_t >, TPL< float >, TPL< double >, TPL< std::string > >
	Like UserTypeTemplateVariant but without ChimeraTK::Void.

Enumerations
enum class	AccessMode { raw , wait_for_new_data }
	Enum type with access mode flags for register accessors. More...

enum class	ImgFormat : unsigned { Unset = 0 , Gray8 , Gray16 , RGB24 , RGBA32 , FLOAT1 , FLOAT2 , FLOAT3 , FLOAT4 , DOUBLE1 , DOUBLE2 , DOUBLE3 , DOUBLE4 }

enum class	ImgOptions { RowMajor = 1 , ColMajor = 0 }

enum class	DataValidity { ok , faulty }
	The current state of the data. More...

enum class	TransferType { read , readNonBlocking , readLatest , write , writeDestructively }
	Used to indicate the applicable operation on a Transferelement. More...

enum class	DecoratorType { limiting , C_style_conversion }
	There are two types of TypeChanging decorators which do different data conversions from the user data type to the implementation data type. More...

enum class	TestCapability { unspecified , enabled , disabled }
	Used by the Capabilities descriptor. More...

Functions
	DECLARE_TEMPLATE_FOR_CHIMERATK_USER_TYPES (DummyInterruptTriggerAccessor)

	DECLARE_TEMPLATE_FOR_CHIMERATK_USER_TYPES (LNMBackendBitAccessor)

	DECLARE_TEMPLATE_FOR_CHIMERATK_USER_TYPES (LNMBackendChannelAccessor)

	DECLARE_TEMPLATE_FOR_CHIMERATK_USER_TYPES (LNMBackendVariableAccessor)

template<>
std::string	LogicalNameMapParser::getValueFromXmlSubnode< std::string > (const xmlpp::Node *node, const std::string &subnodeName, BackendRegisterCatalogue< LNMBackendRegisterInfo > const &catalogue, bool hasDefault, std::string defaultValue)

	INSTANTIATE_TEMPLATE_FOR_CHIMERATK_USER_TYPES (LNMBackendBitAccessor)

	INSTANTIATE_TEMPLATE_FOR_CHIMERATK_USER_TYPES (LNMBackendChannelAccessor)

	INSTANTIATE_TEMPLATE_FOR_CHIMERATK_USER_TYPES (LNMBackendVariableAccessor)

template<>
std::string	LogicalNameMapParser::getValueFromXmlSubnode< std::string > (const xmlpp::Node *node, const std::string &subnodeName, BackendRegisterCatalogue< LNMBackendRegisterInfo > const &catalogue, bool hasDefault, std::string defaultValue)

	INSTANTIATE_TEMPLATE_FOR_CHIMERATK_USER_TYPES (InstantiateLogicalNameMappingBackendFunctions)

std::unique_ptr< RebotProtocolImplementor >	getProtocolImplementor (boost::shared_ptr< Rebot::Connection > &c)

uint32_t	getProtocolVersion (boost::shared_ptr< Rebot::Connection > &c)

uint32_t	parseRxServerHello (const std::vector< uint32_t > &serverHello)

	DECLARE_MULTI_TEMPLATE_FOR_CHIMERATK_USER_TYPES (ConvertingDecorator, uint8_t)

	DECLARE_MULTI_TEMPLATE_FOR_CHIMERATK_USER_TYPES (ConvertingDecorator, uint16_t)

	DECLARE_MULTI_TEMPLATE_FOR_CHIMERATK_USER_TYPES (ConvertingDecorator, uint32_t)

	DECLARE_MULTI_TEMPLATE_FOR_CHIMERATK_USER_TYPES (ConvertingDecorator, uint64_t)

	DECLARE_MULTI_TEMPLATE_FOR_CHIMERATK_USER_TYPES (ConvertingDecorator, int32_t)

	DECLARE_TEMPLATE_FOR_CHIMERATK_RAW_TYPES (ConvertingRawDecorator)

	DECLARE_MULTI_TEMPLATE_FOR_CHIMERATK_RAW_TYPES (SubdeviceRegisterWindowAccessor, uint8_t)

	DECLARE_MULTI_TEMPLATE_FOR_CHIMERATK_RAW_TYPES (SubdeviceRegisterWindowAccessor, uint16_t)

	DECLARE_MULTI_TEMPLATE_FOR_CHIMERATK_RAW_TYPES (SubdeviceRegisterWindowAccessor, uint32_t)

	DECLARE_MULTI_TEMPLATE_FOR_CHIMERATK_RAW_TYPES (SubdeviceRegisterWindowAccessor, uint64_t)

	INSTANTIATE_MULTI_TEMPLATE_FOR_CHIMERATK_USER_TYPES (ConvertingDecorator, uint8_t)

	INSTANTIATE_MULTI_TEMPLATE_FOR_CHIMERATK_USER_TYPES (ConvertingDecorator, uint16_t)

	INSTANTIATE_MULTI_TEMPLATE_FOR_CHIMERATK_USER_TYPES (ConvertingDecorator, uint32_t)

	INSTANTIATE_MULTI_TEMPLATE_FOR_CHIMERATK_USER_TYPES (ConvertingDecorator, uint64_t)

	INSTANTIATE_MULTI_TEMPLATE_FOR_CHIMERATK_USER_TYPES (ConvertingDecorator, int32_t)

	INSTANTIATE_TEMPLATE_FOR_CHIMERATK_RAW_TYPES (ConvertingRawDecorator)

	INSTANTIATE_MULTI_TEMPLATE_FOR_CHIMERATK_RAW_TYPES (SubdeviceRegisterWindowAccessor, uint8_t)

	INSTANTIATE_MULTI_TEMPLATE_FOR_CHIMERATK_RAW_TYPES (SubdeviceRegisterWindowAccessor, uint16_t)

	INSTANTIATE_MULTI_TEMPLATE_FOR_CHIMERATK_RAW_TYPES (SubdeviceRegisterWindowAccessor, uint32_t)

	INSTANTIATE_MULTI_TEMPLATE_FOR_CHIMERATK_RAW_TYPES (SubdeviceRegisterWindowAccessor, uint64_t)

std::istream &	operator>> (std::istream &is, Boolean &value)

std::string	to_string (Boolean &value)

	DECLARE_TEMPLATE_FOR_CHIMERATK_USER_TYPES (DataConsistencyDecorator)

std::ostream &	operator<< (std::ostream &stream, const DataDescriptor::FundamentalType &fundamentalType)

	DECLARE_TEMPLATE_FOR_CHIMERATK_USER_TYPES (DoubleBufferAccessor)

	DECLARE_TEMPLATE_FOR_CHIMERATK_USER_TYPES (NDRegisterAccessor)

	DECLARE_TEMPLATE_FOR_CHIMERATK_USER_TYPES (NumericAddressedBackendMuxedRegisterAccessor)

	DECLARE_MULTI_TEMPLATE_FOR_CHIMERATK_USER_TYPES (NumericAddressedBackendRegisterAccessor, true)

	DECLARE_MULTI_TEMPLATE_FOR_CHIMERATK_USER_TYPES (NumericAddressedBackendRegisterAccessor, false)

RegisterPath	operator/ (const RegisterPath &leftHandSide, const RegisterPath &rightHandSide)
	non-member / operator: add a new element to the path.

std::string	operator+ (const std::string &leftHandSide, const RegisterPath &rightHandSide)
	non-member + operator for RegisterPath: concatenate with normal strings.

RegisterPath	operator+ (const RegisterPath &leftHandSide, const std::string &rightHandSide)

RegisterPath	operator/ (const RegisterPath &leftHandSide, int rightHandSide)
	operators used to build numeric addresses from integers

RegisterPath	operator* (const RegisterPath &leftHandSide, int rightHandSide)

std::ostream &	operator<< (std::ostream &os, const RegisterPath &me)
	streaming operator

template<typename UserType , typename NUMERIC >
UserType	numericToUserType (NUMERIC value)
	Helper function to convert numeric data into any UserType (even if it is a string etc.).

template<typename NUMERIC , typename UserType >
NUMERIC	userTypeToNumeric (UserType value)
	Helper function to convert numeric data into any UserType (even if it is a string etc.).

template<typename UserTypeReturn , typename UserTypeParameter >
UserTypeReturn	userTypeToUserType (UserTypeParameter value)
	Helper function to convert any UserType data into any other UserType (even if it is a string etc.).

template<typename MAPTYPE , typename LAMBDATYPE >
void	for_each (MAPTYPE &map, const LAMBDATYPE &lambda)
	Variant of boost::fusion::for_each() to iterate a boost::fusion::map, which accepts a lambda instead of the callable class requred by the boost version.

template<typename LAMBDATYPE >
void	callForType (const std::type_info &type, LAMBDATYPE lambda)
	Helper function for running code which uses some compile-time type that is specified at runtime as a type_info.

template<typename LAMBDATYPE >
void	callForType (const DataType &type, LAMBDATYPE lambda)
	Alternate form of callForType() which takes a DataType as a runtime type description.

template<typename TYPE_DESCRIPTOR , typename LAMBDATYPE >
void	callForTypeNoVoid (const TYPE_DESCRIPTOR &typeDescriptor, LAMBDATYPE lambda)
	Like callForType() but omit the Void data type.

template<typename LAMBDATYPE >
void	callForRawType (const DataType &type, LAMBDATYPE lambda)
	callForRawType() is similar to callForType(), just with a subset of supported data types which can be raw types in the NumericAddressedBackend.

std::ostream &	operator<< (std::ostream &os, const DataValidity &validity)

std::ostream &	operator<< (std::ostream &os, const TransferElementID &me)
	Streaming operator to stream the TransferElementID e.g.

template<class UserType >
boost::shared_ptr< ChimeraTK::NDRegisterAccessor< UserType > >	getTypeChangingDecorator (const boost::shared_ptr< ChimeraTK::TransferElement > &transferElement, DecoratorType decoratorType=DecoratorType::limiting)
	The factory function for type changing decorators.

template<class UserType >
boost::shared_ptr< ChimeraTK::NDRegisterAccessor< UserType > >	getTypeChangingDecorator (ChimeraTK::TransferElementAbstractor &transferElement, DecoratorType decoratorType=DecoratorType::limiting)

std::map< DecoratorMapKey, boost::shared_ptr< ChimeraTK::TransferElement > > &	getGlobalDecoratorMap ()
	Quasi singleton to have a unique, global map across UserType templated factories.

template<typename UserType >
bool	compareHelper (UserType a, UserType b)

template<>
bool	compareHelper< double > (double a, double b)

template<>
bool	compareHelper< float > (float a, float b)

template<>
bool	compareHelper< std::string > (std::string a, std::string b)

std::string	getDMapFilePath ()
	Returns the dmap file name which the library currently uses for looking up device(alias) names.

void	setDMapFilePath (std::string dmapFilePath)
	Set the location of the dmap file.

std::ostream &	operator<< (std::ostream &stream, const VersionNumber &version)
	Stream operator passing the human readable representation to an ostream.

std::istream &	operator>> (std::istream &is, __attribute__((unused)) Void &value)

std::ostream &	operator<< (std::ostream &os, __attribute__((unused)) Void &value)

std::ostream &	operator<< (std::ostream &os, const DeviceInfoMap &deviceInfoMap)

std::ostream &	operator<< (std::ostream &os, const DeviceInfoMap::DeviceInfo &deviceInfo)

std::ostream &	operator<< (std::ostream &os, const DeviceInfoMap::ErrorList::ErrorElem::TYPE &me)

std::ostream &	operator<< (std::ostream &os, const DeviceInfoMap::ErrorList::ErrorElem &me)

std::ostream &	operator<< (std::ostream &os, const DeviceInfoMap::ErrorList &me)

	INSTANTIATE_TEMPLATE_FOR_CHIMERATK_USER_TYPES (DoubleBufferAccessor)

	INSTANTIATE_TEMPLATE_FOR_CHIMERATK_USER_TYPES (DummyInterruptTriggerAccessor)

	INSTANTIATE_TEMPLATE_FOR_CHIMERATK_USER_TYPES (NDRegisterAccessor)

	INSTANTIATE_TEMPLATE_FOR_CHIMERATK_USER_TYPES (NumericAddressedBackendMuxedRegisterAccessor)

	INSTANTIATE_MULTI_TEMPLATE_FOR_CHIMERATK_USER_TYPES (NumericAddressedBackendRegisterAccessor, true)

	INSTANTIATE_MULTI_TEMPLATE_FOR_CHIMERATK_USER_TYPES (NumericAddressedBackendRegisterAccessor, false)

std::atomic< bool >	stop_rebot_server (false)

Variables
const int	SHARED_MEMORY_N_MAX_MEMBER = 10

template<typename T >
constexpr bool	isBoolean = std::is_same_v<T, bool> \|\| std::is_same_v<T, Boolean>

constexpr auto	MULTIPLEXED_SEQUENCE_PREFIX = "AREA_MULTIPLEXED_SEQUENCE_"

constexpr auto	SEQUENCE_PREFIX = "SEQUENCE_"

constexpr auto	MEM_MULTIPLEXED_PREFIX = "MEM_MULTIPLEXED_"

template<typename T >
constexpr bool	isUserType
	Constant which alles to check whether a type is one of the supported ChimeraTK UserTypes.

template<typename T >
constexpr bool	isRawType
	Constant which alles to check whether a type is one of the supported ChimeraTK RawTypes.

constexpr auto	DUMMY_WRITEABLE_SUFFIX = "DUMMY_WRITEABLE"

constexpr auto	DUMMY_READABLE_SUFFIX = "DUMMY_READABLE"

constexpr auto	DUMMY_INTERRUPT_REGISTER_PREFIX = "/DUMMY_INTERRUPT_"

std::map< DecoratorMapKey, boost::shared_ptr< ChimeraTK::TransferElement > >	globalDecoratorMap

std::atomic< bool >	stop_rebot_server

Detailed Description

Todo:: FIXME My dynamic init header is a hack. Change the test to use BOOST_AUTO_TEST_CASE!

Todo:: FIXME My dynamic init header is a hack. Change the test to use BOOST_AUTO_TEST_CASE!

Typedef Documentation

◆ DeviceInfoMapPointer

ChimeraTK::DeviceInfoMapPointer

Introduce specialisation of shared_pointer template for pointers to RegisterInfoMap object as a DeviceInfoMapPointer.

Definition at line 223 of file DeviceInfoMap.h.

◆ HiddenRange

using ChimeraTK::HiddenRange = typedef boost::any_range<BackendRegisterInfoBase, boost::forward_traversal_tag, const BackendRegisterInfoBase&, std::ptrdiff_t>

Forward range with type-erasure, used to get a range of hidden registers.

Definition at line 21 of file RegisterCatalogue.h.

◆ RawTypeTuple

using ChimeraTK::RawTypeTuple = typedef std::tuple<uint8_t, uint16_t, uint32_t, uint64_t>

Convenience type definition of a std::tuple with all possible RawTypes.

Definition at line 51 of file TupleUserTypes.h.

◆ SingleTypeUserTypeMap

template<typename T >

using ChimeraTK::SingleTypeUserTypeMap = typedef boost::fusion::map<boost::fusion::pair<int8_t, T>, boost::fusion::pair<uint8_t, T>, boost::fusion::pair<int16_t, T>, boost::fusion::pair<uint16_t, T>, boost::fusion::pair<int32_t, T>, boost::fusion::pair<uint32_t, T>, boost::fusion::pair<int64_t, T>, boost::fusion::pair<uint64_t, T>, boost::fusion::pair<float, T>, boost::fusion::pair<double, T>, boost::fusion::pair<std::string, T>, boost::fusion::pair<Boolean, T>, boost::fusion::pair<Void, T> >

Map of UserType to a single type.

Definition at line 385 of file SupportedUserTypes.h.

◆ SingleTypeUserTypeMapNoVoid

template<typename T >

using ChimeraTK::SingleTypeUserTypeMapNoVoid = typedef boost::fusion::map<boost::fusion::pair<int8_t, T>, boost::fusion::pair<uint8_t, T>, boost::fusion::pair<int16_t, T>, boost::fusion::pair<uint16_t, T>, boost::fusion::pair<int32_t, T>, boost::fusion::pair<uint32_t, T>, boost::fusion::pair<int64_t, T>, boost::fusion::pair<uint64_t, T>, boost::fusion::pair<float, T>, boost::fusion::pair<double, T>, boost::fusion::pair<std::string, T>, boost::fusion::pair<Boolean, T> >

Just like SingleTypeUserTypeMap, only without the ChimeraTK::Void type.

Definition at line 393 of file SupportedUserTypes.h.

◆ userTypeMap

using ChimeraTK::userTypeMap = typedef boost::fusion::map<boost::fusion::pair<int8_t, int8_t>, boost::fusion::pair<uint8_t, uint8_t>, boost::fusion::pair<int16_t, int16_t>, boost::fusion::pair<uint16_t, uint16_t>, boost::fusion::pair<int32_t, int32_t>, boost::fusion::pair<uint32_t, uint32_t>, boost::fusion::pair<int64_t, int64_t>, boost::fusion::pair<uint64_t, uint64_t>, boost::fusion::pair<float, float>, boost::fusion::pair<double, double>, boost::fusion::pair<std::string, std::string>, boost::fusion::pair<Boolean, Boolean>, boost::fusion::pair<Void, Void> >

Map of UserType to value of the UserType.

Definition at line 310 of file SupportedUserTypes.h.

◆ userTypeMapNoVoid

using ChimeraTK::userTypeMapNoVoid = typedef boost::fusion::map<boost::fusion::pair<int8_t, int8_t>, boost::fusion::pair<uint8_t, uint8_t>, boost::fusion::pair<int16_t, int16_t>, boost::fusion::pair<uint16_t, uint16_t>, boost::fusion::pair<int32_t, int32_t>, boost::fusion::pair<uint32_t, uint32_t>, boost::fusion::pair<int64_t, int64_t>, boost::fusion::pair<uint64_t, uint64_t>, boost::fusion::pair<float, float>, boost::fusion::pair<double, double>, boost::fusion::pair<std::string, std::string>, boost::fusion::pair<Boolean, Boolean> >

Just like userTypeMap, only without the ChimeraTK::Void type.

Definition at line 318 of file SupportedUserTypes.h.

◆ UserTypeTemplateTuple

template<template< typename > class TPL>

using ChimeraTK::UserTypeTemplateTuple = typedef std::tuple<TPL<ChimeraTK::Boolean>, TPL<int8_t>, TPL<uint8_t>, TPL<int16_t>, TPL<uint16_t>, TPL<int32_t>, TPL<uint32_t>, TPL<int64_t>, TPL<uint64_t>, TPL<float>, TPL<double>, TPL<std::string>, TPL<ChimeraTK::Void> >

Convenience type definition of a std::tuple with the given class template instantiated for all all possible UserTypes.

This is a standard library replacement for ChimeraTK::TemplateUserTypeMap.

Definition at line 36 of file TupleUserTypes.h.

◆ UserTypeTemplateTupleNoVoid

template<template< typename > class TPL>

using ChimeraTK::UserTypeTemplateTupleNoVoid = typedef std::tuple<TPL<ChimeraTK::Boolean>, TPL<int8_t>, TPL<uint8_t>, TPL<int16_t>, TPL<uint16_t>, TPL<int32_t>, TPL<uint32_t>, TPL<int64_t>, TPL<uint64_t>, TPL<float>, TPL<double>, TPL<std::string> >

Like UserTypeTemplateTuple but without ChimeraTK::Void.

Definition at line 44 of file TupleUserTypes.h.

◆ UserTypeTemplateVariant

template<template< typename > class TPL>

using ChimeraTK::UserTypeTemplateVariant = typedef std::variant<TPL<ChimeraTK::Boolean>, TPL<int8_t>, TPL<uint8_t>, TPL<int16_t>, TPL<uint16_t>, TPL<int32_t>, TPL<uint32_t>, TPL<int64_t>, TPL<uint64_t>, TPL<float>, TPL<double>, TPL<std::string>, TPL<ChimeraTK::Void> >

Convenience type definition of a std::variant with the given class template instantiated for all all possible UserTypes.

In contrast to ChimeraTK::TemplateUserTypeMap, only one value is stored in the UserTypeTemplateVariant, and there is some runtime overhead to access the value (which UserType is stored in the variant is a runtime decision).

Definition at line 38 of file VariantUserTypes.h.

◆ UserTypeTemplateVariantNoVoid

template<template< typename > class TPL>

using ChimeraTK::UserTypeTemplateVariantNoVoid = typedef std::variant<TPL<ChimeraTK::Boolean>, TPL<int8_t>, TPL<uint8_t>, TPL<int16_t>, TPL<uint16_t>, TPL<int32_t>, TPL<uint32_t>, TPL<int64_t>, TPL<uint64_t>, TPL<float>, TPL<double>, TPL<std::string> >

Like UserTypeTemplateVariant but without ChimeraTK::Void.

Definition at line 46 of file VariantUserTypes.h.

◆ UserTypeTuple

using ChimeraTK::UserTypeTuple = typedef std::tuple<ChimeraTK::Boolean, int8_t, uint8_t, int16_t, uint16_t, int32_t, uint32_t, int64_t, uint64_t, float, double, std::string, ChimeraTK::Void>

Convenience type definition of a std::tuple with all possible UserTypes.

This is a standard library replacement for ChimeraTK::userTypeMap.

Definition at line 20 of file TupleUserTypes.h.

◆ UserTypeTupleNoVoid

using ChimeraTK::UserTypeTupleNoVoid = typedef std::tuple<ChimeraTK::Boolean, int8_t, uint8_t, int16_t, uint16_t, int32_t, uint32_t, int64_t, uint64_t, float, double, std::string>

Like UserTypeVariUserTypeTupleant but without ChimeraTK::Void.

Definition at line 26 of file TupleUserTypes.h.

◆ UserTypeVariant

using ChimeraTK::UserTypeVariant = typedef std::variant<ChimeraTK::Boolean, int8_t, uint8_t, int16_t, uint16_t, int32_t, uint32_t, int64_t, uint64_t, float, double, std::string, ChimeraTK::Void>

Convenience type definition of a std::variant with all possible UserTypes.

In contrast to ChimeraTK::userTypeMap, only one value is stored in the UserTypeVariant, and there is some runtime overhead to access the value (which UserType is stored in the variant is a runtime decision).

Definition at line 21 of file VariantUserTypes.h.

◆ UserTypeVariantNoVoid

using ChimeraTK::UserTypeVariantNoVoid = typedef std::variant<ChimeraTK::Boolean, int8_t, uint8_t, int16_t, uint16_t, int32_t, uint32_t, int64_t, uint64_t, float, double, std::string>

Like UserTypeVariant but without ChimeraTK::Void.

Definition at line 27 of file VariantUserTypes.h.

Enumeration Type Documentation

◆ AccessMode

enum class ChimeraTK::AccessMode

strong

Enum type with access mode flags for register accessors.

Developers note: when adding new flags, also add the flag in the map of the AccessModeFlags with a string representation.

Enumerator

raw

Raw access: disable any possible conversion from the original hardware data type into the given UserType.

Obtaining the accessor with a UserType unequal to the actual raw data type will fail and throw a DeviceException with the id EX_WRONG_PARAMETER.

Note: using this flag will make your code intrinsically dependent on the backend type, since the actual raw data type must be known.

wait_for_new_data

Make any read blocking until new data has arrived since the last read.

This flag may not be suppoerted by all registers (and backends), in which case a DeviceException with the id NOT_IMPLEMENTED will be thrown.

Definition at line 20 of file AccessMode.h.

◆ DataValidity

enum class ChimeraTK::DataValidity

strong

The current state of the data.

This is a flag to describe the validity of the data. It should be used to signalize whether or not to trust the data currently. It MUST NOT be used to signalize any communication errors with a device, rather to signalize the consumer after such an error that the data is currently not trustable, because we are performing calculations with the last known valid data, for example.

Enumerator

ok

faulty

The data is considered valid.

The data is not considered valid

Definition at line 42 of file TransferElement.h.

◆ DecoratorType

enum class ChimeraTK::DecoratorType

strong

There are two types of TypeChanging decorators which do different data conversions from the user data type to the implementation data type.

limiting This decorator limits the data to the maximum possible in the target data type (for instance 500 will result in 127 in int8_t and 255 in uint8_t, -200 will be -128 in int8t, 0 in uint8_t). This decorator also does correct rounding from floating point to integer type.
C_style_conversion This decorator does a direct cast like an assigment in C/C++ does it. For instance 500 (=0x1f4) will result in 0xf4 for an 8 bit integer, which is interpreted as 244 in uint8_t and -12 in int8_t. Digits after the decimal point are cut when converting a floating point value to an integer type. This decorator can be useful to display unsigned integers which use the full dynamic range in a control system which only supports signed data types (the user has to correctly interpret the 'wrong' representation), of for bit fields where it is acceptable to lose the higher bits.

Enumerator
limiting
C_style_conversion

Definition at line 31 of file TypeChangingDecorator.h.

◆ ImgFormat

enum class ChimeraTK::ImgFormat : unsigned

strong

Enumerator
Unset
Gray8
Gray16
RGB24
RGBA32
FLOAT1
FLOAT2
FLOAT3
FLOAT4
DOUBLE1
DOUBLE2
DOUBLE3
DOUBLE4

Definition at line 66 of file MappedImage.h.

◆ ImgOptions

enum class ChimeraTK::ImgOptions

strong

Enumerator
RowMajor
ColMajor

Definition at line 83 of file MappedImage.h.

◆ TestCapability

enum class ChimeraTK::TestCapability

strong

Used by the Capabilities descriptor.

Enumerator
unspecified	Capability is not specified, hence it is disabled and a warning is printed. Usually default.
enabled	Enable tests requiring this capability.
disabled	Disable tests requiring this capability and do not warn.

Definition at line 26 of file UnifiedBackendTest.h.

◆ TransferType

enum class ChimeraTK::TransferType

strong

Used to indicate the applicable operation on a Transferelement.

Enumerator
read
readNonBlocking
readLatest
write
writeDestructively

Definition at line 52 of file TransferElement.h.

Function Documentation

◆ callForRawType()

template<typename LAMBDATYPE >

void ChimeraTK::callForRawType	(	const DataType &	type,
		LAMBDATYPE	lambda
	)

callForRawType() is similar to callForType(), just with a subset of supported data types which can be raw types in the NumericAddressedBackend.

Definition at line 985 of file SupportedUserTypes.h.

◆ callForType() [1/2]

template<typename LAMBDATYPE >

void ChimeraTK::callForType	(	const DataType &	type,
		LAMBDATYPE	lambda
	)

Alternate form of callForType() which takes a DataType as a runtime type description.

If DataType::none is passed, std::bad_cast is thrown. For more details have a look at the other form.

Definition at line 911 of file SupportedUserTypes.h.

◆ callForType() [2/2]

template<typename LAMBDATYPE >

void ChimeraTK::callForType	(	const std::type_info &	type,
		LAMBDATYPE	lambda
	)

Helper function for running code which uses some compile-time type that is specified at runtime as a type_info.

The code has to be written in a lambda with a single auto-typed argument (this requires C++ 14). This argument will have the type specified by the argument "type". The type must be one of the user types supported by ChimeraTK DeviceAccess. Otherwise, std::bad_cast is thrown.

The lamda should be declared like this:

auto myLambda [](auto arg) { std::cout << typeid(decltype(arg)).name() << std::endl; });

The value of the argument "arg" is undefined, only its type should be used (via decltype(arg)). This lambda can then be called like this:

callForType(typeid(int), myLambda);

This will effectively execute the following code:

std::cout << typeid(int).name() << std::endl;

Please note that this call is not as efficient as a direct call to a template. For each call all allowed user types have to be tested against the given type_info.

Definition at line 880 of file SupportedUserTypes.h.

◆ callForTypeNoVoid()

template<typename TYPE_DESCRIPTOR , typename LAMBDATYPE >

void ChimeraTK::callForTypeNoVoid	(	const TYPE_DESCRIPTOR &	typeDescriptor,
		LAMBDATYPE	lambda
	)

Like callForType() but omit the Void data type.

typeDescriptor can be either a std::type_info or a ChimeraTK::DataType.

Definition at line 972 of file SupportedUserTypes.h.

◆ compareHelper()

template<typename UserType >

bool ChimeraTK::compareHelper	(	UserType	a,
		UserType	b
	)

Definition at line 672 of file UnifiedBackendTest.h.

◆ compareHelper< double >()

template<>

bool ChimeraTK::compareHelper< double >	(	double	a,
		double	b
	)

inline

Definition at line 677 of file UnifiedBackendTest.h.

◆ compareHelper< float >()

template<>

bool ChimeraTK::compareHelper< float >	(	float	a,
		float	b
	)

inline

Definition at line 682 of file UnifiedBackendTest.h.

◆ compareHelper< std::string >()

template<>

bool ChimeraTK::compareHelper< std::string >	(	std::string	a,
		std::string	b
	)

inline

Definition at line 688 of file UnifiedBackendTest.h.

◆ DECLARE_MULTI_TEMPLATE_FOR_CHIMERATK_RAW_TYPES() [1/4]

ChimeraTK::DECLARE_MULTI_TEMPLATE_FOR_CHIMERATK_RAW_TYPES	(	SubdeviceRegisterWindowAccessor	,
		uint16_t
	)

◆ DECLARE_MULTI_TEMPLATE_FOR_CHIMERATK_RAW_TYPES() [2/4]

ChimeraTK::DECLARE_MULTI_TEMPLATE_FOR_CHIMERATK_RAW_TYPES	(	SubdeviceRegisterWindowAccessor	,
		uint32_t
	)

◆ DECLARE_MULTI_TEMPLATE_FOR_CHIMERATK_RAW_TYPES() [3/4]

ChimeraTK::DECLARE_MULTI_TEMPLATE_FOR_CHIMERATK_RAW_TYPES	(	SubdeviceRegisterWindowAccessor	,
		uint64_t
	)

◆ DECLARE_MULTI_TEMPLATE_FOR_CHIMERATK_RAW_TYPES() [4/4]

ChimeraTK::DECLARE_MULTI_TEMPLATE_FOR_CHIMERATK_RAW_TYPES	(	SubdeviceRegisterWindowAccessor	,
		uint8_t
	)

◆ DECLARE_MULTI_TEMPLATE_FOR_CHIMERATK_USER_TYPES() [1/7]

ChimeraTK::DECLARE_MULTI_TEMPLATE_FOR_CHIMERATK_USER_TYPES	(	ConvertingDecorator	,
		int32_t
	)

◆ DECLARE_MULTI_TEMPLATE_FOR_CHIMERATK_USER_TYPES() [2/7]

ChimeraTK::DECLARE_MULTI_TEMPLATE_FOR_CHIMERATK_USER_TYPES	(	ConvertingDecorator	,
		uint16_t
	)

◆ DECLARE_MULTI_TEMPLATE_FOR_CHIMERATK_USER_TYPES() [3/7]

ChimeraTK::DECLARE_MULTI_TEMPLATE_FOR_CHIMERATK_USER_TYPES	(	ConvertingDecorator	,
		uint32_t
	)

◆ DECLARE_MULTI_TEMPLATE_FOR_CHIMERATK_USER_TYPES() [4/7]

ChimeraTK::DECLARE_MULTI_TEMPLATE_FOR_CHIMERATK_USER_TYPES	(	ConvertingDecorator	,
		uint64_t
	)

◆ DECLARE_MULTI_TEMPLATE_FOR_CHIMERATK_USER_TYPES() [5/7]

ChimeraTK::DECLARE_MULTI_TEMPLATE_FOR_CHIMERATK_USER_TYPES	(	ConvertingDecorator	,
		uint8_t
	)

◆ DECLARE_MULTI_TEMPLATE_FOR_CHIMERATK_USER_TYPES() [6/7]

ChimeraTK::DECLARE_MULTI_TEMPLATE_FOR_CHIMERATK_USER_TYPES	(	NumericAddressedBackendRegisterAccessor	,
		false
	)

◆ DECLARE_MULTI_TEMPLATE_FOR_CHIMERATK_USER_TYPES() [7/7]

ChimeraTK::DECLARE_MULTI_TEMPLATE_FOR_CHIMERATK_USER_TYPES	(	NumericAddressedBackendRegisterAccessor	,
		true
	)

◆ DECLARE_TEMPLATE_FOR_CHIMERATK_RAW_TYPES()

ChimeraTK::DECLARE_TEMPLATE_FOR_CHIMERATK_RAW_TYPES ( ConvertingRawDecorator )

◆ DECLARE_TEMPLATE_FOR_CHIMERATK_USER_TYPES() [1/8]

ChimeraTK::DECLARE_TEMPLATE_FOR_CHIMERATK_USER_TYPES ( DataConsistencyDecorator )

◆ DECLARE_TEMPLATE_FOR_CHIMERATK_USER_TYPES() [2/8]

ChimeraTK::DECLARE_TEMPLATE_FOR_CHIMERATK_USER_TYPES ( DoubleBufferAccessor )

◆ DECLARE_TEMPLATE_FOR_CHIMERATK_USER_TYPES() [3/8]

ChimeraTK::DECLARE_TEMPLATE_FOR_CHIMERATK_USER_TYPES ( DummyInterruptTriggerAccessor )

◆ DECLARE_TEMPLATE_FOR_CHIMERATK_USER_TYPES() [4/8]

ChimeraTK::DECLARE_TEMPLATE_FOR_CHIMERATK_USER_TYPES ( LNMBackendBitAccessor )

◆ DECLARE_TEMPLATE_FOR_CHIMERATK_USER_TYPES() [5/8]

ChimeraTK::DECLARE_TEMPLATE_FOR_CHIMERATK_USER_TYPES ( LNMBackendChannelAccessor )

◆ DECLARE_TEMPLATE_FOR_CHIMERATK_USER_TYPES() [6/8]

ChimeraTK::DECLARE_TEMPLATE_FOR_CHIMERATK_USER_TYPES ( LNMBackendVariableAccessor )

◆ DECLARE_TEMPLATE_FOR_CHIMERATK_USER_TYPES() [7/8]

ChimeraTK::DECLARE_TEMPLATE_FOR_CHIMERATK_USER_TYPES ( NDRegisterAccessor )

◆ DECLARE_TEMPLATE_FOR_CHIMERATK_USER_TYPES() [8/8]

ChimeraTK::DECLARE_TEMPLATE_FOR_CHIMERATK_USER_TYPES ( NumericAddressedBackendMuxedRegisterAccessor )

◆ for_each()

template<typename MAPTYPE , typename LAMBDATYPE >

void ChimeraTK::for_each	(	MAPTYPE &	map,
		const LAMBDATYPE &	lambda
	)

Variant of boost::fusion::for_each() to iterate a boost::fusion::map, which accepts a lambda instead of the callable class requred by the boost version.

The lambda must have one single argument of the type auto, which will be a boost::fusion::pair<>.

Definition at line 849 of file SupportedUserTypes.h.

◆ getDMapFilePath()

std::string ChimeraTK::getDMapFilePath ( )

Returns the dmap file name which the library currently uses for looking up device(alias) names.

Definition at line 323 of file Utilities.cpp.

◆ getGlobalDecoratorMap()

std::map< DecoratorMapKey, boost::shared_ptr< ChimeraTK::TransferElement > > & ChimeraTK::getGlobalDecoratorMap ( )

Quasi singleton to have a unique, global map across UserType templated factories.

We need it to loop up if a decorator has already been created for the transfer element, and return this if so. Multiple decorators for the same transfer element don't work.

Definition at line 11 of file TypeChangingDecorator.cc.

◆ getProtocolImplementor()

std::unique_ptr< RebotProtocolImplementor > ChimeraTK::getProtocolImplementor ( boost::shared_ptr< Rebot::Connection > & c )

Definition at line 22 of file RebotBackend.cc.

◆ getProtocolVersion()

uint32_t ChimeraTK::getProtocolVersion ( boost::shared_ptr< Rebot::Connection > & c )

Definition at line 36 of file RebotBackend.cc.

◆ getTypeChangingDecorator() [1/2]

template<class UserType >

boost::shared_ptr< ChimeraTK::NDRegisterAccessor< UserType > > ChimeraTK::getTypeChangingDecorator	(	ChimeraTK::TransferElementAbstractor &	transferElement,
		DecoratorType	decoratorType = `DecoratorType::limiting`
	)

Definition at line 59 of file TypeChangingDecorator.h.

◆ getTypeChangingDecorator() [2/2]

template<class UserType >

boost::shared_ptr< ChimeraTK::NDRegisterAccessor< UserType > > ChimeraTK::getTypeChangingDecorator	(	const boost::shared_ptr< ChimeraTK::TransferElement > &	transferElement,
		DecoratorType	decoratorType = `DecoratorType::limiting`
	)

The factory function for type changing decorators.

TypeChanging decorators take a transfer element (usually NDRegisterAccessor<ImplType>) and wraps it in an NDRegisterAccessor<UserType>. It automatically performs the right type conversion (configurable as argument of the factory function). The decorator has it's own buffer of type UserType and synchronises it in the preWrite() and postRead() functions with the implementation. You don't have to care about the implementation type of the transfer element. The factory will automatically create the correct decorator.

Note: it is possible to obtain multiple decorators of different types for the same accessor. The user needs to ensure that the preXxx/postXxx transfer functions are properly called for all decorators when required.

Parameters

transferElement	The TransferElement to be decorated. It can either be an NDRegisterAccessor (usually the case) or and NDRegisterAccessorAbstractor (but here the user already picks the type he wants).
decoratorType	The type of decorator you want (see description of DecoratorType)

Definition at line 614 of file TypeChangingDecorator.h.

◆ INSTANTIATE_MULTI_TEMPLATE_FOR_CHIMERATK_RAW_TYPES() [1/4]

ChimeraTK::INSTANTIATE_MULTI_TEMPLATE_FOR_CHIMERATK_RAW_TYPES	(	SubdeviceRegisterWindowAccessor	,
		uint16_t
	)

◆ INSTANTIATE_MULTI_TEMPLATE_FOR_CHIMERATK_RAW_TYPES() [2/4]

ChimeraTK::INSTANTIATE_MULTI_TEMPLATE_FOR_CHIMERATK_RAW_TYPES	(	SubdeviceRegisterWindowAccessor	,
		uint32_t
	)

◆ INSTANTIATE_MULTI_TEMPLATE_FOR_CHIMERATK_RAW_TYPES() [3/4]

ChimeraTK::INSTANTIATE_MULTI_TEMPLATE_FOR_CHIMERATK_RAW_TYPES	(	SubdeviceRegisterWindowAccessor	,
		uint64_t
	)

◆ INSTANTIATE_MULTI_TEMPLATE_FOR_CHIMERATK_RAW_TYPES() [4/4]

ChimeraTK::INSTANTIATE_MULTI_TEMPLATE_FOR_CHIMERATK_RAW_TYPES	(	SubdeviceRegisterWindowAccessor	,
		uint8_t
	)

◆ INSTANTIATE_MULTI_TEMPLATE_FOR_CHIMERATK_USER_TYPES() [1/7]

ChimeraTK::INSTANTIATE_MULTI_TEMPLATE_FOR_CHIMERATK_USER_TYPES	(	ConvertingDecorator	,
		int32_t
	)

◆ INSTANTIATE_MULTI_TEMPLATE_FOR_CHIMERATK_USER_TYPES() [2/7]

ChimeraTK::INSTANTIATE_MULTI_TEMPLATE_FOR_CHIMERATK_USER_TYPES	(	ConvertingDecorator	,
		uint16_t
	)

◆ INSTANTIATE_MULTI_TEMPLATE_FOR_CHIMERATK_USER_TYPES() [3/7]

ChimeraTK::INSTANTIATE_MULTI_TEMPLATE_FOR_CHIMERATK_USER_TYPES	(	ConvertingDecorator	,
		uint32_t
	)

◆ INSTANTIATE_MULTI_TEMPLATE_FOR_CHIMERATK_USER_TYPES() [4/7]

ChimeraTK::INSTANTIATE_MULTI_TEMPLATE_FOR_CHIMERATK_USER_TYPES	(	ConvertingDecorator	,
		uint64_t
	)

◆ INSTANTIATE_MULTI_TEMPLATE_FOR_CHIMERATK_USER_TYPES() [5/7]

ChimeraTK::INSTANTIATE_MULTI_TEMPLATE_FOR_CHIMERATK_USER_TYPES	(	ConvertingDecorator	,
		uint8_t
	)

◆ INSTANTIATE_MULTI_TEMPLATE_FOR_CHIMERATK_USER_TYPES() [6/7]

ChimeraTK::INSTANTIATE_MULTI_TEMPLATE_FOR_CHIMERATK_USER_TYPES	(	NumericAddressedBackendRegisterAccessor	,
		false
	)

◆ INSTANTIATE_MULTI_TEMPLATE_FOR_CHIMERATK_USER_TYPES() [7/7]

ChimeraTK::INSTANTIATE_MULTI_TEMPLATE_FOR_CHIMERATK_USER_TYPES	(	NumericAddressedBackendRegisterAccessor	,
		true
	)

◆ INSTANTIATE_TEMPLATE_FOR_CHIMERATK_RAW_TYPES()

ChimeraTK::INSTANTIATE_TEMPLATE_FOR_CHIMERATK_RAW_TYPES ( ConvertingRawDecorator )

◆ INSTANTIATE_TEMPLATE_FOR_CHIMERATK_USER_TYPES() [1/8]

ChimeraTK::INSTANTIATE_TEMPLATE_FOR_CHIMERATK_USER_TYPES ( DoubleBufferAccessor )

◆ INSTANTIATE_TEMPLATE_FOR_CHIMERATK_USER_TYPES() [2/8]

ChimeraTK::INSTANTIATE_TEMPLATE_FOR_CHIMERATK_USER_TYPES ( DummyInterruptTriggerAccessor )

◆ INSTANTIATE_TEMPLATE_FOR_CHIMERATK_USER_TYPES() [3/8]

ChimeraTK::INSTANTIATE_TEMPLATE_FOR_CHIMERATK_USER_TYPES ( InstantiateLogicalNameMappingBackendFunctions )

◆ INSTANTIATE_TEMPLATE_FOR_CHIMERATK_USER_TYPES() [4/8]

ChimeraTK::INSTANTIATE_TEMPLATE_FOR_CHIMERATK_USER_TYPES ( LNMBackendBitAccessor )

◆ INSTANTIATE_TEMPLATE_FOR_CHIMERATK_USER_TYPES() [5/8]

ChimeraTK::INSTANTIATE_TEMPLATE_FOR_CHIMERATK_USER_TYPES ( LNMBackendChannelAccessor )

◆ INSTANTIATE_TEMPLATE_FOR_CHIMERATK_USER_TYPES() [6/8]

ChimeraTK::INSTANTIATE_TEMPLATE_FOR_CHIMERATK_USER_TYPES ( LNMBackendVariableAccessor )

◆ INSTANTIATE_TEMPLATE_FOR_CHIMERATK_USER_TYPES() [7/8]

ChimeraTK::INSTANTIATE_TEMPLATE_FOR_CHIMERATK_USER_TYPES ( NDRegisterAccessor )

◆ INSTANTIATE_TEMPLATE_FOR_CHIMERATK_USER_TYPES() [8/8]

ChimeraTK::INSTANTIATE_TEMPLATE_FOR_CHIMERATK_USER_TYPES ( NumericAddressedBackendMuxedRegisterAccessor )

◆ LogicalNameMapParser::getValueFromXmlSubnode< std::string >() [1/2]

template<>

std::string ChimeraTK::LogicalNameMapParser::getValueFromXmlSubnode< std::string >	(	const xmlpp::Node *	node,
		const std::string &	subnodeName,
		BackendRegisterCatalogue< LNMBackendRegisterInfo > const &	catalogue,
		bool	hasDefault,
		std::string	defaultValue
	)

Definition at line 17 of file LogicalNameMapParser.cc.

◆ LogicalNameMapParser::getValueFromXmlSubnode< std::string >() [2/2]

template<>

std::string ChimeraTK::LogicalNameMapParser::getValueFromXmlSubnode< std::string >	(	const xmlpp::Node *	node,
		const std::string &	subnodeName,
		BackendRegisterCatalogue< LNMBackendRegisterInfo > const &	catalogue,
		bool	hasDefault,
		std::string	defaultValue
	)

Definition at line 17 of file LogicalNameMapParser.cc.

◆ numericToUserType()

template<typename UserType , typename NUMERIC >

UserType ChimeraTK::numericToUserType ( NUMERIC value )

Helper function to convert numeric data into any UserType (even if it is a string etc.).

The conversion is done with proper rounding and range checking (clamping).

Definition at line 164 of file SupportedUserTypes.h.

◆ operator*()

RegisterPath ChimeraTK::operator*	(	const RegisterPath &	leftHandSide,
		int	rightHandSide
	)

Definition at line 47 of file RegisterPath.cc.

◆ operator+() [1/2]

RegisterPath ChimeraTK::operator+	(	const RegisterPath &	leftHandSide,
		const std::string &	rightHandSide
	)

Definition at line 32 of file RegisterPath.cc.

◆ operator+() [2/2]

std::string ChimeraTK::operator+	(	const std::string &	leftHandSide,
		const RegisterPath &	rightHandSide
	)

non-member + operator for RegisterPath: concatenate with normal strings.

Definition at line 26 of file RegisterPath.cc.

◆ operator/() [1/2]

RegisterPath ChimeraTK::operator/	(	const RegisterPath &	leftHandSide,
		const RegisterPath &	rightHandSide
	)

non-member / operator: add a new element to the path.

Must be a non-member operator to allow implicit type conversions also on the leftHandSide.

Definition at line 15 of file RegisterPath.cc.

◆ operator/() [2/2]

RegisterPath ChimeraTK::operator/	(	const RegisterPath &	leftHandSide,
		int	rightHandSide
	)

operators used to build numeric addresses from integers

Definition at line 41 of file RegisterPath.cc.

◆ operator<<() [1/11]

std::ostream & ChimeraTK::operator<<	(	std::ostream &	os,
		__attribute__((unused)) Void &	value
	)

inline

Definition at line 30 of file Void.h.

◆ operator<<() [2/11]

std::ostream & ChimeraTK::operator<<	(	std::ostream &	os,
		const DataValidity &	validity
	)

Definition at line 7 of file TransferElement.cc.

◆ operator<<() [3/11]

std::ostream & ChimeraTK::operator<<	(	std::ostream &	os,
		const DeviceInfoMap &	deviceInfoMap
	)

Definition at line 20 of file DeviceInfoMap.cc.

◆ operator<<() [4/11]

std::ostream & ChimeraTK::operator<<	(	std::ostream &	os,
		const DeviceInfoMap::DeviceInfo &	deviceInfo
	)

Definition at line 51 of file DeviceInfoMap.cc.

◆ operator<<() [5/11]

std::ostream & ChimeraTK::operator<<	(	std::ostream &	os,
		const DeviceInfoMap::ErrorList &	me
	)

Definition at line 129 of file DeviceInfoMap.cc.

◆ operator<<() [6/11]

std::ostream & ChimeraTK::operator<<	(	std::ostream &	os,
		const DeviceInfoMap::ErrorList::ErrorElem &	me
	)

Definition at line 109 of file DeviceInfoMap.cc.

◆ operator<<() [7/11]

std::ostream & ChimeraTK::operator<<	(	std::ostream &	os,
		const DeviceInfoMap::ErrorList::ErrorElem::TYPE &	me
	)

Definition at line 88 of file DeviceInfoMap.cc.

◆ operator<<() [8/11]

std::ostream & ChimeraTK::operator<<	(	std::ostream &	os,
		const RegisterPath &	me
	)

streaming operator

Definition at line 56 of file RegisterPath.cc.

◆ operator<<() [9/11]

std::ostream & ChimeraTK::operator<<	(	std::ostream &	os,
		const TransferElementID &	me
	)

Streaming operator to stream the TransferElementID e.g.

to std::cout

Definition at line 24 of file TransferElementID.cc.

◆ operator<<() [10/11]

std::ostream & ChimeraTK::operator<<	(	std::ostream &	stream,
		const DataDescriptor::FundamentalType &	fundamentalType
	)

Definition at line 195 of file DataDescriptor.cpp.

◆ operator<<() [11/11]

std::ostream & ChimeraTK::operator<<	(	std::ostream &	stream,
		const VersionNumber &	version
	)

Stream operator passing the human readable representation to an ostream.

Definition at line 20 of file VersionNumber.cc.

◆ operator>>() [1/2]

std::istream & ChimeraTK::operator>>	(	std::istream &	is,
		__attribute__((unused)) Void &	value
	)

inline

Definition at line 24 of file Void.h.

◆ operator>>() [2/2]

std::istream & ChimeraTK::operator>>	(	std::istream &	is,
		Boolean &	value
	)

inline

Definition at line 34 of file Boolean.h.

◆ parseRxServerHello()

uint32_t ChimeraTK::parseRxServerHello ( const std::vector< uint32_t > & serverHello )

Definition at line 63 of file RebotBackend.cc.

◆ setDMapFilePath()

void ChimeraTK::setDMapFilePath ( std::string dmapFilePath )

Set the location of the dmap file.

The library will parse this dmap file for the device(alias) lookup.

Parameters

dmapFilePath Relative or absolute path of the dmap file (directory and file name).

Examples: accessor1D.cpp, accessor2D.cpp, accessor2D_multiplexed.cpp, and basic.cpp.

Definition at line 329 of file Utilities.cpp.

◆ stop_rebot_server()

std::atomic< bool > ChimeraTK::stop_rebot_server ( false )

◆ to_string()

std::string ChimeraTK::to_string ( Boolean & value )

inline

Definition at line 60 of file Boolean.h.

◆ userTypeToNumeric()

template<typename NUMERIC , typename UserType >

NUMERIC ChimeraTK::userTypeToNumeric ( UserType value )

Helper function to convert numeric data into any UserType (even if it is a string etc.).

The conversion is done with proper rounding and range checking (clamping).

Definition at line 173 of file SupportedUserTypes.h.

◆ userTypeToUserType()

template<typename UserTypeReturn , typename UserTypeParameter >

UserTypeReturn ChimeraTK::userTypeToUserType ( UserTypeParameter value )

Helper function to convert any UserType data into any other UserType (even if it is a string etc.).

The conversion is done with proper rounding and range checking for numeric types. It will return the closed possible value if the value is out of range.

Definition at line 272 of file SupportedUserTypes.h.

Variable Documentation

◆ DUMMY_INTERRUPT_REGISTER_PREFIX

constexpr auto ChimeraTK::DUMMY_INTERRUPT_REGISTER_PREFIX = "/DUMMY_INTERRUPT_"

constexpr

Definition at line 14 of file DummyBackendBase.cc.

◆ DUMMY_READABLE_SUFFIX

constexpr auto ChimeraTK::DUMMY_READABLE_SUFFIX = "DUMMY_READABLE"

constexpr

Definition at line 13 of file DummyBackendBase.cc.

◆ DUMMY_WRITEABLE_SUFFIX

constexpr auto ChimeraTK::DUMMY_WRITEABLE_SUFFIX = "DUMMY_WRITEABLE"

constexpr

Definition at line 12 of file DummyBackendBase.cc.

◆ globalDecoratorMap

std::map<DecoratorMapKey, boost::shared_ptr<ChimeraTK::TransferElement> > ChimeraTK::globalDecoratorMap

Definition at line 9 of file TypeChangingDecorator.cc.

◆ isBoolean

template<typename T >

constexpr bool ChimeraTK::isBoolean = std::is_same_v<T, bool> || std::is_same_v<T, Boolean>

constexpr

Definition at line 52 of file Boolean.h.

◆ isRawType

template<typename T >

constexpr bool ChimeraTK::isRawType

constexpr

Initial value:

= std::is_same_v<T, uint8_t> || std::is_same_v<T, uint16_t> || std::is_same_v<T, uint32_t> ||

std::is_same_v<T, uint64_t>

Constant which alles to check whether a type is one of the supported ChimeraTK RawTypes.

Definition at line 52 of file SupportedUserTypes.h.

◆ isUserType

template<typename T >

constexpr bool ChimeraTK::isUserType

constexpr

Initial value:

= std::is_same_v<T, int8_t> || std::is_same_v<T, uint8_t> || std::is_same_v<T, int16_t> ||
      std::is_same_v<T, uint16_t> || std::is_same_v<T, int32_t> || std::is_same_v<T, uint32_t> ||
      std::is_same_v<T, int64_t> || std::is_same_v<T, uint64_t> || std::is_same_v<T, float> ||
      std::is_same_v<T, double> || std::is_same_v<T, std::string> || std::is_same_v<T, ChimeraTK::Boolean> ||
      std::is_same_v<T, ChimeraTK::Void>

Constant which alles to check whether a type is one of the supported ChimeraTK UserTypes.

Definition at line 35 of file SupportedUserTypes.h.

◆ MEM_MULTIPLEXED_PREFIX

constexpr auto ChimeraTK::MEM_MULTIPLEXED_PREFIX = "MEM_MULTIPLEXED_"

constexpr

Definition at line 18 of file NumericAddressedBackendMuxedRegisterAccessor.h.

◆ MULTIPLEXED_SEQUENCE_PREFIX

constexpr auto ChimeraTK::MULTIPLEXED_SEQUENCE_PREFIX = "AREA_MULTIPLEXED_SEQUENCE_"

constexpr

Definition at line 15 of file NumericAddressedBackendMuxedRegisterAccessor.h.

◆ SEQUENCE_PREFIX

constexpr auto ChimeraTK::SEQUENCE_PREFIX = "SEQUENCE_"

constexpr

Definition at line 16 of file NumericAddressedBackendMuxedRegisterAccessor.h.

◆ SHARED_MEMORY_N_MAX_MEMBER

const int ChimeraTK::SHARED_MEMORY_N_MAX_MEMBER = 10

Definition at line 32 of file SharedDummyBackend.h.

◆ stop_rebot_server

std::atomic<bool> ChimeraTK::stop_rebot_server

extern

Namespaces

Classes

Concepts

Typedefs

Enumerations

Functions

Variables

Detailed Description

Typedef Documentation

◆ DeviceInfoMapPointer

◆ HiddenRange

◆ RawTypeTuple

◆ SingleTypeUserTypeMap

◆ SingleTypeUserTypeMapNoVoid

◆ userTypeMap

◆ userTypeMapNoVoid

◆ UserTypeTemplateTuple

◆ UserTypeTemplateTupleNoVoid

◆ UserTypeTemplateVariant

◆ UserTypeTemplateVariantNoVoid

◆ UserTypeTuple

◆ UserTypeTupleNoVoid

◆ UserTypeVariant

◆ UserTypeVariantNoVoid

Enumeration Type Documentation

◆ AccessMode

◆ DataValidity

◆ DecoratorType

◆ ImgFormat

◆ ImgOptions

◆ TestCapability

◆ TransferType

Function Documentation

◆ callForRawType()

◆ callForType() [1/2]

◆ callForType() [2/2]

◆ callForTypeNoVoid()

◆ compareHelper()

◆ compareHelper< double >()

◆ compareHelper< float >()

◆ compareHelper< std::string >()

◆ DECLARE_MULTI_TEMPLATE_FOR_CHIMERATK_RAW_TYPES() [1/4]

◆ DECLARE_MULTI_TEMPLATE_FOR_CHIMERATK_RAW_TYPES() [2/4]

◆ DECLARE_MULTI_TEMPLATE_FOR_CHIMERATK_RAW_TYPES() [3/4]

◆ DECLARE_MULTI_TEMPLATE_FOR_CHIMERATK_RAW_TYPES() [4/4]

◆ DECLARE_MULTI_TEMPLATE_FOR_CHIMERATK_USER_TYPES() [1/7]

◆ DECLARE_MULTI_TEMPLATE_FOR_CHIMERATK_USER_TYPES() [2/7]

◆ DECLARE_MULTI_TEMPLATE_FOR_CHIMERATK_USER_TYPES() [3/7]

◆ DECLARE_MULTI_TEMPLATE_FOR_CHIMERATK_USER_TYPES() [4/7]

◆ DECLARE_MULTI_TEMPLATE_FOR_CHIMERATK_USER_TYPES() [5/7]

◆ DECLARE_MULTI_TEMPLATE_FOR_CHIMERATK_USER_TYPES() [6/7]

◆ DECLARE_MULTI_TEMPLATE_FOR_CHIMERATK_USER_TYPES() [7/7]

◆ DECLARE_TEMPLATE_FOR_CHIMERATK_RAW_TYPES()

◆ DECLARE_TEMPLATE_FOR_CHIMERATK_USER_TYPES() [1/8]

◆ DECLARE_TEMPLATE_FOR_CHIMERATK_USER_TYPES() [2/8]

◆ DECLARE_TEMPLATE_FOR_CHIMERATK_USER_TYPES() [3/8]

◆ DECLARE_TEMPLATE_FOR_CHIMERATK_USER_TYPES() [4/8]

◆ DECLARE_TEMPLATE_FOR_CHIMERATK_USER_TYPES() [5/8]

◆ DECLARE_TEMPLATE_FOR_CHIMERATK_USER_TYPES() [6/8]

◆ DECLARE_TEMPLATE_FOR_CHIMERATK_USER_TYPES() [7/8]

◆ DECLARE_TEMPLATE_FOR_CHIMERATK_USER_TYPES() [8/8]

◆ for_each()

◆ getDMapFilePath()

◆ getGlobalDecoratorMap()

◆ getProtocolImplementor()

◆ getProtocolVersion()

◆ getTypeChangingDecorator() [1/2]

◆ getTypeChangingDecorator() [2/2]

◆ INSTANTIATE_MULTI_TEMPLATE_FOR_CHIMERATK_RAW_TYPES() [1/4]

◆ INSTANTIATE_MULTI_TEMPLATE_FOR_CHIMERATK_RAW_TYPES() [2/4]

◆ INSTANTIATE_MULTI_TEMPLATE_FOR_CHIMERATK_RAW_TYPES() [3/4]

◆ INSTANTIATE_MULTI_TEMPLATE_FOR_CHIMERATK_RAW_TYPES() [4/4]

◆ INSTANTIATE_MULTI_TEMPLATE_FOR_CHIMERATK_USER_TYPES() [1/7]

◆ INSTANTIATE_MULTI_TEMPLATE_FOR_CHIMERATK_USER_TYPES() [2/7]

◆ INSTANTIATE_MULTI_TEMPLATE_FOR_CHIMERATK_USER_TYPES() [3/7]

◆ INSTANTIATE_MULTI_TEMPLATE_FOR_CHIMERATK_USER_TYPES() [4/7]

◆ INSTANTIATE_MULTI_TEMPLATE_FOR_CHIMERATK_USER_TYPES() [5/7]

◆ INSTANTIATE_MULTI_TEMPLATE_FOR_CHIMERATK_USER_TYPES() [6/7]

◆ INSTANTIATE_MULTI_TEMPLATE_FOR_CHIMERATK_USER_TYPES() [7/7]

◆ INSTANTIATE_TEMPLATE_FOR_CHIMERATK_RAW_TYPES()