Root / Assembly / ARCCore / Class



_DescriptionAll classes with some AgoRapide specific attributes found in assembly ARCCore.
ActualConnectionThe actual connection, its internal state, queue for sending and so on.

_Member, AssemblyName, BaseTypes, ClassType, CorrespondingEnumType, Description, Interfaces, LongDescription
BaseAttributeInstances of this class are used as source of documentation and data for the API.
Inherits -Attribute- but does also implement IP.

Note how the information NORMALLY originates from within the C# code but as the class inherit IP, it is also possible to distribute the information over the property-stream.

Some inheriting members in ARCCore are:
BasePKAttribute (which again is inherited by PKTypeAttribute and PKLogAttribute)

_Member, AssemblyName, BaseTypes, ClassType, CorrespondingEnumType, Description, Interfaces
BaseAttribute+IncorrectAttributeTypeUsedExceptionHelps to clean up any confusion about which BaseAttribute to use in a given concept.

_Member, AssemblyName, BaseTypes, ClassType, Description, Interfaces
BasePKAttributeTODO: Rename into PKBaseAttribute?.

The class containing the actual attributes used for TaggingOfPropertyKeys.
Instances of this class are accessed through PK.

Some sub-classes included in ARCCore are PKTypeAttribute and PKLogAttribute.

Other ARComponents define their own sub-classes like:
ARCSec: -PKSecAttribute-,

You are also encouraged to create your own instances in your ApplicationSpecificCode for special needs.
TODO: One idea is a TTL (Time-to-live) tag for a property when that property constitues a command to do something
TODO: for instance turning on a switch in a IoT system (in case of communications failure somewhere in the system, queuing a series
TODO: of turn-on, turn-off, turn-on attempts would have little meaning.

NOTE / TODO: Having this class inherit EnumMemberAttribute makes for a complicated inheritance hierarchy. It might therefore be a good idea to just duplicate the function of EnumMemberAttribute into this class and letting it inherit BaseAttribute directly.

See also analogue IPAttribute which describes classes (describes at class levels).

_Member, AssemblyName, BaseTypes, ClassType, Description, Interfaces
CardinalityExtensions_Member, AssemblyName, ClassType
ClassAttributeDescribes a class.

Individual class members are described by ClassMemberAttribute.

_Member, AssemblyName, BaseTypes, ClassType, CorrespondingEnumType, Description, Interfaces
ClassMemberAttributeDescribes a member of a class (a method).

The class itself is described by ClassAttribute.

_Member, AssemblyName, BaseTypes, ClassType, CorrespondingEnumType, Description, Interfaces
ClientUpdatePositionDescribes from WHERE (from WHEN) in the historic PropertyStream new data is to be returned.
(or actually, it describes up to which point in time client already has updated data).

Communicated between client and server as follows:

1) At initialization of ActualConnection:
Sent by client to server in order to inform the server about the client's update status.

2) For every new PropertyStreamLine sent from server to client:
Sent by server to client. Done by prepending to the PropertyStreamLine being sent, with '::' (double colon) as a separator.
Explains from where in the PropertyStream this line originated.
The server also keeps track of the last value sent to the client as long as the ActualConnection is active.

Used in connection with Subscription which describes WHAT data is required from the PropertyStream.
TODO: Clarify difference between ClientUpdatePosition and FromTime / ToTime.

TODO: Build revision number into this? (DataRetention or keep in filename?

TODO: Ensure that the format being used suits the encoding mechanism well (see EncodeValuePartStringToPropertyStreamFormat) (no special encoding should be necessary as want a human readable format also after encoding)

Describes status of a client's up-to-date level.
Note that client in this case not only means Client but any ARNodeType.
r Examples:

1) 'ClientDatastoreIsEmpty' (see ClientDatastoreIsEmpty).

2) 'OnlyNewDataIsRequested' (see OnlyNewDataIsRequested).

3) 'GoBack|1000' (see IsGoBack) means start from 1000 elements back.

4) 'StorageFile0042|42042': The common scenario. Last update was index 42042 in 'StorageFile0042', next update should be at least 42043 (or index 0 in next file)

An 'IsEndOfStream' marker may be added, like this:
'StorageFile0068|42042042|IsEndOfStream' (see IsAtEndOfStream).

_Member, AssemblyName, ClassType, Description, Interfaces, LongDescription
ConnectionInstructionThe instruction about what connections to make (host, portnr, data transfer direction and so on).
Only relevant for -Outgoing-.

_Member, AssemblyName, BaseTypes, ClassType, CorrespondingEnumType, Description, Interfaces
EnumAttributeDescribes an enum.

Enum members (the individual values) are described by EnumMemberAttribute.

_Member, AssemblyName, BaseTypes, ClassType, CorrespondingEnumType, Description, Interfaces
EnumMemberAttributeDescribes an enum's value.
The enum in itself is described by EnumAttribute.
TODO: Consider renaming class into EnumMemberAttribute, and correspondingly use term 'Member' also for enums, instead of 'Value' in AgoRapide.

Note how enum members / enum values of type PropertyKeyEnum should be described by sub-class BasePKAttribute, not this clas.

_Member, AssemblyName, BaseTypes, ClassType, CorrespondingEnumType, Description, Interfaces
ExtensionsContains a few general nice to have extensions methods.

TODO: If this class accumulates too many methods, consider splitting it into multiple classes in a separate folder.
TODO: For instance a TypeExtensions class and DictionaryExtensions class would be natural.
TODO: (together with maybe a StringExtensionClass)

_Member, AssemblyName, ClassType, Description, LongDescription
ICreatedDummy interface signifying that implementing class has the ability to store metadata Created

TryStore will always store -CurrentTimestamp- as Created when it created classes implementing this interface.

_Member, AssemblyName, ClassType, Description
IIKII_Member, AssemblyName, ClassType, Interfaces
IKIK = Interface Key / Index key.
The key is what describes the different elements in a PropertyStreamLine line.
One specific implementation of this interface, PK (Property Key), describes the actual properties related to an entity.

Example, for a PropertyStreamLine like:
'dt/Customer/42/PhoneNumber = 90534333'

'dt' would correspond to dt (data). Parsed as IKString
(if the data storage is implicitly storing only data then this prefix will often have been removed before parsing the rest of the keys keys).

'Customer' would be a IKType, that is a key pointing to a collection of all objects of type 'Customer'.
(in RDBMS-terms pointing to a table called Customers)

'42' would be a IKLong (IKString if it had not been an integer), that is, a general identifier for a specific entity.
(in RDBMS-terms a primary key)

'PhoneNumber' would be a PK, describing this specific field, and how the value '90534333' should be validated and parsed.
(in RDBMS-terms the Field in the schema for the Table)

Instances implementing this interface is suitable for use as key in hierarchical object stores like PRich.

See TryParse for details about about how the different sub-classes of IK are utilizied for a given PropertyStreamLine.

_Member, AssemblyName, ClassType, Description, Interfaces, LongDescription
IKIPContainer class for key (IK), and value (IP).

TODO: Move to separate file

_Member, AssemblyName, ClassType, Description
IKLongA more memory efficient alternative to IKString.

See IKString for documentation.

_Member, AssemblyName, ClassType, Description, Interfaces, LongDescription
IKStringIndex key for any general id, like primary-key or sequence-number or similar.
(in RDBMS-terms a primary key)

Note that if the actual id is an integer, then IKLong will be used instead of IKString.

The actual id is not expected to be unique throughout the database, but rather unique within a context, for example the value 42 could be unique within the context of Customer.

A single instance of this class can contain multiple PropertyStream-'levels', like for instance '[insert/example/here]'. This is pragmatic approach useful especially in contexts where there is no point in building up multiple IK instances for something that is going to be immediately put into the property stream anyway.
TODO: Give som actual examples of what just mentioned.

This class is immutable.

_Member, AssemblyName, ClassType, Description, Interfaces
IKTypeIndex key used when storing a collection of a given type, like 'Customer'.

The key will normally point to a collection of all objects of that type.
(in RDBMS-terms pointing to a table like Customers)

This class is immutable.

_Member, AssemblyName, ClassType, Description, Interfaces
InvalidTypeException_Member, AssemblyName, BaseTypes, ClassType, Interfaces
IPIP = IProperty.

Common central mechanism for implementing PropertyAccess.

'Everything' in your application, especially entity objects (like 'Customer', 'Order' and so on) should implement this interface.

You should also let internal parts of your application implement this interface. This will make logging and debugging much easier for instance (see ExposingApplicationState).

Some of the implementing classes are:
PRich Fully flexible storage. Can store anything. Typical inherited for entity representations like 'Customer' or 'Order'.
PConcurrent A (somewhat) thread-safe alternative to PRich which also supports log.
PValue<T> Single value storage.

NOTE: Some ideas for new classes implementing this interface could be:
1) PRichImmutable, a quasi-immutable class for which you could (after initialization) set a flag stopping further updates to the class.

(The difference between ITypeDescriber and IP is that the former must be stored 'inside' an IP.
In RDBMS-terms a ITypeDescriber is the Field stored within a IP which is the Post.)

The more classes you have implementing this interface, the more classes you have that can participiate in the AgoRapide world with flexible concepts like PropertyStream, TaggingOfPropertyKeys, PropertyAccess, ExposingApplicationState.
The mechanism has been designed to be as flexible as possible. Experience shows that a great variety of objects can with great advantage be represented through this mechanism. That is, not only traditional entities like 'Customer', 'Order' and so on can be represented but also objects like internal parts of your application (classes, enums),
the different methods in an API and even reports and aggregations.

(Even the mechanism for describing this mechanism (PK) is an implementation of it).

HINT: Whenever you are creating a new class in your application, instead of using traditional setters and getters / traditional properties, let class inherit IP and use this mechanism instead.

Using IP from the start makes the rich functionality of AgoRapide available without much work. (You can always build traditional setters and getters and / or traditional property storage on top of that mechanism at a later stage if you so prefer)

Reflecting the fact that instances of this interface often contain a collection of objects, this interface implements the following:
1) Indexing. Enables you to query more 'direct' in C# like for instance 'DataStorage["Customer"]["42"]["FirstName"]'.
2) IEnumerable<IKIP>.
3) The Keys and Values pattern from ordinary .NET Dictionary (see Keys and Values.
This functionality is of course not relevant for value only implementations like PValue<T> but technically implemented nonetheless in all cases in order for any hierarchical structure to be 'probed' from the outside in a standardized manner.

TODO: Implement IDictionary<TKey, TValue> also..

See also PropertyAccess.

_Member, AssemblyName, ClassType, Description, Interfaces, LongDescription
IPAttributeDescribes IP classes (describes at class-level)

See analogue BasePKAttribute which describes properties of classes (describes at property level).

Note that no sub-classes are included in ARCCore.

_Member, AssemblyName, ClassType, Description
IPIIFuture expansion, using different classes for storing, not only PII.

_Member, AssemblyName, ClassType, Description
ITypeDescriberProvides a standardized mechanism for describing single-property values (like 'PhoneNumber' of 'Customer' for instance).

(The difference between ITypeDescriber and IP is that the former must be stored 'inside' an IP.
In RDBMS-terms a ITypeDescriber is the Field stored within a IP which is the Post.)

The most important functionality provided is validation and parsing in a standardized manner.

This is done by a static method call 'EnrichKey' which is supposed to be available in a class 'implementing' this interface.
(In other words, the type implementing this interface is by this principle able to describe itself to AgoRapide).

Note how this interface in itself is empty
(apart from GetSyntaxHelp which is just a suggestion to use in your implementing classes.)

EnrichKey should have the following signature:
public static void EnrichKey(PK k)

A typical method will set ValidatorAndParser although other attributes of PK may also be changed (which gives rise to the somewhat strange name for the method 'EnrichKey').

(note that for very common types like int, long, DateTime, TimeSpan and so on PKTypeAttribute provides a StandardValidatorAndParser.)

A typical implementation can look like this:

public static void EnrichKey(PK k) {
k.SetValidatorAndParser(new Func<string, ParseResult>(value =>
TryParse(value, out var retval, out var errorResponse) ?
ParseResult.CreateOK(retval) :

The TryParse method in the implementation class follows the ordinary .NET pattern with the addition of a 'out string errorResponse' parameter which can communicate WHY the value was not valid for parsing. This helps a lot with error messages, making an API for instance much more user friendly.

Note the the implementation should also overrride object.ToString() to a format actually understood by the ValidatorAndParser returned. This is necessary for the storage mechanism, like PropertyStream to work (serialization and de-serialization of objects).

_Member, AssemblyName, ClassType, Description, LongDescription
MonkeyWrenchDescribes level of 'spanner-throwing' this connection shall contibute with

_Member, AssemblyName, ClassType, Description, Interfaces, LongDescription
P'Dummy'-class, not necessarily in use. See PP for more information. Created because of the concept of CorrespondingClass which is strictly enforced

_Member, AssemblyName, BaseTypes, ClassType, CorrespondingEnumType, Description, Interfaces
ParseResultNOTE: Concept is very old, from the dark ages of AgoRapide's very first inception. There might be room for improvement.
NOTE: (for instance by using a super-class and inheriting classes for OK and ERROR).

_Member, AssemblyName, ClassType, Description
PConcurrentA (somewhat) thread-safe alternative to PRich which also supports log.

Note that thread-safety is only guaranteed for writing / reading key and value pairs directly stored within this class, not for writing / reading to objects further down in the hierarchical storage.

Use this base class when you want to ExposingApplicationState throughout the PropertyStream.
(in other words, use this class as a base class for all parts of your application that do some kind of processing.)

By setting the LogContext, every call to TrySetP will be logged.

In addition the metods Log and HandleException get more meaningful, as they will actually distribute the information somewhere, not just hide it withing the object.

The practical consequence of this is that you do not have to write log-code like this:
var c = new Connection()
c.Id="My connection"
log("Created new connection with id " + c.Id)

See also ExposingApplicationState.
Note that more memory-hungry due to use of ConcurrentDictionary

_Member, AssemblyName, ClassType, CorrespondingEnumType, Description, Interfaces, LongDescription
PExact<EnumType>Very MemoryConsumption efficient alternative to PRich.

Has some limitations in the sense that you can only store an exact number of properties (assumed to come from one specific PropertyKeyEnum), and only use PK as key.

Values are stored 'directly', that is, without packing inside a PValue<T>. (in other words, values are unpacked as they are received (by call to -GetV-), and packed again (by PackObjectForStorageInEntityObject) before being sent.
If PValueEmpty is received from outside, it is treated as 'not-existing' (stored internally as null)

Use this class as basis for your 'entity' classes when you know exact what you want to store in them and when you do not need to store any meta-data like Cid, Created.

The only overhead of this class compared to a 'traditional' C# class (with ordinary properties) should be the overhead for Storage array (24 extra bytes).

See also MemoryConsumption.

_Member, AssemblyName, ClassType, Description, Interfaces, LongDescription
PIIPII = property for storing individual items.

Attempt at solving IndividualItems storage.

Each item is stored as a key in the properties dictionary (with value as PValueEmpty).

Note that using only a HashSet would be more efficient memory-wise, but then we would loose a future ability to store metadata for each key.

_Member, AssemblyName, BaseTypes, ClassType, Description, Interfaces
PKPK = AgoRapide PropertyKey.

Describes properties related to an object (an entity).
In RDBMS-terms it describes the field in the schema for the table)r
Constitutes the basic element of TaggingOfPropertyKeys, and gives the IP mechanism the information it needs in order to implement PropertyAccess.

Contains collection of BasePKAttribute instances which in turn contain the actual attributes. See also TaggingOfPropertyKeys.

NOTE: This class is itself an instance of IP because we want to communicate contents of keys in a standardised manner. They can for instance be communicated to other ARNodeType through the ToPropertyStream.

_Member, AssemblyName, BaseTypes, ClassType, Description, Interfaces
PK+BasePKAttributeNotFoundException<T>Explains how to implement a given BasePKAttribute for an enum

_Member, AssemblyName, BaseTypes, ClassType, Description, Interfaces
PK+PKBoolPairUsed to signify that a given PK returned from value factory inside FromEnum has not been initialized (has not yet been populated with PKTypeAttribute collection).

_Member, AssemblyName, ClassType, Description
PKLogAttributeExplains how logging of changes to a property should be done.
Describes mostly occasions where logging shall be restricted.

Normally when a class like PConcurrent is set up to log (like through LogContext), then every property's changes will be logged. In some cases this is too much, for instance if CountReceiveMessage was to be logged for every PropertyStream-line received, that would generate another property stream line which again would update the CountReceiveMessage value.

Utilized by for instance ActualConnection.

See also ExposingApplicationState.

See also PKLogAttributeP.

_Member, AssemblyName, BaseTypes, ClassType, CorrespondingEnumType, Description, Interfaces
PKTypeAttributeContains the most basic essential information about a property key, like its description, type and cardinality.

Will always be present within an instance of PK.

See also PKTypeAttributeP.

_Member, AssemblyName, BaseTypes, ClassType, CorrespondingEnumType, Description, Interfaces
PRichFully flexible storage. Can store anything. Typical inherited for entity representations like 'Customer' or 'Order'.

PRich = rich property. Rich in the sense that it can store a wide amount of information.

Can also function as a 'root' storage for all data.

Inherently not thread-safe due to using Dictionary and not ConcurrentDictionary as storage.
See tips about locking in documentation for OutsideLocalReceiver and some practical code in ARCDoc

See PConcurrent for a (somewhat more) thread-safe alternative.
See PExact<EnumType> for a more memory efficient alternative.

A more expensive (memory-wise) 'property'-object to use compared to PValue<T>.

Probably suitable when you want full flexibility about which metadata to store (see PP) and / or want to store child properties.
Most probably the one to use for 'ordinary' entities like 'Customer', 'Product' and so on, whereas PValue<T> is often used for single values for these instances (like 'FirstName', 'Price' and so on).

An instance of this class can also be used as the single total in-memory data storage in your application.
A typical representation would then consist of dictionaries inside dictionaries, with IK-keys and either PRich-values or specific IP-subclass instances (like 'Customer') values inside those again.
Such a usage would be very typical for a Client but also possible for ArmDB (enabling it to answer AdHocQuery over an TCP/IP connection.
With such a usage the instance of this class would typically populated by calling -ParseAndStore-.

_Member, AssemblyName, ClassType, Description, Interfaces, LongDescription
PropertyStreamLineHas two main functions:

1) Encodes and decodes single lines in the PropertyStream.
See methods like EncodeKeyPartStringToPropertyStreamFormat, EncodeValuePartStringToPropertyStreamFormat and DecodeStringFromPropertyStreamFormat.

2) Stores single lines in the PropertyStream into a data-storage. See TryStore.

3) Parses a collection of PropertyStream lines into a single IP instanse.
See methods like TryParseDirectToIP.

4) Parses a single PropertyStream line into a single property.
See methods like TryParseDirectToProperty.

A line consists of a key-part, the separator ' = ' (space, equals sign, space) and a value part.
(the value part may be empty, see PValueEmpty).

Examples are (syntax only approximate as of May 2020):
'// This is a comment (lines starting with // are to be ignored in any processing
'dt/Customer/42 (create new Customer object, actually this line is not necessary)
'dt/Customer/42/Cid = User/43' // (See Cid)
'dt/Customer/42/FirstName = John'
'dt/Customer/42/PhoneNumber/+4790534333' (create new PhoneNumber)
'dt/Customer/42/PhoneNumber/+4790534333:Invalid = 2020-03-12 08:42:11' (Equivalent to 'delete', see -Invalid)

'dt/Order/1968/CustomerId = Customer/42'

'dt/OrderLine/2001/OrderId = Order/1968'
'dt/OrderLine/2001/ProductId = Product/2003'
'dt/OrderLine/2001/Quantity = 3'

'dt/Product/2003/Name = Widget3'
'dt/Product/2003/Colour = Red'

Note that timestamps are normally not needed because the property stream is sequentially organised, and timestamps are inserted automatically (see TimestampResolution).
See EncodeKeyPartStringToPropertyStreamFormat and EncodeValuePartStringToPropertyStreamFormat for how data is actually encoded (examples given above are only indicative).

Note that this class is static, that is, no instances if this class are ever created.
Instead simple strings are used for representing property stream lines for transmission and storage. This is considered to be more efficient (less processing required) and take up less memory (especially for CoreDB).

_Member, AssemblyName, ClassType, Description, LongDescription
PropertyStreamLineParsedParses the keys part of a line from PropertyStream, like 'Customer/42/FirstName = John.

Should only be used in ephemeral contexts as class is assumed to be somewhat memory hungry.

In general, property stream lines should be stored as string only by CoreDB (and possible also ArmDB).
Client will normally use PropertyStreamLineParsed as a middle step in order to to translate the string representation of a PropertyStreamLine into a hierarhical data storage.

_Member, AssemblyName, ClassType, Description
PValue<T>Single value storage.

The most memory-efficient 'property'-object to use, when only the actual value of a property is needed.
(unable to store any sub-properties or metadata).

Immutable (assuming generic type is also immutable).

Typically used for storing properties like 'Customer.FirstName', 'Product.Price' and so on.

When metadata is desired, a more complicated approach is used. See Value for a more detailed explanation about this
Using this class should give an overhead per object of 24 bytes (16 for object header, 8 for Value), in addition to the space needed for the actual object (of type T) stored. Note, when calculating space needed for the actual object (of type T) you must remember to include boxing-overhead for value types.

TODO: Consider creating a PValueVal-class for storing value types. This should get rid of boxing...?
TODO: (However, no practical use-case has been seen as of Jul 2020 because of PExact<EnumType> TODO: which stores objects directly within an Object[], that is, not using PValue<T> at all.)

See also MemoryConsumption.

_Member, AssemblyName, ClassType, Description, Interfaces
PValueEmptyRepresents the 'no value'.
Relevant for -IndividualItems where the values are actual keys (stored as IKString) and we just need a dummy representation where the value would ordinary be placed

_Member, AssemblyName, ClassType, Description, Interfaces
RExREx = 'TooDeepRecursiveDepthException'

Functionality that helps to guard against infinite recursion.

void RecursiveMethod() {
try {
.... Some code calling RecursiveMethod again, either directly or indirectly ...
} finally {

Alternatively, you can just do:
REx.Inc() + RecursiveMethod() + REx.Inc()
whenever RecursiveMethod returns a string.
This later approach is useful in expressions, meaning you do not have to build statements in order to use this class. If exceptions should occur in RecursiveMethod however, the recursive counter may 'leak' upwards.

_Member, AssemblyName, BaseTypes, ClassType, Description, Interfaces, LongDescription
ShardingEnables load-balancing by describing what data should be sent over a given connection.
If load-balancing is combined with fault-tolerance (see MultipleConnectionUsage, then multiple connections with the same value for Sharding- are grouped together and considered separately for other groups

_Member, AssemblyName, ClassType, Description, Interfaces, LongDescription
StorageFileImplemented only in order to store some ideas about Hash.

_Member, AssemblyName, BaseTypes, ClassType, CorrespondingEnumType, Description, Interfaces
StreamProcessorImplements the storage mechanism for AgoRapide.

Coordinates the PropertyStream with other nodes.

TODO: Implement discarding of data when not listening to incoming connections (saves memory usage).
TODO: (search for this TODO in code to see where relevant to make changes).

Has the following functionality:
(note: Terminology is kept close to the one used for the MQTT protcol, although AgoRapide does not use MQTT in itself)

1) Listen to incoming TCP/IP connections from other nodes. An incoming connections may be either for:
a) Incoming data (from a publishing client), for us to distribute.
as a CoreDB we would then store the data locally and then distribute the data to all current downstream subscriber clients as relevant according to their respective subscriptions (Note: For incoming data on an incoming connection an implicit -IsAll-, '+*', is assumed), as a ArmDB we would then forward the data to a CoreDB )
or for
b) Outgoing data, downstream subscribing client requests subscription
we would then typically be a CoreDB or a ArmDB.
After having reveived the Subscription and ClientUpdatePosition
from the subscribing client we will then keep the client continously up-to-date with new data.

2) Connect to other nodes. An outgoing connection may be either for
a) Publishing properties. ( As a publishing Client the data would be locally in-application generated properties.
As an ArmDB the data would typically have been received over an incoming connection from a Client )
or for
b) Receiving (as downstream subscribing client) data from upstream server.
We would then typically be an ArmDB or Client
We would send Subscription and ClientUpdatePosition as soon as connection is established.

_Member, AssemblyName, BaseTypes, ClassType, CorrespondingEnumType, Description, Interfaces, LongDescription
StreamProcessor+PropertyStreamLineWithOriginThe rationale for this class is that ReceiveAndDistribute needs to distingush origin of data when routing it (in general, in order to avoid sending it back to its source).

This class is not to be confused with PropertyStreamLine.

_Member, AssemblyName, ClassType, Description
StreamProcessor+StorageFile_Member, AssemblyName, ClassType
SubscriptionA stream Subscription is the concept of how nodes (see ARNodeType) subscribe to the PropertyStream (either the whole stream or just part of it) in a distributed manner.

This class Subscription describes WHAT data is required from the PropertyStream.
Used in connection with ClientUpdatePosition which describes from WHERE (from WHEN) in the historic PropertyStream data is to be returned.

This class describes a single subscription element. A complete query consists of one or more instances of this class. See IsMatch for how a query is evaluated.

Some examples of subscriptions could be:

1) A Client, for instance ARCAPI, subscribing (towards CoreDB) to those parts of the PropertyStream that it needs for its functioning.
As this client receives the incoming properties (through OutsideLocalReceiver) they would typically be stored in a PRich for immediate in-memory evaluation of incoming queries to the client again.

2) Subscribe to logging properties for setting up of a log-console (see log).

3) Subscribe to whole database or part of database in different manners in order to set up load-balancing, fault-tolerance, caching and similar (see MultipleConnectionUsage and Sharding for more information).
(in other words, synchronizing and coordinating between multiple AgoRapide based nodes, especially between CoreDB nodes.) Note how the subscription instruction itself can very well be sent over the PropertyStream, configuring the different nodes from a central entry point of administration.

See SyntaxHelp.

TODO: Introduce '**' in order to signify any hierarchical level.
TODO: Like +**/Heartbeat/* in order to collect all Heartbeat in the system, regardless of hierarchical level.
See IsMatch (static method) for how a query consisting of multiple instances of Subscription are evaluated.

_Member, AssemblyName, ClassType, Description, Interfaces, LongDescription
TValuePlaceholder for any class type suitable as generic type parameter PValue<T>.

Used for documentation purposes only.
This class helps with referring to PValue<T> classes when using the 'nameof' keyword because it is not possible to simply do 'nameof(PValue<T>)'. You have to specify a class like 'nameof(PValue<object>)' or 'nameof(PValue<string>)' but that would be misleading. 'nameof(PValue<TValue>)' is then better to use.

Note that this issue does not exist with XML-comments where you can simply just write <see cref="PValue{T}"/>

_Member, AssemblyName, ClassType, Description
UtilMethods and functionality that we are unable to find another natural home for.

_Member, AssemblyName, ClassType, Description, LongDescription

50 items

Generated 2020-10-13 11:11:05.835 UTC