Extends
Methods
(async) attach(schemaName, stateIdOrFilteropt, filteropt) → {Promise.<SharedState>}
- Description:
Attach to an existing SharedState instance.
Alternative signatures:
stateManager.attach(schemaName)
stateManager.attach(schemaName, stateId)
stateManager.attach(schemaName, filter)
stateManager.attach(schemaName, stateId, filter)
- Source:
- Overrides:
Example
const state = await client.stateManager.attach('my-class');
Parameters:
Name | Type | Attributes | Default | Description |
---|---|---|---|---|
schemaName |
string | Name of the schema as given on registration |
||
stateIdOrFilter |
number | Array.<string> |
<optional> |
null
|
Id of the state to attach to. If |
filter |
Array.<string> |
<optional> |
null
|
List of parameters of interest in the
returned state. If set to |
Returns:
- Type
- Promise.<SharedState>
(async) create(schemaName, initValuesopt) → {Promise.<SharedState>}
- Description:
Create a SharedState instance from a registered schema.
- Source:
- Overrides:
Example
const state = await client.stateManager.create('my-class');
Parameters:
Name | Type | Attributes | Default | Description |
---|---|---|---|---|
schemaName |
string | Name of the schema as given on registration (cf. ServerStateManager) |
||
initValues |
Object.<string, any> |
<optional> |
{}
|
Default values for the state. |
Returns:
- Type
- Promise.<SharedState>
deleteSchema(schemaName)
- Description:
Delete a whole class of ShareState.
All SharedState instance that belong to this class are deleted as well, triggering the
onDetach
andonDelete
callbacks are called on the actual SharedState instances.In a future revision, this method and its arguments will be renamed
- Source:
Parameters:
Name | Type | Description |
---|---|---|
schemaName |
SharedStateClassName | Name of the schema. |
(async) getCollection(schemaName, filteropt, optionsopt) → {Promise.<SharedStateCollection>}
- Description:
Returns a collection of all the states created from the schema name.
Alternative signatures:
stateManager.getCollection(schemaName)
stateManager.getCollection(schemaName, filter)
stateManager.getCollection(schemaName, options)
stateManager.getCollection(schemaName, filter, options)
- Source:
- Overrides:
Example
const collection = await client.stateManager.getCollection(schemaName);
Parameters:
Name | Type | Attributes | Default | Description | ||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
schemaName |
string | Name of the schema. |
||||||||||||
filter |
array | null |
<optional> |
null
|
Filter parameter of interest for each
state of the collection. If set to |
||||||||||
options |
object |
<optional> |
{}
|
Options. Properties
|
Returns:
- Type
- Promise.<SharedStateCollection>
(async) getSchema(schemaName) → {SharedStateSchema}
- Description:
Return the schema from a given registered schema name
- Source:
- Overrides:
Example
const schema = await client.stateManager.getSchema('my-class');
Parameters:
Name | Type | Description |
---|---|---|
schemaName |
String | Name of the schema as given on registration (cf. ServerStateManager) |
Returns:
- Type
- SharedStateSchema
(async) observe(schemaNameopt, callback, options) → {Promise.<stateManagerDeleteObserveCallback>}
- Description:
Observe all the SharedState instances that are created on the network.
Notes:
- The order of execution is not guaranted between nodes, i.e. a state attached
in the
observe
callback can be instantiated before theasync create
method resolves on the creator node. - Filtering, i.e.
observedSchemaName
andoptions.excludeLocal
are handled on the node side, the server just notify all state creation activity and the node executes the given callbacks according to the different filter rules. Such strategy allows to simply share the observe notifications between all observers.
Alternative signatures:
stateManager.observe(callback)
stateManager.observe(schemaName, callback)
stateManager.observe(callback, options)
stateManager.observe(schemaName, callback, options)
- The order of execution is not guaranted between nodes, i.e. a state attached
in the
- Source:
- Overrides:
Example
client.stateManager.observe(async (schemaName, stateId) => {
if (schemaName === 'my-shared-state-class') {
const attached = await client.stateManager.attach(schemaName, stateId);
}
});
Parameters:
Name | Type | Attributes | Description | ||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|
schemaName |
string |
<optional> |
optionnal schema name to filter the observed states. |
||||||||||
callback |
stateManagerObserveCallback | Function to be called when a new state is created on the network. |
|||||||||||
options |
object | Options. Properties
|
Returns:
- Returns a Promise that resolves when the given callback as been executed on each existing states. The promise value is a function which allows to stop observing the states on the network.
- Type
- Promise.<stateManagerDeleteObserveCallback>
registerSchema(schemaName, schema)
- Description:
Define a class of data structure from which SharedState can be instanciated.
In a future revision, this method and its arguments will be renamed
- Source:
- See:
Example
server.stateManager.registerSchema('my-schema', {
myBoolean: {
type: 'boolean'
default: false,
},
myFloat: {
type: 'float'
default: 0.1,
min: -1,
max: 1
}
})
Parameters:
Name | Type | Description |
---|---|---|
schemaName |
SharedStateClassName | Name of the schema. |
schema |
SharedStateSchema | Data structure describing the states that will be created from this schema. |
registerUpdateHook(schemaName, updateHook) → {Fuction}
- Description:
Register a function for a given schema (e.g. will be applied on all states created from this schema) that will be executed before the update values are propagated. For example, this could be used to implement a preset system where all the values of the state are updated from e.g. some data stored in filesystem while the consumer of the state only want to update the preset name.
The hook is associated to every state of its kind (i.e. schemaName) and executed on every update (call of
set
). Note that the hooks are executed server-side regarless the node on whichset
has been called and before the "actual" update of the state (e.g. before the call ofonUpdate
).
- Source:
Example
server.stateManager.registerSchema('hooked', {
value: { type: 'string', default: null, nullable: true },
numUpdates: { type: 'integer', default: 0 },
});
server.stateManager.registerUpdateHook('hooked', updates => {
return {
...updates
numUpdates: currentValues.numUpdates + 1,
};
});
const state = await server.stateManager.create('hooked');
await state.set({ value: 'test' });
const values = state.getValues();
assert.deepEqual(result, { value: 'test', numUpdates: 1 });
Parameters:
Name | Type | Description |
---|---|---|
schemaName |
string | Kind of states on which applying the hook. |
updateHook |
serverStateManagerUpdateHook | Function
called between the |
Returns:
deleteHook - Handler that deletes the hook when executed.
- Type
- Fuction