 |
Sen API
Sen Libraries
|
| Npybind11 | |
| Ndetail | |
| Ctype_caster< sen::ObjectId > | |
| Nsen | |
| Ndb | |
| Ntest | |
| CTestObjImpl | |
| CSingleClassSetup | |
| COtherObjImpl | |
| CDualClassSetup | |
| 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 |
| CEnd | Represents the end of the recording. Used in cursors |
| CEvent | Represents the emission of an event by some object |
| 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 |
| CKeyframeIndex | The location of a keyframe in an archive |
| CObjectIndexDef | Describes an object that has been indexed |
| CObjectInfo | Basic information about an object tracked for recording |
| COutput | Allows the creation of recordings |
| CPropertyChange | Represents the change of a property value |
| CRecordingMergeDuplicateObject | Conflict data passed to the duplicate object resolver |
| CRecordingMergeInput | Recording input used by the merger |
| CRecordingMergeKeepSelectedObject | Object that we need to keep and discards the other in a duplicate conflict |
| CRecordingMergeObject | Information about an object found while merging recordings |
| CRecordingMergeObjectRename | New name selected for one object in a duplicate object conflict |
| CRecordingMergeRenameObjects | Resolution that assigns new names to objects in a duplicate conflict |
| CRecordingMergeSettings | Settings used to merge several recording archives into one archive |
| CSnapshot | Represents the full state of an object at a point in time |
| Ndetail | |
| CTemplatedBaseTypeDispatcher | |
| CTemplatedBaseTypeDispatcher< T, BaseClassType, true > | |
| Ngen | |
| Ndetail | |
| CCppTemplateSet | A template for each supported user type |
| CHtmlApp | The application, baked into the binary. Unpacked once per generator |
| CJsonTemplateSet | A template for each supported user type |
| CMkDocsTemplates | A template for each supported user type |
| CNode | |
| CPlantUmlTemplateSet | A template for each supported user type |
| CPythonTemplateSet | A template for each supported user type |
| CTemplateVisitorResult | |
| CTypeGroups | |
| CTypeScriptTemplateSet | One template per supported user type, plus the file shell |
| CTypeStorage | |
| Ntest | |
| CResolvedModel | A model resolved from STL source. Owns the statements as well as the context, because the context refers to them |
| CComponentOptions | Options for JsonGenerator::generateComponent |
| CCppExportsOptions | Options for CppGenerator::generateExports |
| CCppGenerator | Renders C++ sources out of Sen type sets. Stateful (caches the loaded inja templates), so prefer reusing one instance across calls when possible |
| CCppOptions | Options controlling how CppGenerator::generate renders one type set |
| CHtmlGenerator | Renders a browsable reference for a sen data model as a self-contained web page. The output needs no server, no network and no host site: it opens from a file path and carries its own navigation and search |
| CJsonGenerator | Renders JSON-Schema descriptions of sen type sets. Stateful (caches the loaded inja templates), so prefer reusing one instance across calls when possible |
| CMkDocsGenerator | Renders an MkDocs-compatible markdown document out of sen type sets. Stateful (caches the loaded inja templates), so prefer reusing one instance across calls when possible |
| CPackageOptions | Options for JsonGenerator::generatePackage |
| CPlantUMLGenerator | Renders PlantUML class diagrams out of sen type sets. Stateful (caches the loaded inja templates), so prefer reusing one instance across calls when possible |
| CPythonGenerator | Renders Python dataclasses out of sen type sets. Stateful (caches the loaded inja templates), so prefer reusing one instance across calls when possible |
| CTypeScriptGenerator | Renders TypeScript modules out of sen type sets. Stateful (caches the loaded inja templates), so prefer reusing one instance across calls when possible |
| CTypstGenerator | Renders a Sen data model as a Typst document, in the shape of an interface control document. Writes Typst source; producing a PDF is a separate step, as with PlantUML |
| CTypstOptions | What the document contains and how it is put together. Every field defaults to the whole model and the standard sections, so a default-constructed value produces a complete document and a caller who wants that need know none of this |
| Nkernel | Strong type for the unique identifier for a transport timer |
| CBootloader | Configures a kernel for running |
| CBusId | |
| CComponent | Base class for implementing sen kernel components |
| CComponentContext | Holds a component instance and basic info |
| CComponentMonitoringInfo | Runtime monitoring information about a single component runner |
| CConfigGetter | Allows for fetching configuration parameters |
| CInitApi | What can be done when initializing a component |
| CKernel | Main entry point of a sen microkernel |
| CKernelApi | User-facing kernel functions |
| 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 |
| CKernelMonitoringInfo | Kernel runtime monitoring information |
| CLoadApi | What can be done when loading a component |
| CPackageManager | Utility class for loading types from Sen packages |
| CParticipantAddr | To identify remote participants |
| CPreloadApi | What can be done when preloading a component |
| CRegistrationApi | API for objects when registered |
| CRunApi | What can be done while a component is running |
| CSessionInfoProvider | |
| CSessionsDiscoverer | |
| CSourceInfo | Provides information about sources as strings |
| CTestComponent | Convenience class for using lambdas instead of inheritance when defining test components |
| CTestKernel | Kernel class only meant for unit testing your packages or components. It starts in virtual time mode |
| 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 |
| CTransport | Interface for implementing a Sen inter-process transport solution |
| CTransportListener | Interface for the internal Sen element that reacts to transport events |
| CTransportStats | Global transport statistics |
| CUniqueByteBufferManager | |
| CUnloadApi | What can be done when unloading a component |
| Nlang | |
| Nfom | |
| CDocument | One document that was read, and the nodes in it that declare something |
| CMappingDocument | A mapping file and where it was read from, so a refusal can name the file that asked for something the FOM does not have |
| CDocumentTypeSet | A type set and the path it was built from. One caller resolves a single FOM file by path |
| CDeclaration | One declaring node and the document it came from, so a refusal can name the file |
| CDeclarations | Everything that declares one type. The complete definition owns the type and decides its package; every other declaration adds its members to it. HLA 4 calls this the union over the collective set of modules, and uses the same two words for the two roles |
| CFomDocuments | Reads every document, indexes what each one declares, then builds the types. A type is built on first reference, from every declaration of it rather than only the first, which is what lets a file beside the FOM add members to it |
| CBusNameStatement | |
| CChunk | A chunk of byte code. It holds code and constants needed by the code. Constants are accessed by index |
| CClassAnnotations | |
| CCodeLocation | Location of a character in a program |
| CErrorReporter | Utility class for reporting errors in the source code |
| CFomParser | Parses HLA FOM files |
| CQueryStatement | |
| CResolverContext | The environment where a resolution takes place |
| CStlArgStatement | |
| CStlArrayStatement | |
| CStlAttribute | |
| CStlBetweenExpr | A BETWEEN expression |
| CStlBinaryExpr | Binary expression |
| CStlClassStatement | |
| CStlEnumeratorStatement | |
| CStlEnumStatement | |
| CStlEventStatement | |
| CStlExpr | Wrapper for expression values |
| CStlFunctionStatement | |
| CStlGroupingExpr | Groups |
| CStlImportStatement | |
| CStlInExpr | A IN expression |
| CStlInterfaceStatement | |
| CStlLiteralExpr | Literals |
| CStlLogicalExpr | Binary logical operation |
| CStlOptionalTypeStatement | |
| CStlPackageStatement | |
| CStlParser | Parses STL types and queries out of a list of tokens |
| CParseError | |
| CStlQuantityStatement | |
| CStlResolver | Resolves a list of statements into a set of types |
| CStlScanner | Converts a string into a list of tokens |
| CStlSequenceStatement | |
| CStlStructFieldStatement | |
| CStlStructStatement | |
| CStlToken | |
| CStlTypeAliasStatement | |
| CStlTypeNameStatement | |
| CStlUnaryExpr | Unary operation |
| CStlVariableExpr | A variable |
| CStlVariantElement | |
| CStlVariantStatement | |
| CStlVarStatement | |
| CTypeSet | A set of types coming from a STL file |
| CTypeSetContext | The set of types used during resolution |
| CTypeSetIterator | |
| CTypeSettings | |
| CVariantAccessError | Represents a variant that could not be accessed |
| CVM | Virtual machine for executing Sen byte code |
| CCompileError | Compilation failure report |
| CRuntimeError | Runtime error report |
| Nstd_util | |
| Ndetail | |
| CIsInPlaceType | |
| CIsInPlaceType< std::in_place_type_t< T > > | |
| CMoveOnlyFunctionBase | |
| CSmallSizeBuffer.__unnamed0__ | |
| CMoveOnlyFunctionImpl | |
| CMoveOnlyFunctionImpl< ResultType(ArgTypes...) GENERATE_WITH_CV GENERATE_WITH_REF NOEXCEPT_SPECIFIER > | |
| CIsInstantiationOf | |
| CIsInstantiationOf< Template, Template< Args... > > | |
| CReportPolicyAssertion | |
| CReportPolicyIgnore | |
| CReportPolicyLog | |
| CReportPolicyTrace | |
| Ntest | |
| Ncrash_report | |
| CCrashMakerImpl | |
| Nruntime | |
| CTestClassImpl | |
| CTesterImpl | |
| Ntype_clash | |
| CApp1ClassImpl | |
| CApp2ClassImpl | |
| CApp3ClassImpl | |
| CApp4ClassImpl | |
| CClashTypeImpl | |
| CBufferedTestReader | |
| CListenerImpl | Reacts to action performs by the publisher and compares the result to the test expectation. These reactions normally involve creating subscriptions for objects, installing callbacks for property changes, etc |
| CProcessTerminatorImpl | Terminates each process where it is included (via the kernel API) when it detects that all StatefulObjects in the process are 'finished' |
| CPublisherImpl | Performs actions in the integration test. These normally include creating, erasing and modifying objects |
| CStateFulObjectImpl | Holds a connection state |
| CTestClassImpl | |
| CTesterImpl | |
| CTestReader | |
| CTestWriter | |
| Nutil | |
| Nimpl | |
| CHasCommitTime | True when T can report when its data was committed. Generated RPR types can, through asObject(); a hand-written stand-in usually cannot, so it is detected rather than required |
| CHasCommitTime< T, std::void_t< decltype(std::declval< const T & >().asObject().getLastCommitTime())> > | |
| CAcceleration | Acceleration struct |
| CAngularAcceleration | AngularAcceleration struct |
| CAngularVelocity | AngularVelocity struct |
| 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 |
| CDrConfig | Dead Reckoning configuration |
| CDrThreshold | How far the extrapolation may drift from the data before the Spatial is written: a distance per axis and an angle between orientations, both compared in ECEF. The reference system selects which algorithm family the written Spatial is tagged with, not the frame of the comparison |
| CGeodeticSituation | GeodeticSituation structure with the following parameters: |
| CGeodeticWorldLocation | World location in geodetic coordinates |
| CHaversineData | Return type for the haversine helper containing the haversine distance and header between the start and end points |
| CIteratorRange | Basic range abstraction to form a minimal range around two iterators |
| CLocation | World Location struct |
| CLockedRangeAdapter | A range adapter to combine a range with lock |
| CMat3 | Handles all mathematical ops involving 3D Matrices |
| COrientation | Orientation struct |
| CQuat | Quaternion. Represents the orientation of an object in space |
| 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 |
| CSituation | Situation structure with the following parameters: |
| CSmartPtrIteratorAdapter | Iterator adapter to turn a iterator that iterates over a smart ptr sequence into one that iterates over pointers to the underlying type |
| CVec3 | Handles all mathematical ops involving 3D Vectors |
| CVelocity | Velocity struct |
| CAliasSpec | Data of an alias type |
| CAliasType | Represents an aliased type |
| CArg | Holds the information for an argument in the callable |
| CArrayTraitsBase | Base class for sequence traits |
| CBasicTraits | Helper class that traits classes can inherit from when the type at hand is basic (native or trivial) |
| CBigEndian | Tag type for referring to big endian encoding |
| CBufferWriter | A writer that owns a fixed size buffer |
| CBusSpec | The name/address of a bus |
| CCallable | Represents something that can be called |
| CCallableSpec | Data of a callable |
| 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 |
| CCustomType | Represents a user-defined type |
| CCustomTypeRegistry | A registry of custom types |
| CDuration | A time duration |
| CDurationType | Represents a sen::Duration (a time duration) |
| CEnumerator | Holds the information for an enumerator |
| CEnumSpec | Data of an enum type |
| CEnumTraitsBase | Base class for enum traits |
| CEnumType | Represents an enumeration |
| CEvent | Represents an event |
| CEventInfo | Information about an event emission |
| CEventSpec | Data of an event |
| 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) |
| 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 |
| CHasOperator | Allows compile-time check for the presence of various operators |
| 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' |
| CInputStreamBase | Base class for input streams |
| CInputStreamTemplate | Binary input stream. Deserializes values. In general, I/O operations throw on failure |
| CIntegralType | Represents an integral numeric type |
| CInterest | Declares interest on objects that satisfy a set of conditions |
| 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 |
| CIsVariantMember< T, Var > | |
| CLittleEndian | Tag type for referring to little endian encoding |
| CMemberHash | The hash of a member |
| CMetaTypeTrait | |
| CMetaTypeTrait< Duration > | |
| CMetaTypeTrait< TimeStamp > | |
| CMethod | Represents a method |
| CMethodCallInfo | Information about a method call |
| CMethodSpec | Data of a method |
| CMuxedProviderListener | An extended ObjectProviderListener that works together with ObjectMux and notifies when objects provided by different ObjectMux sources are added/removed multiple times |
| CNativeObject | An object instantiated in this process. This is the base class for all user-implemented objects |
| CNativeType | Represents a native (built-in) type that can be created on the stack or sent in a message |
| CNonPropertyRelated | Indicates that the method is not directly related to any property |
| CNumericType | Represents a numeric native type |
| CObject | A sen object |
| CObjectFilter | Allows the discovery of objects based on different criteria |
| CObjectSet | |
| CObjectFilterBase | Base class for object filters |
| CObjectInstanceDiscovery | Holds information about an object that has been discovered |
| CObjectList | A list of objects that is managed by some source based on user-expressed interests |
| CIterators | |
| 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 |
| CObjectProvider | Base class for an entity that is able to produce objects |
| CObjectProviderListener | Allows reacting to objects being added or removed to an object provider. It automatically unregisters itself from all the providers upon destruction |
| 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 |
| CObjectRemoval | Holds information about an object that has been removed |
| CObjectSource | Allows adding and receiving objects |
| COptionalSpec | Data of an optional type |
| COptionalTraitsBase | Base class for enum traits |
| COptionalType | Represents an optional type |
| COutputStreamTemplate | Binary output stream. Serializes values. In general, I/O operations throw on failure |
| COverloaded | Helper type for std::variant lambda visitors |
| CProperty | Represents a property |
| CPropertyGetter | Indicates that the method represents a getter of a property |
| CPropertySetter | Indicates that the method represents a setter of a property |
| CPropertySpec | Data of a property |
| CQuantity | CRTP class that wraps T to ensure it's value stays within a certain range |
| CQuantitySpec | Data of a quantity type |
| CQuantityTraits | |
| CQuantityTraits< Duration > | |
| CQuantityTraits< TimeStamp > | |
| CQuantityTraitsBase | Base class for quantity traits |
| CQuantityType | Represents a quantity |
| CRealType | Represents a floating point numeric type |
| CRemoteObjectDiscovery | Holds information about a remote object that has been discovered |
| Cremove_cvref | |
| CResizableBufferWriter | A writer that owns a buffer that gets resized on demand |
| 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 |
| CSenClassRelation | Compile-time information about a generated (or built-in) type |
| CSenClassRelation< const T & > | |
| CSenClassRelation< const T > | |
| CSenClassRelation< T & > | |
| CSequenceSpec | Data of a sequence type |
| CSequenceTraitsBase | Base class for sequence traits |
| CSequenceType | Represents a sequence type |
| CSerializationTraits | |
| CSerializationTraits< Duration > | |
| CSerializationTraits< TimeStamp > | |
| CShouldBePassedByValue | Utility to indicate that your class wants to be passed by value in some of the library calls |
| CShouldBePassedByValue< ConnId > | |
| CShouldBePassedByValue< Duration > | |
| CShouldBePassedByValue< InterestId > | Unique identifier that represents the interest |
| CShouldBePassedByValue< kernel::BusId > | |
| CShouldBePassedByValue< kernel::ProcessId > | |
| CShouldBePassedByValue< MemberHash > | |
| CShouldBePassedByValue< ObjectId > | Unique identifier for any object instance |
| CShouldBePassedByValue< ObjectOwnerId > | Identifies the owner of an object |
| CShouldBePassedByValue< Quantity< T, D > > | |
| CShouldBePassedByValue< StrongType< T, D > > | |
| CShouldBePassedByValue< StrongTypeBase< T > > | |
| CShouldBePassedByValue< TimeStamp > | |
| 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 |
| CStaticVector | Stack-based, exception-free and resizable vector with fixed-capacity |
| CStaticVectorBase | Base class for stack-based, exception-safe and resizable vector with fixed-capacity |
| CStringConversionTraits | |
| CStrongType | CRTP class that wraps T to make it a strong type |
| CStrongTypeBase | Wraps T to make it a strong type |
| CStructField | Holds the information for a field in the struct |
| CStructSpec | Data of struct type |
| CStructTraitsBase | Base class for struct traits |
| CStructType | Represents a structure type |
| CSubscription | A list of objects and a reference to its source (to keep it alive) |
| CTimeStamp | A point in time |
| CTimestampType | Represents a sen::TimeStamp (a point in time) |
| 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 |
| CTypesDontMatch | Types do not match |
| CTypesMatch | Types are compatible |
| CTypeVisitor | All the apply virtual methods are overriden to empty methods. Use TypeVisitor if you only need to handle some of the types |
| CUnit | Represents the definition of a unit |
| CEnsureTag | |
| CUnitRegistry | A registry of units |
| CUnitSpec | Data about a given unit definition. Given f, x, y: |
| CUuid | Universal Unique Identifier |
| CUuidRandomGenerator | |
| CVar | Can hold any supported value type. Wraps std::variant to allow recursion and implements some helpers |
| CVariantField | Holds the information for a field in the variant |
| CVariantSpec | Data of a variant type |
| CVariantTraits | |
| CVariantTraits< Duration > | |
| CVariantTraits< TimeStamp > | |
| CVariantTraitsBase | Base class for variant traits |
| CVariantTraitsBaseBase | |
| CVariantType | Represents a variant type |
| CVarInfo | Information about a variable used in the query |
| CVoidType | Used for indicating that no result value is provided |
| CWriter | Interface for writing to a device |
| Nstd | STL namespace |
| Chash< sen::kernel::ParticipantAddr > | |
| Chash< sen::TypeHandle< Type > > | |
| Chash< sen::Uuid > | |
| Chash<::sen::MemberHash > | |
| CAMkdocsGenerator | |
| CAPlantUMLGenerator | |
| 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.17.0