-> Vertically: as a full application development solution valos radically simplifies the semantic web technology stack.
-> Horizontally: as a global, decentralized ecosystem valos eases cross-organization interfacing.
-> In depth: with its isomorphic resource model valos blurs the boundary between frontends and backends.
-> Temporally: valos unifies document state and change updates into seamless event streams, *chronicles*.
Prefix | IRI |
---|---|
rdf | http://www.w3.org/1999/02/22-rdf-syntax-ns# |
rdfs | http://www.w3.org/2000/01/rdf-schema# |
xsd | http://www.w3.org/2001/XMLSchema# |
owl | http://www.w3.org/2002/07/owl# |
dc | http://purl.org/dc/elements/1.1/ |
V | https://valospace.org/0# |
VKernel | https://valospace.org/kernel/0# |
VState | https://valospace.org/state/0# |
VScript | https://valospace.org/script/0# |
VEngine | https://valospace.org/engine/0# |
VLog | https://valospace.org/log/0# |
VPlot | https://valospace.org/plot/0# |
rdfs:subClassOf | description |
---|
rdfs:domain | rdfs:range |
---|
rdfs:domain | rdfs:range |
---|---|
#immediateContent Media.prototype.$V.immediateContent | |
V:Media The class of valospace resources which represent interpretable media and can be associated with mutable binary content and accompanying metadata. With Relation and Media it forms the group of three primary node types. | immediateContent(options) |
description | Returns Media content if immediately available or throws otherwise. |
introduction | Media content is immediately available if its has been downloaded and marked as in-memory cacheable. The thrown error can be a missing connection error which triggers an implicit connection process. See V:interpretContent for more details. |
#interpretContent Media.prototype.$V.interpretContent | |
V:Media The class of valospace resources which represent interpretable media and can be associated with mutable binary content and accompanying metadata. With Relation and Media it forms the group of three primary node types. | interpretContent(options) |
description | Returns a promise to a Media content interpretation as optionally given *options.contentType*. |
introduction | The default contentType if determined as follows:
|
#immediateURL Media.prototype.$V.immediateURL | |
V:Media The class of valospace resources which represent interpretable media and can be associated with mutable binary content and accompanying metadata. With Relation and Media it forms the group of three primary node types. | immediateURL(options) |
description | Returns a Media content download URL if immediately available or throws an error otherwise. |
introduction | The returned URL can be used to fetch an online resource in the local context. This URL is only temporarily valid. The expiration time is defined by the chronicle behaviors and its backend implementation. The error can be a missing connection error which triggers an implicit connection process. See V:getURL for more details. |
#getURL Media.prototype.$V.getURL | |
V:Media The class of valospace resources which represent interpretable media and can be associated with mutable binary content and accompanying metadata. With Relation and Media it forms the group of three primary node types. | getURL(options) |
description | Returns a promise to a Media content download URL. |
introduction | The resolved URL can be used to fetch the Media content in the local context. This URL is only temporarily valid. The expiration time is defined by the chronicle behaviors and its backend implementation. |
#getRelations Relatable.prototype.$V.getRelations | |
V:Relatable | getRelations(name) |
description | Returns an array of all outgoing relations with the given *name* as their V:name. |
introduction | Outgoing relations are all V:Relation resources owned by *this* V:Relatable in its V:relations and which have *this* as their V:source. If no *name* is given returns all outgoing relations. Note: all matching relations are selected, even those in unconnected chronicles. |
#getRelationTargets Relatable.prototype.$V.getRelationTargets | |
V:Relatable | getRelationsTargets(name) |
description | Returns an array of all the V:target resources of those outgoing relations which have the given *name* as their V:name. |
introduction | This method is identical to V:getRelations except that the returned array contains the V:target resources instead of the relations themselves. |
#setRelations Relatable.prototype.$V.setRelations | |
V:Relatable | setRelations(name, newRelations) |
description | Replaces all relations with given *name* with relations in given *newRelations* sequence. |
introduction | This can be used to reorder the relations, as even if no entries are actually removed or added (if the new set has the same entries as the existing set), their order will be changed to match the order in the new sequence. |
#getIncomingRelations Relatable.prototype.$V.getIncomingRelations | |
V:Relatable | getIncomingRelations(name) |
description | Returns an array of all incoming, connected relations with the given *name* as their V:name. |
introduction | Incoming relations are all V:Relation resources that appear in the V:incomingRelations and which have *this* as their V:target. Note: only relations inside connected chronicles are listed (even though some might be inactive, f.ex. if they have an inactive prototype). |
#getIncomingRelationSources Relatable.prototype.$V.getIncomingRelationSources | |
V:Relatable | getIncomingRelationsSources(name) |
description | Returns an array of all V:source resources of those incoming relations which have the given *name* as their V:name |
introduction | This method is identical to V:getIncomingRelations except that the returned array contains V:source resources instead of the relations themselves. |
#setIncomingRelations Relatable.prototype.$V.setIncomingRelations | |
V:Relatable | setIncomingRelations(name, newIncomingRelations) |
description | Replaces all incoming relations with given *name* with relations in given *newIncomingRelations* sequence. |
introduction | This can be used to reorder the relations, as even if no entries are actually removed or added (if the new set has the same entries as the existing set), their order will be changed to match the order in the new sequence. |
#Resource.prototype.hasOwnProperty Resource.prototype.hasOwnProperty | |
V:Resource The class of resources which can appear as a subject in valospace resource and event graphs. The domain of all transient and generated fields which are available even for unsourced bodies. | hasOwnProperty(propertyName) |
description | Returns true if this resource has the given *propertyName* as its own locally materialized property, false otherwise. |
#getField Resource.prototype.$V.getField | |
V:Resource The class of resources which can appear as a subject in valospace resource and event graphs. The domain of all transient and generated fields which are available even for unsourced bodies. | getField(fieldName) |
description | Returns the value of the valospace field with given *fieldName* of *this* Resource |
introduction | This is an internal API and should be avoided in favor of ordinary field access. |
#getFieldCoupling Resource.prototype.$V.getFieldCoupling | |
V:Resource The class of resources which can appear as a subject in valospace resource and event graphs. The domain of all transient and generated fields which are available even for unsourced bodies. | getFieldCoupling(fieldName) |
description | Returns the coupled field of the given singular valospace field *fieldName* of *this* Resource |
introduction | |
#setField Resource.prototype.$V.setField | |
V:Resource The class of resources which can appear as a subject in valospace resource and event graphs. The domain of all transient and generated fields which are available even for unsourced bodies. | setField(fieldName, newValue) |
description | Sets the value of the field *fieldName* of *this* Resource. |
#addToField Resource.prototype.$V.addToField | |
V:Resource The class of resources which can appear as a subject in valospace resource and event graphs. The domain of all transient and generated fields which are available even for unsourced bodies. | addToField(fieldName, value) |
description | Adds the given *value* to the host field with given *fieldName* of *this* Resource. |
introduction | If the *value* is an iterable all the entries will be added in iteration order. All added values will be placed to the end of the sequence, even if they already exist. |
#removeFromField Resource.prototype.$V.removeFromField | |
V:Resource The class of resources which can appear as a subject in valospace resource and event graphs. The domain of all transient and generated fields which are available even for unsourced bodies. | removeFromField(fieldName, value) |
description | Removes the given *value* from the host field with given *fieldName* of *this* Resource. |
introduction | If the *value* is an iterable all the iterated entries will be removed. |
#replaceWithinField Resource.prototype.$V.replaceWithinField | |
V:Resource The class of resources which can appear as a subject in valospace resource and event graphs. The domain of all transient and generated fields which are available even for unsourced bodies. | replaceWithinField(fieldName, replacedValues, withValues) |
description | Replaces the given *replacedValues* within the field *fieldName* of *this* Resource with given *withValues*. |
introduction | Behaves like a removedFrom call followed by an addedTo call, where the removedFrom is given the entries appearing only in *replacedValues* and addedTo is given *withValues* as-is. |
#setOwner Resource.prototype.$V.setOwner | |
V:Resource The class of resources which can appear as a subject in valospace resource and event graphs. The domain of all transient and generated fields which are available even for unsourced bodies. | setOwner(owner) |
description | Sets the host owner of *this* Resource to the given *owner*, with optionally given *coupledFieldName*. |
introduction | The coupledFieldName default value is based on the type of this resource as either 'unnamedOwnlings', 'properties', 'relations' or 'listeners' |
#getEntity Resource.prototype.$V.getEntity | |
V:Resource The class of resources which can appear as a subject in valospace resource and event graphs. The domain of all transient and generated fields which are available even for unsourced bodies. | getEntity(name) |
description | Returns the first owned Entity with the given *name*. |
#getMedia Resource.prototype.$V.getMedia | |
V:Resource The class of resources which can appear as a subject in valospace resource and event graphs. The domain of all transient and generated fields which are available even for unsourced bodies. | getMedia(name) |
description | Returns the first owned Media with the given *name*. |
#getFixedResource Resource.prototype.$V.getFixedResource | |
V:Resource The class of resources which can appear as a subject in valospace resource and event graphs. The domain of all transient and generated fields which are available even for unsourced bodies. | getFixedResource(subPlot, explicitChronicleURI) |
description | Returns a reference to the fixed sub-resource reached from this resource via the given *subPlot* VPlot. |
introduction | This call does not create any resources. If the resource does not exist the reference will be immaterial. Alternatively the *subPlot* can be a fixed field object which is used to determined the actual resource sub-id vplot. The keys of the object are divided to three groups: - Specials: keys 'id', 'typeName', 'name' and 'params' have semantics described below - Plain terms: all other string keys are sorted and treated as namespace 'V' terms - Symbol terms: all symbols must be valid namespace names, sorted lexically as [namespace, term] pairs Firstly the resource sub-id starts with the value of 'id' key which if given must contain the verb type and an optional number of params. Otherwise if 'id' is not given the sub-id verb type is generated based on 'typeName' if it is given. Otherwise the verb type is set to "@_". Secondly if 'name' is specified it is then prepended as the first param. Thirdly all sorted plain terms are appended to the params. Fourthly all sorted symbol terms are appended to the params. Finally all 'param' values are appended to the params. See also $V.obtainFixedResource. |
#getFixedEntity Resource.prototype.$V.getFixedEntity | |
V:Resource The class of resources which can appear as a subject in valospace resource and event graphs. The domain of all transient and generated fields which are available even for unsourced bodies. | getFixedEntity(subPlot, explicitChronicleURI) |
description | Returns a reference to the fixed sub-entity reached from this resource via the given *subPlot* VPlot. |
introduction | This call does not create any resources. If the sub-resource does not exist the reference will be immaterial. Alternatively the *subPlot* can be a fixed field object. In this case this call adds "Entity" as a typeName to it. See $V.getFixedResource for more details. |
#getFixedMedia Resource.prototype.$V.getFixedMedia | |
V:Resource The class of resources which can appear as a subject in valospace resource and event graphs. The domain of all transient and generated fields which are available even for unsourced bodies. | getFixedEntity(subPlot, explicitChronicleURI) |
description | Returns a reference to the fixed sub-media reached from this resource via the given *subPlot* VPlot. |
introduction | This call does not create any resources. If the sub-resource does not exist the reference will be immaterial. Alternatively the *subPlot* can be a fixed field object. In this case this call adds "Media" as a typeName to it. See $V.getFixedResource for more details. |
#getFixedRelation Resource.prototype.$V.getFixedRelation | |
V:Resource The class of resources which can appear as a subject in valospace resource and event graphs. The domain of all transient and generated fields which are available even for unsourced bodies. | getFixedEntity(subPlot, explicitChronicleURI) |
description | Returns a reference to the fixed sub-relation reached from this resource via the given *subPlot* VPlot. |
introduction | This call does not create any resources. If the sub-resource does not exist the reference will be immaterial. Alternatively the *subPlot* can be a fixed field object. In this case this call adds "Relation" as a typeName to it. See $V.getFixedResource for more details. |
#obtainFixedResource Resource.prototype.$V.obtainFixedResource | |
V:Resource The class of resources which can appear as a subject in valospace resource and event graphs. The domain of all transient and generated fields which are available even for unsourced bodies. | obtainFixedResource(subPlot, extendInitialState, explicitChronicleURI) |
description | Returns an existing or a newly created fixed sub-resource that is reached from this resource via the given *subPlot* VPlot. |
introduction | Will create all resources traversed by the subPlot VPlot that don't exist. Provides initial field and property values for the newly created resources so that they satisfy the semantic constraints of the *subPlot* VPlot elements. This typically means that at least the resource type and its $V.owner and $V.name are initialized, but depending on VPlot contents other properties can also be initialized. Calls the optional callback argument *extendInitialState* for each new resource right before the resource is created. This call is passed *initialState* and *subPlotIndex* as arguments. The *subPlotIndex* is an index to the *subPlot* sub-element for which a new resource is about to be created. The *initialState* contains the initial fields and properties for the new resource. These values are immutable and can only be inspected but new fields and properties can be added. Once the callback returns the *initialState* will be passed to the V:Resource.new call. |
#instantiate Resource.prototype.$V.instantiate | |
V:Resource The class of resources which can appear as a subject in valospace resource and event graphs. The domain of all transient and generated fields which are available even for unsourced bodies. | instantiate(initialState) |
description | Instantiates *this* Resource with given *initialState*. |
#duplicate Resource.prototype.$V.duplicate | |
V:Resource The class of resources which can appear as a subject in valospace resource and event graphs. The domain of all transient and generated fields which are available even for unsourced bodies. | duplicate(initialState) |
description | Duplicates *this* Resource with given *initialState*. |
#prepareBlob Resource.prototype.$V.prepareBlob | |
DEPRECATED in favor of: | V:prepareBvob Uploads the given *content* and returns a promise to a Bvob resource creation callback. |
V:Resource The class of resources which can appear as a subject in valospace resource and event graphs. The domain of all transient and generated fields which are available even for unsourced bodies. | prepareBlob(content) |
description | DEPRECATED, prefer: V:prepareBvob. Returns a promise to a Bvob creator callback. See Resource.prepareBvob. |
#prepareBvob Resource.prototype.$V.prepareBvob | |
V:Resource The class of resources which can appear as a subject in valospace resource and event graphs. The domain of all transient and generated fields which are available even for unsourced bodies. | prepareBvob(content) |
description | Uploads the given *content* and returns a promise to a Bvob resource creation callback. |
introduction | All valospace binary content is associated with a chronicle in the
form immutable Bvob resource references. A full process of uploading
content to valospace is a two-stage process. Firstly the content must
be uploaded and validated by persistence layers. Secondly the content
hash must be chronicled as a Bvob reference in the chronicle event log.
This function initiates the first stage and returns a promise to a
callback. The promise resolves when the given *content* has been
converted into raw data and persisted in the *nearest persistence cache*.
The resolved value is a callback which when called creates a Bvob
resource in the chronicle of *this* Resource and returns a reference to
it. This Bvob should then be immediately assigned to a resource field
in the chronicle (usually as V:content of some V:Media) to initiate the
second stage. Note that as the Bvob itself only represents binary
content all encoding information, contentType and any other metadata
should be assigned at the same time (see V:Media).
There can be a period of time between the first stage and the second
stage, especially if user interaction is performed in between. During
this period the uploaded content is pending and likely has no chronicle
references to it until the second stage is initiated and completed.
The pending content is guaranteed to remain valid until one of the
following conditions is true:
|
#getProperty Scope.prototype.$V.getProperty | |
DEPRECATED in favor of: | Object.getOwnPropertyDescriptor |
V:Scope The class of valospace resources which can have scoped properties. | getProperty(name) |
description | DEPRECATED, prefer: Object.getOwnPropertyDescriptor. Returns the Property object with the given name in this Scope. |
introduction | This Property object is an internal detail of @valos/engine. |
#getHostGlobal Scope.prototype.$V.getHostGlobal | |
V:Scope The class of valospace resources which can have scoped properties. | getHostGlobal() |
description | Returns the javascript host global object associated with this Scope. |
introduction | The host global object of a Scope resource is used as the javascript
global object for all application/javascript medias that are owned by
the Scope.
This global object prototypically inherits the host global object of
the nearest owning Scope. Thus all host global variables introduced to
the Scope by its directly owned javascript medias will be available to
all other medias directly or indirectly owned by the Scope.
The host global object is a native host environment javascript object,
so that unlike valospace resource modifications, the host global object
modifications are:
|
#getFickleId TransientFields.prototype.$V.getFickleId | |
V:TransientFields | getFickleId(minimumLength) |
description | Returns a short, descriptive but fickle identifier string of this resource. |
introduction | The fickle is uniquely mapped to this resource but during this execution session only. The returned fickle id string is guaranteed to be at least the given *minimumLength* characters long. The fickle id may be longer if a shorter id candidate is already allocated for another resource. The fickle algorithm is a best-effort algorithm which /most of the time/ returns a prefix of the resource raw id that is same across sessions, but none of these qualities is guaranteed. |
#createDerivedId TransientFields.prototype.$V.createDerivedId | |
V:TransientFields | createDerivedId(salt) |
description | Creates a deterministic, unique id string based on the id of *this* resource as well as the optional *salt* and optional *contextId* strings. |
introduction | The generated id is always the same for same combination of these three values. |
#hasInterface TransientFields.prototype.$V.hasInterface | |
V:TransientFields | hasInterface(interfaceName) |
description | Returns true if *this* resource implements the host interface *interfaceName* |
rdf:subject | rdfs:range |
---|
rdf:subject | rdfs:range |
---|---|
#Chronicle.createPartitionURI Chronicle.createPartitionURI | |
V:Chronicle | createNaivePartitionURI(baseString, partitionRawId) |
description | Creates a URI from given *base* and *partitionId* strings |
#Chronicle.createChronicleURI Chronicle.createChronicleURI | |
V:Chronicle | createChronicleURI(authorityURI, chronicleId) |
description | Creates a URI from given *authorityURI* and *chronicleId* strings (coercing non-vplot id's) |
#Chronicle.splitChronicleURI Chronicle.splitChronicleURI | |
V:Chronicle | splitChronicleURI(chronicleURI) |
description | Returns an array containing the authority URI and the chronicle id of given *chronicleURI* |
#Chronicle.tryPartitionConnection Chronicle.tryPartitionConnection | |
DEPRECATED in favor of: | V:Chronicle.tryConnection Returns an existing, fully active connection to the chronicle with given *chronicleURI*, undefined otherwise |
V:Chronicle | tryPartitionConnection(chronicleURI) |
description | DEPRECATED, prefer: V:Chronicle.tryConnection. Returns an existing, fully active connection to the chronicle with given *chronicleURI*, undefined otherwise |
introduction | |
#Chronicle.tryConnection Chronicle.tryConnection | |
V:Chronicle | tryConnection(chronicleURI) |
description | Returns an existing, fully active connection to the chronicle with given *chronicleURI*, undefined otherwise |
#Chronicle.acquirePartitionConnection Chronicle.acquirePartitionConnection | |
DEPRECATED in favor of: | V:Chronicle.acquireConnection Returns a promise to a full connection to the chronicle with given *chronicleURI* and *options*. |
V:Chronicle | acquireConnection(chronicleURI) |
description | DEPRECATED, prefer: V:Chronicle.acquireConnection. Returns a promise to a full connection to the chronicle with given *chronicleURI* and *options*. |
introduction | If no full connection exists, waits on a possibly existing on-going connection process. If none exists creates a new connection process. |
#Chronicle.acquireConnection Chronicle.acquireConnection | |
V:Chronicle | acquireConnection(chronicleURI) |
description | Returns a promise to a full connection to the chronicle with given *chronicleURI* and *options*. |
introduction | If no full connection exists, waits on a possibly existing on-going connection process. If none exists creates a new connection process. |
#Chronicle.sourcerChronicle Chronicle.sourcerChronicle | |
V:Chronicle | sourcerChronicle(chronicleURI) |
description | Returns a promise to a sourcered chronicle with given *chronicleURI* and *options*. |
introduction | If no full connection exists, waits on a possibly existing on-going connection process. If none exists creates a new connection process. |
#Relatable.getRelationsOf Relatable.getRelationsOf | |
DEPRECATED in favor of: | V:getRelations Returns an array of all outgoing relations with the given *name* as their V:name. |
V:Relatable | getRelationsOf(relatable, name) |
description | DEPRECATED, prefer: V:getRelations. Returns an array which contains all Relation objects of given *relatable* which have the given *name* |
introduction | Returned relation objects have given *relatable* as their host *Relation.source* field value and which fullfill all constaints of given additionalConditions |
#Relatable.getIncomingRelationsOf Relatable.getIncomingRelationsOf | |
DEPRECATED in favor of: | V:getIncomingRelations Returns an array of all incoming, connected relations with the given *name* as their V:name. |
V:Relatable | getIncomingRelationsOf(entity, name) |
description | DEPRECATED, prefer: V:getIncomingRelations. Returns an array which contains all Relation objects which have the given *name* |
introduction | have *this* relatable as their host *Relation.target* field value and which fullfill all constaints of given additionalConditions |
#Resource.activate Resource.activate | |
V:Resource The class of resources which can appear as a subject in valospace resource and event graphs. The domain of all transient and generated fields which are available even for unsourced bodies. | activate(resource) |
description | Returns a promise to an activation operation of the given *resource* |
introduction | Activating a resource is the operation of sourcering the chronicles of all of the resources in its prototype chain. The returned promise resolves to the given resource itself once all corresponding chronicles have completed their first narration. If the resource is already active the returned promise is an already resolved one. |
#Resource.isActive Resource.isActive | |
V:Resource The class of resources which can appear as a subject in valospace resource and event graphs. The domain of all transient and generated fields which are available even for unsourced bodies. | isActive(resource) |
description | Returns true if the given *resource* is active |
introduction | Returns false if the *resource* is inactive and not being activated at all, or if any of the prototype chain chronicles is still undergoing sourcering or first narration. |
#Resource.getFieldOf Resource.getFieldOf | |
DEPRECATED in favor of: | V:getField Returns the value of the valospace field with given *fieldName* of *this* Resource |
V:Resource The class of resources which can appear as a subject in valospace resource and event graphs. The domain of all transient and generated fields which are available even for unsourced bodies. | getFieldOf(resource, fieldVAKON) |
description | DEPRECATED, prefer: V:getField. Returns the value of the host field with given *fieldName* of the given *resource* |
#Resource.setFieldOf Resource.setFieldOf | |
DEPRECATED in favor of: | V:setField Sets the value of the field *fieldName* of *this* Resource. |
V:Resource The class of resources which can appear as a subject in valospace resource and event graphs. The domain of all transient and generated fields which are available even for unsourced bodies. | setFieldOf(resource, fieldName, newValue) |
description | DEPRECATED, prefer: V:setField. Sets the host field with given *fieldName* of the given *resource* to given *newValue* |
#Resource.getOwnerOf Resource.getOwnerOf | |
DEPRECATED in favor of: | V:owner The owner of this extant resource. |
V:Resource The class of resources which can appear as a subject in valospace resource and event graphs. The domain of all transient and generated fields which are available even for unsourced bodies. | getOwnerOf(resource) |
description | DEPRECATED, prefer: V:owner. Returns the owner of the given *resource* |
#Resource.setOwnerOf Resource.setOwnerOf | |
DEPRECATED in favor of: | V:setOwner Sets the host owner of *this* Resource to the given *owner*, with optionally given *coupledFieldName*. |
V:Resource The class of resources which can appear as a subject in valospace resource and event graphs. The domain of all transient and generated fields which are available even for unsourced bodies. | setOwnerOf(resource, owner) |
description | DEPRECATED, prefer: V:setOwner. sets the host owner of the given *resource* to the given *owner* |
introduction | Can optionally be given *coupledField*. If not given coupledField default value is determined by the type of this resource to be either 'unnamedOwnlings', 'properties', 'relations' or 'listeners' |
#Resource.getActiveResource Resource.getActiveResource | |
V:Resource The class of resources which can appear as a subject in valospace resource and event graphs. The domain of all transient and generated fields which are available even for unsourced bodies. | getActiveResource(id) |
description | Returns the active resource with given *id* if one exists, otherwise throws an error. |
introduction | An active resource is an existing, non-destroyed resource in a fully connected chronicle whose all possible prototypes are also active. If the error is due to an unconnected or partially connected chronicle an absent chronicle error is thrown. This causes an implicit chronicle connection attempt which by default restarts this transaction. Otherwise a regular, by default unhandled exception is thrown. |
#Resource.tryActiveResource Resource.tryActiveResource | |
V:Resource The class of resources which can appear as a subject in valospace resource and event graphs. The domain of all transient and generated fields which are available even for unsourced bodies. | tryActiveResource(id) |
description | Returns the active resource with given *id* if one exists, otherwise returns null. |
introduction | An active resource is an existing, non-destroyed resource in a fully connected chronicle whose all possible prototypes are also active. |
#Resource.recombine Resource.recombine | |
V:Resource The class of resources which can appear as a subject in valospace resource and event graphs. The domain of all transient and generated fields which are available even for unsourced bodies. | recombine() |
description | Returns an array of duplicated resources based on the given *duplicationDirectives* (dd). |
introduction | The duplications are performed as if they are part of a single duplication; all directly and indirectly owned cross-references between all *dd.duplicateOf* resources are updated to cross-refer to the appropriate (sub-)resources in the resulting duplicates. This has two major advantages over the singular duplication. First advantage is that recombination allows for fine-grained control over all duplicated resources and not just the top-level. When a *dd.duplicateOf* refers to a resource which is already being implicitly duplicated (by some other directive targeting its (grand)owner) then the rules in the explicit dd override the default duplication instead of creating an extra duplicate. Notably this also allows for omission of whole sub-branches from the duplication by specifying null *dd.id*. Second advantage is that by providing customized *dd.initialState.owner* values the recombination can fully alter ownership hierarchy of the duplicated objects (unlike duplication which once again can only manage duplicated top-level resource). Specifically this enables duplication of resources from different locations and even chronicles to under the same entity while maintaining the internal cross-references between different recombined resources. Vice versa recombine allows spreading the duplicates to separate chronicles (at least insofar a multi-chronicle commands between said chronicles is possible). |
#Resource.destroy Resource.destroy | |
V:Resource The class of resources which can appear as a subject in valospace resource and event graphs. The domain of all transient and generated fields which are available even for unsourced bodies. | destroy(resource) |
description | Destroys the given *resource* and recursively all resources owned by it |
#Scope.createIdentifer Scope.createIdentifer | |
V:Scope The class of valospace resources which can have scoped properties. | createIdentifier(initialValue) |
description | Creates and returns an identifier binding object. |
introduction | When an identifier object is placed as a scope lookup value it will act as an assignable identifier binding for valoscript identifier operations with name equal to the key of the scope lookup. |
rdf:type | rdfs:subClassOf |
---|---|
#Chronicle window.valos.Chronicle | |
description | |
#Describable window.valos.Describable | |
description | |
#DestroyedScriptResource window.valos.DestroyedScriptResource | |
description | |
#Discoverable window.valos.Discoverable | |
description | |
#InactiveScriptResource window.valos.InactiveScriptResource | |
description | |
#Property window.Property | |
description | |
#Relatable window.Relatable | |
description | |
#TransientFields window.valos.TransientFields | |
description | |
#TransientScriptFields window.valos.TransientScriptFields | |
description |
Term | Definition | @id | @type | @container |
---|---|---|---|---|
restriction | ||||
@base | https://valospace.org/0# | |||
V:Chronicle.createPartitionURI | #Chronicle.createPartitionURI | @id | ||
V:Chronicle.createChronicleURI | #Chronicle.createChronicleURI | @id | ||
V:Chronicle.splitChronicleURI | #Chronicle.splitChronicleURI | @id | ||
V:Chronicle.tryPartitionConnection | #Chronicle.tryPartitionConnection | @id | ||
V:Chronicle.tryConnection | #Chronicle.tryConnection | @id | ||
V:Chronicle.acquirePartitionConnection | #Chronicle.acquirePartitionConnection | @id | ||
V:Chronicle.acquireConnection | #Chronicle.acquireConnection | @id | ||
V:Chronicle.sourcerChronicle | #Chronicle.sourcerChronicle | @id | ||
V:immediateContent | #immediateContent | @id | ||
V:interpretContent | #interpretContent | @id | ||
V:immediateURL | #immediateURL | @id | ||
V:getURL | #getURL | @id | ||
V:Relatable.getRelationsOf | #Relatable.getRelationsOf | @id | ||
V:Relatable.getIncomingRelationsOf | #Relatable.getIncomingRelationsOf | @id | ||
V:getRelations | #getRelations | @id | ||
V:getRelationTargets | #getRelationTargets | @id | ||
V:setRelations | #setRelations | @id | ||
V:getIncomingRelations | #getIncomingRelations | @id | ||
V:getIncomingRelationSources | #getIncomingRelationSources | @id | ||
V:setIncomingRelations | #setIncomingRelations | @id | ||
V:Resource.activate | #Resource.activate | @id | ||
V:Resource.isActive | #Resource.isActive | @id | ||
V:Resource.getFieldOf | #Resource.getFieldOf | @id | ||
V:Resource.setFieldOf | #Resource.setFieldOf | @id | ||
V:Resource.getOwnerOf | #Resource.getOwnerOf | @id | ||
V:Resource.setOwnerOf | #Resource.setOwnerOf | @id | ||
V:Resource.getActiveResource | #Resource.getActiveResource | @id | ||
V:Resource.tryActiveResource | #Resource.tryActiveResource | @id | ||
V:Resource.recombine | #Resource.recombine | @id | ||
V:Resource.destroy | #Resource.destroy | @id | ||
V:Resource.prototype.hasOwnProperty | #Resource.prototype.hasOwnProperty | @id | ||
V:getField | #getField | @id | ||
V:getFieldCoupling | #getFieldCoupling | @id | ||
V:setField | #setField | @id | ||
V:addToField | #addToField | @id | ||
V:removeFromField | #removeFromField | @id | ||
V:replaceWithinField | #replaceWithinField | @id | ||
V:setOwner | #setOwner | @id | ||
V:getEntity | #getEntity | @id | ||
V:getMedia | #getMedia | @id | ||
V:getFixedResource | #getFixedResource | @id | ||
V:getFixedEntity | #getFixedEntity | @id | ||
V:getFixedMedia | #getFixedMedia | @id | ||
V:getFixedRelation | #getFixedRelation | @id | ||
V:obtainFixedResource | #obtainFixedResource | @id | ||
V:instantiate | #instantiate | @id | ||
V:duplicate | #duplicate | @id | ||
V:prepareBlob | #prepareBlob | @id | ||
V:prepareBvob | #prepareBvob | @id | ||
V:Scope.createIdentifer | #Scope.createIdentifer | @id | ||
V:getProperty | #getProperty | @id | ||
V:getHostGlobal | #getHostGlobal | @id | ||
V:getFickleId | #getFickleId | @id | ||
V:createDerivedId | #createDerivedId | @id | ||
V:hasInterface | #hasInterface | @id | ||
V:chronicleRoot | #chronicleRoot | @id | ||
V:partition | #partition | @id | ||
V:container | #container | @id | ||
V:nodes | #nodes | @id | @list | |
V:directory | #directory | @id | ||
V:entries | #entries | @id | @list | |
V:parent | #parent | @id | ||
V:ownsEntity | #ownsEntity | @id | @list | |
V:folder | #folder | @id | ||
V:ownsMedia | #ownsMedia | @id | @list | |
V:content | #content | @id | ||
V:graph | #graph | @id | ||
V:ownsRelation | #ownsRelation | @id | @list | |
V:source | #source | @id | ||
V:hasOutRelation | #hasOutRelation | @id | @list | |
V:target | #target | @id | ||
V:hasInRelation | #hasInRelation | @id | @list | |
V:linkedSource | #linkedSource | @id | ||
V:linkedOutRelation | #linkedOutRelation | @id | @list | |
V:linkedTarget | #linkedTarget | @id | ||
V:linkedInRelation | #linkedInRelation | @id | @list | |
V:ownerSource | #ownerSource | @id | ||
V:ownsOutRelation | #ownsOutRelation | @id | @list | |
V:ownerTarget | #ownerTarget | @id | ||
V:ownsInRelation | #ownsInRelation | @id | @list | |
V:relations | #relations | @id | @list | |
V:outgoingRelations | #outgoingRelations | @id | @list | |
V:incomingRelations | #incomingRelations | @id | @list | |
V:vrid | #vrid | @id | @list | |
V:specializationOf | #specializationOf | @id | ||
V:hasSpecialization | #hasSpecialization | @id | ||
V:ownFields | #ownFields | @id | ||
V:prototypeOf | #prototypeOf | @id | ||
V:hasInstance | #hasInstance | @id | ||
V:ghostOf | #ghostOf | @id | ||
V:hasGhost | #hasGhost | @id | ||
V:materializedGhosts | #materializedGhosts | @id | ||
V:unnamedCouplings | #unnamedCouplings | @id | ||
V:ghostHost | #ghostHost | @id | ||
V:ghostOwner | #ghostOwner | @id | ||
V:ownsGhost | #ownsGhost | @id | ||
V:contentReferrers | #contentReferrers | @id | ||
V:owner | #owner | @id | ||
V:name | #name | @id | ||
V:hasPrototype | #hasPrototype | @id | ||
V:instanceOf | #instanceOf | @id | ||
V:ownlings | #ownlings | @id | @list | |
V:unnamedOwnlings | #unnamedOwnlings | @id | ||
V:prototypeAlias | #prototypeAlias | @id | ||
V:scope | #scope | @id | ||
V:value | #value | @id | ||
V:ownsProperty | #ownsProperty | @id | @list |