 |
Sen API
Sen Libraries
|
|
Sen API
Sen Libraries
|
| Npybind11 | |
| Ndetail | |
| Ctype_caster< sen::ObjectId > | |
| Nsen | |
| Nstd_util | |
| Ndetail | |
| CMoveOnlyFunctionImpl< ResultType(ArgTypes...) GENERATE_WITH_CV GENERATE_WITH_REF NOEXCEPT_SPECIFIER > | |
| CIsInPlaceType | |
| CIsInPlaceType< std::in_place_type_t< T > > | |
| CMoveOnlyFunctionImpl | |
| CMoveOnlyFunctionBase | |
| CSmallSizeBuffer.__unnamed0__ | |
| CReportPolicyAssertion | |
| CReportPolicyTrace | |
| CReportPolicyLog | |
| CReportPolicyIgnore | |
| CIsInstantiationOf | |
| CIsInstantiationOf< Template, Template< Args... > > | |
| Nutil | |
| CIteratorRange | Basic range abstraction to form a minimal range around two iterators |
| CLockedRangeAdapter | A range adapter to combine a range with lock |
| CSmartPtrIteratorAdapter | Iterator adapter to turn a iterator that iterates over a smart ptr sequence into one that iterates over pointers to the underlying type |
| CDrConfig | Length in meters |
| CLocation | World Location struct |
| CGeodeticWorldLocation | World location in geodetic coordinates |
| COrientation | Orientation struct |
| CVelocity | Velocity struct |
| CAcceleration | Acceleration struct |
| CAngularVelocity | AngularVelocity struct |
| CAngularAcceleration | AngularAcceleration struct |
| CSituation | Situation structure with the following parameters: |
| CGeodeticSituation | GeodeticSituation structure with the following parameters: |
| CDeadReckoner | Enables the user to predict an object’s position and movement at any future time applying dead reckoning. It adheres to the algorithms specified in IEEE 1278_1:2012, Annex E |
| CDeadReckonerBase | Extrapolates the Situation of an entity at a certain time. The extrapolation is smoothed by default unless the user specifies otherwise |
| CDeadReckonerTemplateBase | Base class for the DeadReckoner and SettableDeadReckoner classes |
| CDrThreshold | Threshold configuration structure with the position error threshold (maximum distance between extrapolation and data) and the entity dynamics (speed and changes of direction) |
| CSettableDeadReckoner | Allows the user to get the extrapolated situation of an object and to set the Spatial when the error of the extrapolation exceeds a configurable threshold |
| CMat3 | Handles all mathematical ops involving 3D Matrices |
| CQuat | Quaternion. Represents the orientation of an object in space |
| CHaversineData | Return type for the haversine helper containing the haversine distance and header between the start and end points |
| CVec3 | Handles all mathematical ops involving 3D Vectors |
| Nlang | |
| CCodeLocation | Location of a character in a program |
| CErrorReporter | Utility class for reporting errors in the source code |
| CFomParser | Parses HLA FOM files |
| CStlUnaryExpr | Unary operation |
| CStlBinaryExpr | Binary expression |
| CStlLiteralExpr | Literals |
| CStlGroupingExpr | Groups |
| CStlLogicalExpr | Binary logical operation |
| CStlVariableExpr | A variable |
| CStlBetweenExpr | A BETWEEN expression |
| CStlInExpr | A IN expression |
| CStlExpr | Wrapper for expression values |
| CStlParser | Parses STL types and queries out of a list of tokens |
| CParseError | |
| CTypeSet | A set of types coming from a STL file |
| CResolverContext | The environment where a resolution takes place |
| CTypeSetContext | The set of types used during resolution |
| CTypeSetIterator | |
| CClassAnnotations | |
| CTypeSettings | |
| CStlResolver | Resolves a list of statements into a set of types |
| CStlScanner | Converts a string into a list of tokens |
| CStlImportStatement | |
| CStlPackageStatement | |
| CStlAttribute | |
| CStlTypeNameStatement | |
| CStlStructFieldStatement | |
| CStlStructStatement | |
| CStlEnumeratorStatement | |
| CStlEnumStatement | |
| CStlVariantElement | |
| CStlVariantStatement | |
| CStlQuantityStatement | |
| CStlSequenceStatement | |
| CStlArrayStatement | |
| CStlTypeAliasStatement | |
| CStlOptionalTypeStatement | |
| CStlArgStatement | |
| CStlVarStatement | |
| CStlFunctionStatement | |
| CStlEventStatement | |
| CStlInterfaceStatement | |
| CStlClassStatement | |
| CBusNameStatement | |
| CQueryStatement | |
| CStlToken | |
| CVariantAccessError | Represents a variant that could not be accessed |
| CChunk | A chunk of byte code. It holds code and constants needed by the code. Constants are accessed by index |
| CVM | Virtual machine for executing Sen byte code |
| CCompileError | Compilation failure report |
| CRuntimeError | Runtime error report |
| CFomDocument | |
| CParsedDoc | |
| CFomDocumentSet | |
| Ndetail | |
| CTemplatedBaseTypeDispatcher | |
| CTemplatedBaseTypeDispatcher< T, BaseClassType, true > | |
| Nkernel | Strong type for the unique identifier for a transport timer |
| CBootloader | Configures a kernel for running |
| CComponent | Base class for implementing sen kernel components |
| CComponentMonitoringInfo | Monitoring information about components |
| CKernelMonitoringInfo | Kernel monitoring information |
| CKernelApi | User-facing kernel functions |
| CConfigGetter | Allows for fetching configuration parameters |
| CRegistrationApi | API for objects when registered |
| CPreloadApi | What can be done when preloading a component |
| CLoadApi | What can be done when loading a component |
| CInitApi | What can be done when initializing a component |
| CRunApi | What can be done while a component is running |
| CUnloadApi | What can be done when unloading a component |
| CKernel | Main entry point of a sen microkernel |
| CComponentContext | Holds a component instance and basic info |
| CKernelConfig | Holds the kernel configuration information |
| CComponentPluginToLoad | Information about a component to load from a plugin |
| CComponentToLoad | Information about a component to load |
| CObjectConfig | Information about how to create an object |
| CPipelineToLoad | Information about how to create a pipeline |
| CPackageManager | Utility class for loading types from Sen packages |
| CSourceInfo | Provides information about sources as strings |
| CSessionInfoProvider | |
| CSessionsDiscoverer | |
| CTestKernel | Kernel class only meant for unit testing your packages or components. It starts in virtual time mode |
| CTestComponent | Convenience class for using lambdas instead of inheritance when defining test components |
| CTracer | Interface implemented by tracers. You can use it to trace the behavior of your code. Please note that not all tracers support the functions below |
| CBusId | |
| CParticipantAddr | To identify remote participants |
| CUniqueByteBufferManager | |
| CTransportListener | Interface for the internal Sen element that reacts to transport events |
| CTransportStats | Global transport statistics |
| CTransport | Interface for implementing a Sen inter-process transport solution |
| Ntest | |
| Nruntime | |
| CTestClassImpl | |
| CTesterImpl | |
| CTestWriter | |
| CTestReader | |
| CBufferedTestReader | |
| CTestClassImpl | |
| CTesterImpl | |
| Ndb | |
| CAnnotation | Represents an annotation which can be added to a recording |
| CCreation | Represents the creation of an object |
| CCursor | A cursor that can be used to iterate over the contents of a recording. The cursor holds a payload which can have one of the values given as type arguments |
| CEntry | The current entry |
| CDeletion | Represents the deletion of an object |
| CEvent | Represents the emission of an event by some object |
| CKeyframeIndex | The location of a keyframe in an archive |
| CObjectIndexDef | Describes an object that has been indexed |
| CEnd | Represents the end of the recording. Used in cursors |
| CInput | Allows you to access an existing recording in the file system |
| CKeyframe | Represents the state of the system at a given time. The state of the system is made of the snapshots of all the objects present at the time of the snapshot |
| CObjectInfo | Basic information about an object tracked for recording |
| COutput | Allows the creation of recordings |
| CPropertyChange | Represents the change of a property value |
| CSnapshot | Represents the full state of an object at a point in time |
| CShouldBePassedByValue | Utility to indicate that your class wants to be passed by value in some of the library calls |
| CHasValueType | Return false if T has not an 'using ValueType' or a 'typedef ValueType' |
| CHasValueType< T, std::void_t< typename T::ValueType > > | Return true if T has an 'using ValueType' or a 'typedef ValueType' |
| CHasOperator | Allows compile-time check for the presence of various operators |
| COverloaded | Helper type for std::variant lambda visitors |
| CIsContained | Checks if T is on of the types in TypeList |
| CIsVariantMember | Checks if T is on of the member types of the given VariantType |
| CIsVariantMember< T, std::variant< MemberTypes... > > | Checks if T is on of the member types of the given VariantType |
| CDuration | A time duration |
| CShouldBePassedByValue< Duration > | |
| CGradientNoise | Utility class for generating n-dimensional noise. Mainly useful in tests and examples |
| CGuarded | 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 |
| CTemporaryAccessToken | Access token that enables the user to interact with the protected object while simultaneously holding a lock to ensure access are correctly synchronized |
| CQuantity | CRTP class that wraps T to ensure it's value stays within a certain range |
| CShouldBePassedByValue< Quantity< T, D > > | |
| CResult | 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 |
| CResult< void, E > | Specialization for Results that just hold error data |
| CResult< void, std::monostate > | Specialization for Results that just hold success indication |
| CScopeGuard | Runs the function object F on destruction |
| CSourceLocation | Represents a location in source code |
| CSpan | Contiguous view of elements of type T. Inspired by http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p0122r7.pdf |
| CStaticVectorBase | Base class for stack-based, exception-safe and resizable vector with fixed-capacity |
| CStaticVector | Stack-based, exception-free and resizable vector with fixed-capacity |
| CStrongTypeBase | Wraps T to make it a strong type |
| CShouldBePassedByValue< StrongTypeBase< T > > | |
| CStrongType | CRTP class that wraps T to make it a strong type |
| CShouldBePassedByValue< StrongType< T, D > > | |
| CTimeStamp | A point in time |
| CShouldBePassedByValue< TimeStamp > | |
| CUuid | Universal Unique Identifier |
| CUuidRandomGenerator | |
| CWriter | Interface for writing to a device |
| CBufferWriter | A writer that owns a fixed size buffer |
| CResizableBufferWriter | A writer that owns a buffer that gets resized on demand |
| CLittleEndian | Tag type for referring to little endian encoding |
| CBigEndian | Tag type for referring to big endian encoding |
| CInputStreamBase | Base class for input streams |
| CInputStreamTemplate | Binary input stream. Deserializes values. In general, I/O operations throw on failure |
| COutputStreamTemplate | Binary output stream. Serializes values. In general, I/O operations throw on failure |
| CAliasSpec | Data of an alias type |
| CAliasType | Represents an aliased type |
| CBasicTraits | Helper class that traits classes can inherit from when the type at hand is basic (native or trivial) |
| CArg | Holds the information for an argument in the callable |
| CCallableSpec | Data of a callable |
| CCallable | Represents something that can be called |
| CCustomType | Represents a user-defined type |
| CEnumTraitsBase | Base class for enum traits |
| CEnumerator | Holds the information for an enumerator |
| CEnumSpec | Data of an enum type |
| CEnumType | Represents an enumeration |
| CEventSpec | Data of an event |
| CEvent | Represents an event |
| CNonPropertyRelated | Indicates that the method is not directly related to any property |
| CPropertyGetter | Indicates that the method represents a getter of a property |
| CPropertySetter | Indicates that the method represents a setter of a property |
| CMethodSpec | Data of a method |
| CMethod | Represents a method |
| CNativeType | Represents a native (built-in) type that can be created on the stack or sent in a message |
| CNumericType | Represents a numeric native type |
| CIntegralType | Represents an integral numeric type |
| CRealType | Represents a floating point numeric type |
| CVoidType | Used for indicating that no result value is provided |
| COptionalTraitsBase | Base class for enum traits |
| COptionalSpec | Data of an optional type |
| COptionalType | Represents an optional type |
| CPropertySpec | Data of a property |
| CProperty | Represents a property |
| CQuantityTraitsBase | Base class for quantity traits |
| CQuantitySpec | Data of a quantity type |
| CQuantityType | Represents a quantity |
| CSequenceTraitsBase | Base class for sequence traits |
| CArrayTraitsBase | Base class for sequence traits |
| CSequenceSpec | Data of a sequence type |
| CSequenceType | Represents a sequence type |
| CStructTraitsBase | Base class for struct traits |
| CStructField | Holds the information for a field in the struct |
| CStructSpec | Data of struct type |
| CStructType | Represents a structure type |
| CDurationType | Represents a sen::Duration (a time duration) |
| CTimestampType | Represents a sen::TimeStamp (a point in time) |
| CMetaTypeTrait< Duration > | |
| CQuantityTraits< Duration > | |
| CVariantTraits< Duration > | |
| CSerializationTraits< Duration > | |
| CMetaTypeTrait< TimeStamp > | |
| CVariantTraits< TimeStamp > | |
| CSerializationTraits< TimeStamp > | |
| CQuantityTraits< TimeStamp > | |
| CMemberHash | The hash of a member |
| CShouldBePassedByValue< MemberHash > | |
| CType | 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 |
| CTypeHandle | Handle around a type that, by default, ensures the lifetime of the underlying type |
| CTypeMatchIssue | Information about a type matching issue |
| CTypesMatch | Types are compatible |
| CTypesDontMatch | Types do not match |
| CCustomTypeRegistry | A registry of custom types |
| CMetaTypeTrait | |
| CVariantTraits | |
| CSerializationTraits | |
| CStringConversionTraits | |
| CQuantityTraits | |
| CSenClassRelation | Compile-time information about a generated (or built-in) type |
| CSenClassRelation< const T & > | |
| CSenClassRelation< T & > | |
| CSenClassRelation< const T > | |
| Cremove_cvref | |
| CFullTypeVisitor | 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) |
| CTypeVisitor | All the apply virtual methods are overriden to empty methods. Use TypeVisitor if you only need to handle some of the types |
| CUnitSpec | Data about a given unit definition. Given f, x, y: |
| CUnit | Represents the definition of a unit |
| CEnsureTag | |
| CUnitRegistry | A registry of units |
| CVar | Can hold any supported value type. Wraps std::variant to allow recursion and implements some helpers |
| CIsVariantMember< T, Var > | |
| CVariantTraitsBaseBase | |
| CVariantTraitsBase | Base class for variant traits |
| CVariantField | Holds the information for a field in the variant |
| CVariantSpec | Data of a variant type |
| CVariantType | Represents a variant type |
| CEventInfo | Information about an event emission |
| CMethodCallInfo | Information about a method call |
| CCallback | 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 |
| CConnectionGuard | Unregisters a callback on destruction, unless keep() is called |
| CShouldBePassedByValue< InterestId > | Unique identifier that represents the interest |
| CBusSpec | The name/address of a bus |
| CVarInfo | Information about a variable used in the query |
| CInterest | Declares interest on objects that satisfy a set of conditions |
| CNativeObject | An object instantiated in this process. This is the base class for all user-implemented objects |
| CShouldBePassedByValue< ConnId > | |
| CShouldBePassedByValue< ObjectId > | Unique identifier for any object instance |
| CObject | A sen object |
| CObjectFilterBase | Base class for object filters |
| CObjectFilter | Allows the discovery of objects based on different criteria |
| CObjectSet | |
| CObjectList | A list of objects that is managed by some source based on user-expressed interests |
| CIterators | |
| CMuxedProviderListener | An extended ObjectProviderListener that works together with ObjectMux and notifies when objects provided by different ObjectMux sources are added/removed multiple times |
| CObjectMux | 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 |
| CShouldBePassedByValue< ObjectOwnerId > | Identifies the owner of an object |
| CObjectInstanceDiscovery | Holds information about an object that has been discovered |
| CRemoteObjectDiscovery | Holds information about a remote object that has been discovered |
| CObjectRemoval | Holds information about an object that has been removed |
| CObjectProviderListener | Allows reacting to objects being added or removed to an object provider. It automatically unregisters itself from all the providers upon destruction |
| CObjectProvider | Base class for an entity that is able to produce objects |
| CObjectRef | 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 |
| CObjectSource | Allows adding and receiving objects |
| CSubscription | A list of objects and a reference to its source (to keep it alive) |
| CShouldBePassedByValue< kernel::ProcessId > | |
| CShouldBePassedByValue< kernel::BusId > | |
| Nstd | STL namespace |
| Chash< sen::Uuid > | |
| Chash< sen::TypeHandle< Type > > | |
| Chash<::sen::MemberHash > | |
| Chash< sen::kernel::ParticipantAddr > | |
| CKernelFixture | Wrapper class used in the integration tests that facilitates the interaction with the Sen kernel test API, managing the allocation and deallocation of common resources |
1.16.1