103 lines
3.7 KiB
Text
103 lines
3.7 KiB
Text
.. default-role:: literal
|
|
|
|
.. currentmodule:: tiramisu
|
|
|
|
The global consistency
|
|
===========================
|
|
|
|
Identical option names
|
|
----------------------
|
|
|
|
If an :class:`~option.Option()` happens to be defined twice in the
|
|
:term:`schema` (e.g. the :class:`~option.OptionDescription()`),
|
|
that is the two options actually have the same name, an exception is raised.
|
|
|
|
The calculation is currently carried out in the samespace, for example
|
|
if `config.gc.name` is defined, another option in `gc` with the name
|
|
`name` is **not** allowed, whereas `config.whateverelse.name` is still
|
|
allowed.
|
|
|
|
Option's values type validation
|
|
--------------------------------
|
|
|
|
When a value is set to the option, the value is validated by the
|
|
option's :class:`option.Option()` validator's type.
|
|
|
|
Notice that if the option is `multi`, that is the `multi` attribute is set to
|
|
`True`, then the validation of the option value accepts a list of values
|
|
of the same type.
|
|
|
|
For example, an :class:`option.IntOption` validator waits for an `int` object of
|
|
course, an :class:`option.StrOption` validator waits for an `str`, vs...
|
|
|
|
|
|
Where are located the values
|
|
-------------------------------
|
|
|
|
The entry point of the acces to the values is the :class:`setting.Setting()` of
|
|
the root configuration object, but the values are actually located in the
|
|
:class:`value.Values()` object, in order to be delegated in some kind of a
|
|
`tiramisu.storage`, which can be a in-memory storage, or a persistent (for the
|
|
time being, a sqlite3) storage.
|
|
|
|
:class:`value.Values()` is also responsible of the owners and the calculation
|
|
of the options that have callbacks.
|
|
|
|
Requirements
|
|
------------
|
|
|
|
Configuration options can specify requirements as parameters at the init
|
|
time, the specification of some links between options or groups allows
|
|
to carry out a dependencies calculation. For example, an option can ben
|
|
hidden if another option has been set with some expected value. This is
|
|
just an example, because the possibilities are hudge.
|
|
|
|
A requirement is specified using a list of triplets. The first element
|
|
of the triplet gives the path of the option that is required, the second
|
|
element is the value wich is expected to trigger the callback, and the
|
|
third one is the callback's action name (`hide`, `show`...)::
|
|
|
|
stroption = StrOption('str', 'Test string option', default="abc",
|
|
requires=[('int', 1, 'hide')])
|
|
|
|
Requirements are validated in :class:`setting.Setting`.
|
|
|
|
Validation upon a whole configuration object
|
|
----------------------------------------------
|
|
|
|
An option's integrity can be validated towards a whole configuration.
|
|
|
|
This type of validation is very open. Let's take a use case : an option
|
|
has a certain value, and the value of this option can change the owner
|
|
of another option or option group... Everything is possible.
|
|
|
|
.. currentmodule:: tiramisu.option
|
|
|
|
Other hooks are availables to validate upon a whole configuration at any time,
|
|
for example the consistency between two options (typically, an
|
|
:class:`IPOption` and a :class:`NetworkOption`).
|
|
|
|
Values that are calculated
|
|
--------------------------------
|
|
|
|
An option that have a callback is considered to have a value that is to be
|
|
calculated.
|
|
|
|
An option's property with a `force_store_value` attribute is considered to be
|
|
modified at the first calculation.
|
|
|
|
.. automodule:: tiramisu.autolib
|
|
:members:
|
|
|
|
This is the typically protocol for accessing a option's for a calculated value,
|
|
but some twisted ways are also possible, take a look at the `force_store_value`
|
|
attribute.
|
|
|
|
.. glossary::
|
|
|
|
force store value
|
|
|
|
A calculated value (that is, an option that has a callback) with the
|
|
attribute `force_store_value` enabled is considered to be modified at
|
|
the first calculation
|
|
|