rst to md
This commit is contained in:
parent
66356d8ff0
commit
845d25c2ff
|
|
@ -1,34 +1,30 @@
|
|||
Famille
|
||||
=======
|
||||
# Famille
|
||||
|
||||
Une famille
|
||||
-----------
|
||||
## Une famille
|
||||
|
||||
Une famille est un conteneur de variables.
|
||||
|
||||
Pour décrire une famille il faut mettre au minimum un nom :
|
||||
|
||||
<family name="my_family"/>
|
||||
```<family name="my_family"/>```
|
||||
|
||||
Cette famille doit être placé dans une balise "variables" :
|
||||
|
||||
<variables>
|
||||
```<variables>
|
||||
<family name="my_family"/>
|
||||
</variables>
|
||||
</variables>```
|
||||
|
||||
Description et aide sur la famille
|
||||
----------------------------------
|
||||
## Description et aide sur la famille
|
||||
|
||||
En plus d'un nom, il est possible de mettre une "description" à la famille. C'est une information "utilisateur" qui nous permettra d'avoir des informations complémentaires sur le contenu de cette famille :
|
||||
|
||||
<family name="my_family" description="This is a great family"/>
|
||||
```<family name="my_family" description="This is a great family"/>```
|
||||
|
||||
En plus de la description, il est possible de préciser une aide complémentaire :
|
||||
|
||||
<family name="my_family" help="This is a great family"/>
|
||||
```<family name="my_family" help="This is a great family"/>```
|
||||
|
||||
Mode de la famille
|
||||
------------------
|
||||
## Mode de la famille
|
||||
|
||||
Le mode par défaut d'une famille correspond au mode le plus petite des variables dans cette famille.
|
||||
|
||||
|
|
@ -36,10 +32,9 @@ Changer le mode d'une famille permet de définir le mode par défaut des variabl
|
|||
|
||||
Pour définir le mode :
|
||||
|
||||
<family name="my_family" mode="expert"/>
|
||||
```<family name="my_family" mode="expert"/>```
|
||||
|
||||
Cacher une famille
|
||||
------------------
|
||||
# Cacher une famille
|
||||
|
||||
Il est possible de cacher une famille, ainsi toutes les variables inclusent dans cette famille.
|
||||
|
||||
|
|
@ -48,25 +43,24 @@ Par contre ces variables sont accessibles lorsqu'on va utiliser ces variables.
|
|||
|
||||
Pour cacher une famille :
|
||||
|
||||
<family name="my_family" hidden="True"/>
|
||||
```<family name="my_family" hidden="True"/>```
|
||||
|
||||
Les familles crées dynamiquement
|
||||
--------------------------------
|
||||
## Les familles crées dynamiquement
|
||||
|
||||
Pour créer une famille crées dynamiquement, il faut créer une family fictive lié à une variable.
|
||||
Le nom et la description de la famille et des variables qu'elle contient sera en réalité le prefix du nouveau nom/description. Le suffix viendra de la variable liée.
|
||||
|
||||
Par exemple :
|
||||
|
||||
<family name='my_family'>
|
||||
```<family name='my_family'>
|
||||
<variable name='varname' multi="True">
|
||||
<value>val1</value>
|
||||
<value>val2</value>
|
||||
</variable>
|
||||
</family>
|
||||
<family name='my_dyn_family\_' dynamic="varname description="Describe "">
|
||||
</family>
|
||||
<family name='my_dyn_family\_' dynamic="varname description="Describe "">
|
||||
<variable name='my_dyn_var\_'/>
|
||||
</family>
|
||||
</family>```
|
||||
|
||||
Créera trois familles :
|
||||
|
||||
|
|
@ -0,0 +1,293 @@
|
|||
# Les variables calculées
|
||||
|
||||
Une variable calculée est une variable donc sa valeur est le résultat d'une fonction python.
|
||||
|
||||
## Variable avec une valeur par défaut calculée
|
||||
|
||||
Créons une variable dont la valeur est retournée par la fonction "return_no" :
|
||||
|
||||
```<variables>
|
||||
<family name="family">
|
||||
<variable name="my_calculated_variable"/>
|
||||
</family>
|
||||
</variables>
|
||||
<constraints>
|
||||
<fill name="return_no" target="my_calculated_variable"/>
|
||||
</constraints>```
|
||||
|
||||
Puis créons la fonction "return_no" :
|
||||
|
||||
```def return_no():
|
||||
return 'no'```
|
||||
|
||||
Dans ce cas, la valeur par défaut est la valeur retournée par la fonction (ici "no"), elle sera calculée tant que l'utilisateur n'a pas de spécifié une valeur à cette variable.
|
||||
|
||||
Si l'utilisateur à définit une valeur par défaut à "my_calculated_variable" :
|
||||
|
||||
```<variable name="my_calculated_variable">
|
||||
<value>yes</value>
|
||||
</variable>```
|
||||
|
||||
Cette valeur par défaut sera complètement ignorée.
|
||||
|
||||
## Variable avec une valeur calculée
|
||||
|
||||
En ajoutant le paramètre "hidden" à "True" dans la variable précédente, l'utilisateur n'aura plus la possibilité de modifié la valeur. La valeur de la variable sera donc systématiquement calculée :
|
||||
|
||||
```<variable name="my_calculated_variable" hidden="True"/>```
|
||||
|
||||
Si une condition "hidden_if_in" est spécifié à la variable, la valeur sera modifiable par l'utilisateur si elle n'est pas cachée mais elle sera systèmatiquement calculée (même si elle a déjà était modifiée) si la variable est cachée.
|
||||
|
||||
## Variable avec valeur calculée obligatoire
|
||||
|
||||
Par défaut les variables calculées ne sont pas des varibles obligatoires.
|
||||
Dans ce cas un calcul peut retourner None, mais surtout un utilisateur peut spécifier une valeur nulle à cette variable. Dans ce cas le calcul ne sera pas réalisé.
|
||||
|
||||
## Fonction avec une valeur fixe comme paramètre positionnel
|
||||
|
||||
Déclarons un calcul avec paramètre :
|
||||
|
||||
```<constraints>
|
||||
<fill name="return_value" target="my_calculated_variable">
|
||||
<param>no</param>
|
||||
</fill>
|
||||
</constraints>```
|
||||
|
||||
Créons la fonction correspondante :
|
||||
|
||||
```def return_value(value):
|
||||
return value```
|
||||
|
||||
La variable aura donc "no" comme valeur puisque le paramètre aura la valeur fixe "no".
|
||||
|
||||
## Paramètre nommée
|
||||
|
||||
Déclarons une contrainte avec un paramètre nommée :
|
||||
|
||||
```<constraints>
|
||||
<fill name="return_value" target="my_calculated_variable">
|
||||
<param name="valeur">no</param>
|
||||
</fill>
|
||||
</constraints>```
|
||||
|
||||
Dans ce cas la fonction return_value sera exécuté avec le paramètre nommé "valeur" dont sa valeur sera "no".
|
||||
|
||||
## Paramètre avec un nombre
|
||||
|
||||
Déclarons un calcul avec paramètre avec un nombre :
|
||||
|
||||
```<constraints>
|
||||
<fill name="return_value_with_number" target="my_calculated_variable">
|
||||
<param type="number">1</param>
|
||||
</fill>
|
||||
</constraints>```
|
||||
|
||||
Créons la fonction correspondante :
|
||||
|
||||
```def return_value_with_number(value):
|
||||
if value == 1:
|
||||
return 'no'
|
||||
return 'yes'```
|
||||
|
||||
La variable aura donc "no" comme valeur puisque le paramètre aura la valeur fixe "1".
|
||||
|
||||
## Paramètre dont la valeur est issue d'une autre variable
|
||||
|
||||
Créons deux variables avec une contrainte de type variable qui contient le nom de la variable dont sa valeur sera utilisé comme paramètre :
|
||||
|
||||
```<variables>
|
||||
<family name="family">
|
||||
<variable name="my_calculated_variable"/>
|
||||
<variable name="my_variable" type="number" description="My variable">
|
||||
<value>1</value>
|
||||
</variable>
|
||||
</family>
|
||||
</variables>
|
||||
<constraints>
|
||||
<fill name="return_value_with_number" target="my_calculated_variable">
|
||||
<param type="variable">my_variable</param>
|
||||
</fill>
|
||||
</constraints>```
|
||||
|
||||
Si l'utilisateur laisse la valeur 1 à "my_variable", la valeur par défault de la variable "my_calculated_variable" sera "no".
|
||||
Si la valeur de "my_variable" est différent de 1, la valeur par défaut de la variable "my_calculated_variable" sera "yes".
|
||||
|
||||
## Paramètre dont la valeur est issue d'une information de la configuration
|
||||
|
||||
Créons une variable et la contrainte :
|
||||
|
||||
```<variables>
|
||||
<family name="family">
|
||||
<variable name="my_calculated_variable" type="string" description="My calculated variable"/>
|
||||
</family>
|
||||
</variables>
|
||||
<constraints>
|
||||
<fill name="return_value" target="my_calculated_variable">
|
||||
<param type="information">server_name</param>
|
||||
</fill>
|
||||
</constraints>```
|
||||
|
||||
Dans ce cas, l'information de la configuration "server_name" sera utilisé comme valeur de la variable "my_calculated_variable".
|
||||
Si l'information n'existe pas, la paramètre aura la valeur "None".
|
||||
|
||||
## Paramètre avec variable potentiellement non existante
|
||||
|
||||
Suivant le contexte une variable peut exister ou ne pas exister.
|
||||
|
||||
Un paramètre de type "variable" peut être "optional" :
|
||||
|
||||
<variables>
|
||||
<family name="family">
|
||||
<variable name="my_calculated_variable"/>
|
||||
</family>
|
||||
</variables>
|
||||
<constraints>
|
||||
<fill name="return_value" target="my_calculated_variable">
|
||||
<param type="variable" optional="True">unknow_variable</param>
|
||||
</fill>
|
||||
</constraints>
|
||||
|
||||
Dans ce cas la fonction "return_value" est exécuté sans paramètre.
|
||||
|
||||
## Paramètre avec variable potentiellement désactivée
|
||||
|
||||
FIXME :
|
||||
|
||||
<!ATTLIST param notraisepropertyerror (True|False) "False">
|
||||
|
||||
Il n'y a pas spécialement de test !
|
||||
|
||||
## Les variables suiveuses
|
||||
|
||||
FIXME :
|
||||
|
||||
- tests/flattener_dicos/10leadership_append/00-base.xml
|
||||
- tests/flattener_dicos/10leadership_auto/00-base.xml
|
||||
- tests/flattener_dicos/10leadership_autoleader/00-base.xml
|
||||
- tests/flattener_dicos/10leadership_autoleader_expert/00-base.xml
|
||||
|
||||
## Les variables dynamiques
|
||||
|
||||
### Paramètre avec variable dynamique
|
||||
|
||||
Il est possible de faire un calcul avec comme paramètre une variable dynamique mais pour une suffix particulier :
|
||||
|
||||
```<variables>
|
||||
<family name='family'>
|
||||
<variable name='suffixes' type='string' description="Suffixes of dynamic family" multi="True">
|
||||
<value>val1</value>
|
||||
<value>val2</value>
|
||||
</variable>
|
||||
<variable name="my_calculated_variable" type="string" description="My calculated variable"/>
|
||||
</family>
|
||||
<family name='dyn' dynamic="suffixes">
|
||||
<variable name='vardyn' type='string' description="Dynamic variable">
|
||||
<value>val</value>
|
||||
</variable>
|
||||
</family>
|
||||
</variables>
|
||||
<constraints>
|
||||
<fill name="return_value" target="my_calculated_variable">
|
||||
<param type="variable">vardynval1</param>
|
||||
</fill>
|
||||
</constraints>```
|
||||
|
||||
Dans ce cas, valeur du paramètre de la fonction "return_value" sera la valeur de la variable "vardyn" avec le suffix "val1".
|
||||
|
||||
### Calcule d'une variable dynamique
|
||||
|
||||
Il est également possible de calculer une variable dynamique à partir d'une variable standard :
|
||||
|
||||
```<variables>
|
||||
<family name='family'>
|
||||
<variable name='suffixes' type='string' description="Suffixes of dynamic family" multi="True">
|
||||
<value>val1</value>
|
||||
<value>val2</value>
|
||||
</variable>
|
||||
<variable name="my_variable" type="string" description="My variable">
|
||||
<value>val</value>
|
||||
</variable>
|
||||
</family>
|
||||
<family name='dyn' dynamic="suffixes">
|
||||
<variable name="my_calculated_variable_dyn_" type="string" description="My calculated variable"/>
|
||||
<value>val</value>
|
||||
</variable>
|
||||
</family>
|
||||
</variables>
|
||||
<constraints>
|
||||
<fill name="return_value" target="my_calculated_variable_dyn_">
|
||||
<param type="variable">my_variable</param>
|
||||
</fill>
|
||||
</constraints>```
|
||||
|
||||
Dans ce cas, les variables dynamiques "my_calculated_variable_dyn_" seront calculés à partir de la valeur de la variable "my_variable".
|
||||
Que cela soit pour la variable "my_calculated_variable_dyn_val1" et "my_calculated_variable_dyn_val2".
|
||||
|
||||
Par contre, il n'est pas possible de faire un calcul pour une seule des deux variables issues de la variable dynamique.
|
||||
Si c'est ce que vous cherchez à faire, il faudra prévoir un traitement particulier dans votre fonction.
|
||||
|
||||
Dans ce cas, il faut explicitement demander la valeur du suffix dans la fonction :
|
||||
|
||||
```<constraints>
|
||||
<fill name="return_value_suffix" target="my_calculated_variable_dyn_">
|
||||
<param type="variable">my_variable</param>
|
||||
<param type="suffix"/>
|
||||
</fill>
|
||||
</constraints>```
|
||||
|
||||
Et ainsi faire un traitement spécifique pour ce suffix :
|
||||
|
||||
```def return_value_suffix(value, suffix):
|
||||
if suffix == 'val1':
|
||||
return value```
|
||||
|
||||
## Redéfinition des calcules
|
||||
|
||||
Dans un premier dictionnaire déclarons notre variable et notre calcule :
|
||||
|
||||
```<variables>
|
||||
<family name="family">
|
||||
<variable name="my_calculated_variable"/>
|
||||
</family>
|
||||
</variables>
|
||||
<constraints>
|
||||
<fill name="return_no" target="my_calculated_variable"/>
|
||||
</constraints>```
|
||||
|
||||
Dans un second dictionnaire il est possible de redéfinir le calcul :
|
||||
|
||||
```<variables>
|
||||
<family name="family">
|
||||
<variable name="my_calculated_variable" redefine="True"/>
|
||||
</family>
|
||||
</variables>
|
||||
<constraints>
|
||||
<fill name="return_yes" target="my_calculated_variable"/>
|
||||
</constraints>```
|
||||
|
||||
Dans ce cas, à aucun moment la fonction "return_no" ne sera exécuté. Seul la fonction "return_yes" le sera.
|
||||
|
||||
## Redéfinition avec suppression d'un calcul
|
||||
|
||||
Il se peut que dans un dictionnaire on décide de définir une valeur par défaut à une variable via un calcul.
|
||||
|
||||
Dans un second dictionnaire il est possible de supprimer ce calcul.
|
||||
|
||||
Dans un premier dictionnaire déclarons notre variable et notre calcule :
|
||||
|
||||
```<variables>
|
||||
<family name="family">
|
||||
<variable name="my_calculated_variable"/>
|
||||
</family>
|
||||
</variables>
|
||||
<constraints>
|
||||
<fill name="return_no" target="my_calculated_variable"/>
|
||||
</constraints>```
|
||||
|
||||
Dans un second dictionnaire supprimer ce calcul :
|
||||
|
||||
```<variables>
|
||||
<family name="family">
|
||||
<variable name="my_calculated_variable" redefine="True" remove_fill="True"/>
|
||||
</family>
|
||||
</variables>```
|
||||
310
doc/fill.rst
310
doc/fill.rst
|
|
@ -1,310 +0,0 @@
|
|||
Les variables calculées
|
||||
=======================
|
||||
|
||||
Une variable calculée est une variable donc sa valeur est le résultat d'une fonction python.
|
||||
|
||||
Variable avec une valeur par défaut calculée
|
||||
--------------------------------------------
|
||||
|
||||
Créons une variable dont la valeur est retournée par la fonction "return_no" :
|
||||
|
||||
<variables>
|
||||
<family name="family">
|
||||
<variable name="my_calculated_variable"/>
|
||||
</family>
|
||||
</variables>
|
||||
<constraints>
|
||||
<fill name="return_no" target="my_calculated_variable"/>
|
||||
</constraints>
|
||||
|
||||
Puis créons la fonction "return_no" :
|
||||
|
||||
def return_no():
|
||||
return 'no'
|
||||
|
||||
Dans ce cas, la valeur par défaut est la valeur retournée par la fonction (ici "no"), elle sera calculée tant que l'utilisateur n'a pas de spécifié une valeur à cette variable.
|
||||
|
||||
Si l'utilisateur à définit une valeur par défaut à "my_calculated_variable" :
|
||||
|
||||
<variable name="my_calculated_variable">
|
||||
<value>yes</value>
|
||||
</variable>
|
||||
|
||||
Cette valeur par défaut sera complètement ignorée.
|
||||
|
||||
Variable avec une valeur calculée
|
||||
---------------------------------
|
||||
|
||||
En ajoutant le paramètre "hidden" à "True" dans la variable précédente, l'utilisateur n'aura plus la possibilité de modifié la valeur. La valeur de la variable sera donc systématiquement calculée :
|
||||
|
||||
<variable name="my_calculated_variable" hidden="True"/>
|
||||
|
||||
Si une condition "hidden_if_in" est spécifié à la variable, la valeur sera modifiable par l'utilisateur si elle n'est pas cachée mais elle sera systèmatiquement calculée (même si elle a déjà était modifiée) si la variable est cachée.
|
||||
|
||||
Variable avec valeur calculée obligatoire
|
||||
-----------------------------------------
|
||||
|
||||
Par défaut les variables calculées ne sont pas des varibles obligatoires.
|
||||
Dans ce cas un calcul peut retourner None, mais surtout un utilisateur peut spécifier une valeur nulle à cette variable. Dans ce cas le calcul ne sera pas réalisé.
|
||||
|
||||
Fonction avec une valeur fixe comme paramètre positionnel
|
||||
---------------------------------------------------------
|
||||
|
||||
Déclarons un calcul avec paramètre :
|
||||
|
||||
<constraints>
|
||||
<fill name="return_value" target="my_calculated_variable">
|
||||
<param>no</param>
|
||||
</fill>
|
||||
</constraints>
|
||||
|
||||
Créons la fonction correspondante :
|
||||
|
||||
def return_value(value):
|
||||
return value
|
||||
|
||||
La variable aura donc "no" comme valeur puisque le paramètre aura la valeur fixe "no".
|
||||
|
||||
Paramètre nommée
|
||||
----------------
|
||||
|
||||
Déclarons une contrainte avec un paramètre nommée :
|
||||
|
||||
<constraints>
|
||||
<fill name="return_value" target="my_calculated_variable">
|
||||
<param name="valeur">no</param>
|
||||
</fill>
|
||||
</constraints>
|
||||
|
||||
Dans ce cas la fonction return_value sera exécuté avec le paramètre nommé "valeur" dont sa valeur sera "no".
|
||||
|
||||
Paramètre avec un nombre
|
||||
------------------------
|
||||
|
||||
Déclarons un calcul avec paramètre avec un nombre :
|
||||
|
||||
<constraints>
|
||||
<fill name="return_value_with_number" target="my_calculated_variable">
|
||||
<param type="number">1</param>
|
||||
</fill>
|
||||
</constraints>
|
||||
|
||||
Créons la fonction correspondante :
|
||||
|
||||
def return_value_with_number(value):
|
||||
if value == 1:
|
||||
return 'no'
|
||||
return 'yes'
|
||||
|
||||
La variable aura donc "no" comme valeur puisque le paramètre aura la valeur fixe "1".
|
||||
|
||||
Paramètre dont la valeur est issue d'une autre variable
|
||||
-------------------------------------------------------
|
||||
|
||||
Créons deux variables avec une contrainte de type variable qui contient le nom de la variable dont sa valeur sera utilisé comme paramètre :
|
||||
|
||||
<variables>
|
||||
<family name="family">
|
||||
<variable name="my_calculated_variable"/>
|
||||
<variable name="my_variable" type="number" description="My variable">
|
||||
<value>1</value>
|
||||
</variable>
|
||||
</family>
|
||||
</variables>
|
||||
<constraints>
|
||||
<fill name="return_value_with_number" target="my_calculated_variable">
|
||||
<param type="variable">my_variable</param>
|
||||
</fill>
|
||||
</constraints>
|
||||
|
||||
Si l'utilisateur laisse la valeur 1 à "my_variable", la valeur par défault de la variable "my_calculated_variable" sera "no".
|
||||
Si la valeur de "my_variable" est différent de 1, la valeur par défaut de la variable "my_calculated_variable" sera "yes".
|
||||
|
||||
Paramètre dont la valeur est issue d'une information de la configuration
|
||||
------------------------------------------------------------------------
|
||||
|
||||
Créons une variable et la contrainte :
|
||||
|
||||
<variables>
|
||||
<family name="family">
|
||||
<variable name="my_calculated_variable" type="string" description="My calculated variable"/>
|
||||
</family>
|
||||
</variables>
|
||||
<constraints>
|
||||
<fill name="return_value" target="my_calculated_variable">
|
||||
<param type="information">server_name</param>
|
||||
</fill>
|
||||
</constraints>
|
||||
|
||||
Dans ce cas, l'information de la configuration "server_name" sera utilisé comme valeur de la variable "my_calculated_variable".
|
||||
Si l'information n'existe pas, la paramètre aura la valeur "None".
|
||||
|
||||
Paramètre avec variable potentiellement non existante
|
||||
-----------------------------------------------------
|
||||
|
||||
Suivant le contexte une variable peut exister ou ne pas exister.
|
||||
|
||||
Un paramètre de type "variable" peut être "optional" :
|
||||
|
||||
<variables>
|
||||
<family name="family">
|
||||
<variable name="my_calculated_variable"/>
|
||||
</family>
|
||||
</variables>
|
||||
<constraints>
|
||||
<fill name="return_value" target="my_calculated_variable">
|
||||
<param type="variable" optional="True">unknow_variable</param>
|
||||
</fill>
|
||||
</constraints>
|
||||
|
||||
Dans ce cas la fonction "return_value" est exécuté sans paramètre.
|
||||
|
||||
Paramètre avec variable potentiellement désactivée
|
||||
--------------------------------------------------
|
||||
|
||||
FIXME :
|
||||
|
||||
<!ATTLIST param notraisepropertyerror (True|False) "False">
|
||||
|
||||
Il n'y a pas spécialement de test !
|
||||
|
||||
Les variables suiveuses
|
||||
-----------------------
|
||||
|
||||
FIXME :
|
||||
|
||||
- tests/flattener_dicos/10leadership_append/00-base.xml
|
||||
- tests/flattener_dicos/10leadership_auto/00-base.xml
|
||||
- tests/flattener_dicos/10leadership_autoleader/00-base.xml
|
||||
- tests/flattener_dicos/10leadership_autoleader_expert/00-base.xml
|
||||
|
||||
Les variables dynamiques
|
||||
------------------------
|
||||
|
||||
Paramètre avec variable dynamique
|
||||
'''''''''''''''''''''''''''''''''
|
||||
|
||||
Il est possible de faire un calcul avec comme paramètre une variable dynamique mais pour une suffix particulier :
|
||||
|
||||
<variables>
|
||||
<family name='family'>
|
||||
<variable name='suffixes' type='string' description="Suffixes of dynamic family" multi="True">
|
||||
<value>val1</value>
|
||||
<value>val2</value>
|
||||
</variable>
|
||||
<variable name="my_calculated_variable" type="string" description="My calculated variable"/>
|
||||
</family>
|
||||
<family name='dyn' dynamic="suffixes">
|
||||
<variable name='vardyn' type='string' description="Dynamic variable">
|
||||
<value>val</value>
|
||||
</variable>
|
||||
</family>
|
||||
</variables>
|
||||
<constraints>
|
||||
<fill name="return_value" target="my_calculated_variable">
|
||||
<param type="variable">vardynval1</param>
|
||||
</fill>
|
||||
</constraints>
|
||||
|
||||
Dans ce cas, valeur du paramètre de la fonction "return_value" sera la valeur de la variable "vardyn" avec le suffix "val1".
|
||||
|
||||
Calcule d'une variable dynamique
|
||||
''''''''''''''''''''''''''''''''
|
||||
|
||||
Il est également possible de calculer une variable dynamique à partir d'une variable standard :
|
||||
|
||||
<variables>
|
||||
<family name='family'>
|
||||
<variable name='suffixes' type='string' description="Suffixes of dynamic family" multi="True">
|
||||
<value>val1</value>
|
||||
<value>val2</value>
|
||||
</variable>
|
||||
<variable name="my_variable" type="string" description="My variable">
|
||||
<value>val</value>
|
||||
</variable>
|
||||
</family>
|
||||
<family name='dyn' dynamic="suffixes">
|
||||
<variable name="my_calculated_variable_dyn_" type="string" description="My calculated variable"/>
|
||||
<value>val</value>
|
||||
</variable>
|
||||
</family>
|
||||
</variables>
|
||||
<constraints>
|
||||
<fill name="return_value" target="my_calculated_variable_dyn_">
|
||||
<param type="variable">my_variable</param>
|
||||
</fill>
|
||||
</constraints>
|
||||
|
||||
Dans ce cas, les variables dynamiques "my_calculated_variable_dyn_" seront calculés à partir de la valeur de la variable "my_variable".
|
||||
Que cela soit pour la variable "my_calculated_variable_dyn_val1" et "my_calculated_variable_dyn_val2".
|
||||
|
||||
Par contre, il n'est pas possible de faire un calcul pour une seule des deux variables issues de la variable dynamique.
|
||||
Si c'est ce que vous cherchez à faire, il faudra prévoir un traitement particulier dans votre fonction.
|
||||
|
||||
Dans ce cas, il faut explicitement demander la valeur du suffix dans la fonction :
|
||||
|
||||
<constraints>
|
||||
<fill name="return_value_suffix" target="my_calculated_variable_dyn_">
|
||||
<param type="variable">my_variable</param>
|
||||
<param type="suffix"/>
|
||||
</fill>
|
||||
</constraints>
|
||||
|
||||
Et ainsi faire un traitement spécifique pour ce suffix :
|
||||
|
||||
def return_value_suffix(value, suffix):
|
||||
if suffix == 'val1':
|
||||
return value
|
||||
|
||||
Redéfinition des calcules
|
||||
-------------------------
|
||||
|
||||
Dans un premier dictionnaire déclarons notre variable et notre calcule :
|
||||
|
||||
<variables>
|
||||
<family name="family">
|
||||
<variable name="my_calculated_variable"/>
|
||||
</family>
|
||||
</variables>
|
||||
<constraints>
|
||||
<fill name="return_no" target="my_calculated_variable"/>
|
||||
</constraints>
|
||||
|
||||
Dans un second dictionnaire il est possible de redéfinir le calcul :
|
||||
|
||||
<variables>
|
||||
<family name="family">
|
||||
<variable name="my_calculated_variable" redefine="True"/>
|
||||
</family>
|
||||
</variables>
|
||||
<constraints>
|
||||
<fill name="return_yes" target="my_calculated_variable"/>
|
||||
</constraints>
|
||||
|
||||
Dans ce cas, à aucun moment la fonction "return_no" ne sera exécuté. Seul la fonction "return_yes" le sera.
|
||||
|
||||
Redéfinition avec suppression d'un calcul
|
||||
-----------------------------------------
|
||||
|
||||
Il se peut que dans un dictionnaire on décide de définir une valeur par défaut à une variable via un calcul.
|
||||
|
||||
Dans un second dictionnaire il est possible de supprimer ce calcul.
|
||||
|
||||
Dans un premier dictionnaire déclarons notre variable et notre calcule :
|
||||
|
||||
<variables>
|
||||
<family name="family">
|
||||
<variable name="my_calculated_variable"/>
|
||||
</family>
|
||||
</variables>
|
||||
<constraints>
|
||||
<fill name="return_no" target="my_calculated_variable"/>
|
||||
</constraints>
|
||||
|
||||
Dans un second dictionnaire supprimer ce calcul :
|
||||
|
||||
<variables>
|
||||
<family name="family">
|
||||
<variable name="my_calculated_variable" redefine="True" remove_fill="True"/>
|
||||
</family>
|
||||
</variables>
|
||||
|
|
@ -0,0 +1,12 @@
|
|||
# Rougail
|
||||
|
||||
## Les variables
|
||||
|
||||
- [Le conteneur des variables](variables.md)
|
||||
- [Les familles](family.md)
|
||||
- [Les variables](variable.md)
|
||||
- [Les modes](mode.md)
|
||||
|
||||
## Les contraintes
|
||||
|
||||
- [Les calcules automatiques](fill.md)
|
||||
|
|
@ -1,17 +1,14 @@
|
|||
Variable
|
||||
========
|
||||
# Variable
|
||||
|
||||
Un variable
|
||||
-----------
|
||||
## Un variable
|
||||
|
||||
Une variable est forcement dans une famille. Il faut donc déjà avoir créer une famille.
|
||||
|
||||
Une variable est déjà un nom. C'est à dire qu'on pourra utiliser plus tard la variable via ce nom.
|
||||
|
||||
<variable name="my_variable"/>
|
||||
```<variable name="my_variable"/>```
|
||||
|
||||
Description et aide sur la variable
|
||||
----------------------------------
|
||||
## Description et aide sur la variable
|
||||
|
||||
En plus d'un nom, il est possible de mettre une "description" à la variable. C'est une information "utilisateur" qui nous permettra d'avoir des informations complémentaires sur le contenu de cette variable :
|
||||
|
||||
|
|
@ -21,8 +18,7 @@ En plus de la description, il est possible de préciser une aide complémentaire
|
|||
|
||||
<variable name="my_variable" help="This is a greate variable"/>
|
||||
|
||||
Le type de la variable
|
||||
----------------------
|
||||
## Le type de la variable
|
||||
|
||||
Une variable a un type. Ce type permet de définir les valeurs acceptées par cette variable :
|
||||
|
||||
|
|
@ -53,28 +49,25 @@ Une variable a un type. Ce type permet de définir les valeurs acceptées par ce
|
|||
|
||||
Pour définir le type d'une variable :
|
||||
|
||||
<variable name="my_variable" type="number"/>
|
||||
```<variable name="my_variable" type="number"/>```
|
||||
|
||||
Variable à valeur multiple
|
||||
--------------------------
|
||||
## Variable à valeur multiple
|
||||
|
||||
Par défaut une variable ne peut acceuillir qu'une seule valeur. Il peut être utile de pouvoir spécifier plusieurs valeurs à une même variable.
|
||||
|
||||
Pour définir une variable à valeur multiple :
|
||||
|
||||
<variable name="my_variable" multi="True"/>
|
||||
```<variable name="my_variable" multi="True"/>```
|
||||
|
||||
Mode de la variable
|
||||
-------------------
|
||||
## Mode de la variable
|
||||
|
||||
Le mode par défaut d'une variable correspond au mode de la famille.
|
||||
|
||||
Pour définir le mode :
|
||||
|
||||
<variable name="my_variable" mode="expert"/>
|
||||
```<variable name="my_variable" mode="expert"/>```
|
||||
|
||||
Cacher une variable
|
||||
-------------------
|
||||
## Cacher une variable
|
||||
|
||||
Il est possible de cacher une variable.
|
||||
|
||||
|
|
@ -83,10 +76,9 @@ Par contre cette variable sont accessibles lorsqu'on va l'utiliser.
|
|||
|
||||
Pour cacher une variable :
|
||||
|
||||
<variable name="my_variable" hidden="True"/>
|
||||
```<variable name="my_variable" hidden="True"/>```
|
||||
|
||||
Désactiver une variable
|
||||
-----------------------
|
||||
## Désactiver une variable
|
||||
|
||||
Il est possible de désactiver une variable.
|
||||
|
||||
|
|
@ -94,35 +86,32 @@ Désactiver une variable signifie qu'elle ne sera pas visible lorsqu'on modifie
|
|||
|
||||
Pour désactiver une variable :
|
||||
|
||||
<variable name="my_variable" disabled="True"/>
|
||||
```<variable name="my_variable" disabled="True"/>```
|
||||
|
||||
Variable obligatoire
|
||||
--------------------
|
||||
## Variable obligatoire
|
||||
|
||||
Variable dont une valeur est requise :
|
||||
|
||||
<variable name="my_variable" mandatory="True"/>
|
||||
```<variable name="my_variable" mandatory="True"/>```
|
||||
|
||||
Valeur par défaut d'une variable
|
||||
--------------------------------
|
||||
## Valeur par défaut d'une variable
|
||||
|
||||
Il est possible de fixer les valeurs par défaut d'une variable :
|
||||
|
||||
<variable name="my_variable">
|
||||
```<variable name="my_variable">
|
||||
<value>value</value>
|
||||
</variable>
|
||||
</variable>```
|
||||
|
||||
Pour une variable multiple, il est possible de préciser plusieurs valeurs :
|
||||
|
||||
<variable name="my_variable" multi="True">
|
||||
```<variable name="my_variable" multi="True">
|
||||
<value>value 1</value>
|
||||
<value>value 2</value>
|
||||
</variable>
|
||||
</variable>```
|
||||
|
||||
Une valeur par défaut peut également être `une valeur calculer <fill.rst>`.
|
||||
|
||||
Redéfinir une variable
|
||||
----------------------
|
||||
## Redéfinir une variable
|
||||
|
||||
Il est possible de définir une variable dans un dictionnaire et de changer son comportement dans une second dictionnaire.
|
||||
|
||||
|
|
@ -138,48 +127,44 @@ Créons notre variable :
|
|||
|
||||
Et redéfinisons là :
|
||||
|
||||
<variable name="my_variable" redefine="True" description="New description"/>
|
||||
```<variable name="my_variable" redefine="True" description="New description"/>```
|
||||
|
||||
Créer une variable inexistante
|
||||
------------------------------
|
||||
## Créer une variable inexistante
|
||||
|
||||
Il est parfois utile de créer une variable si elle n'existe pas dans un autre dictionnaire :
|
||||
|
||||
<variable name="my_variable" exists="False"/>
|
||||
```<variable name="my_variable" exists="False"/>```
|
||||
|
||||
Si cette variable existe dans un autre dictionnaire, elle ne sera pas modifier ni recréé
|
||||
|
||||
Redéfinir une variable si elle existe
|
||||
-------------------------------------
|
||||
## Redéfinir une variable si elle existe
|
||||
|
||||
Parfois on veut pouvoir redéfinir une variable mais seulement dans le cas où elle existe déjà :
|
||||
|
||||
<variable name="my_variable" redefine="True" exists="True" hidden="True"/>
|
||||
```<variable name="my_variable" redefine="True" exists="True" hidden="True"/>```
|
||||
|
||||
Variable à valeur automatiquement modifiée
|
||||
------------------------------------------
|
||||
## Variable à valeur automatiquement modifiée
|
||||
|
||||
Une variable avec valeur automatiquement modifiée est une variable dont la valeur sera considéré comme modifié quand le serveur sera déployé.
|
||||
|
||||
Voici une variable a valeur automatiquement modifiée :
|
||||
|
||||
<variable name="my_variable" auto_save="True">
|
||||
```<variable name="my_variable" auto_save="True">
|
||||
<value>my_value</value>
|
||||
</variable>
|
||||
</variable>```
|
||||
|
||||
Dans ce cas la valeur est fixée à la valeur actuelle.
|
||||
Par exemple, si la valeur de cette variable est issue d'un calcul, la valeur ne sera plus recalculée.
|
||||
|
||||
Ces variables sont généralement des variables obligatoires. En effet ces variable ne sont automatiquement modifiées que si elles sont une valeurs.
|
||||
|
||||
Variable à valeur en lecture seule automatique
|
||||
----------------------------------------------
|
||||
## Variable à valeur en lecture seule automatique
|
||||
|
||||
Une variable avec valeur en lecture seule automatique est une variable dont la valeur ne sera plus modifiable par l'utilisateur quand le serveur sera déployé.
|
||||
|
||||
Voici un variable à valeur en lecture seule automatique :
|
||||
|
||||
<variable name="my_variable" auto_freeze="True"/>
|
||||
```<variable name="my_variable" auto_freeze="True"/>```
|
||||
|
||||
Dans ce cas la valeur est fixée à la valeur actuelle et elle ne sera plus modifiable par l'utilisateur.
|
||||
Par exemple, si la valeur de cette variable est issue d'un calcul, la valeur ne sera plus recalculée.
|
||||
|
|
@ -0,0 +1,9 @@
|
|||
# Le conteneur des variables Variables
|
||||
|
||||
La balise variable est le conteneur de l'ensemble des familles dans laquelle on pourra placer des variables :
|
||||
|
||||
```<?xml version='1.0' encoding='UTF-8'?>
|
||||
<rougail>
|
||||
<variables/>
|
||||
</rougail>
|
||||
```
|
||||
|
|
@ -1,9 +0,0 @@
|
|||
Variables
|
||||
=========
|
||||
|
||||
La balise variable est le conteneur de l'ensemble des familles dans laquelle on pourra placer des variables :
|
||||
|
||||
<?xml version='1.0' encoding='UTF-8'?>
|
||||
<rougail>
|
||||
<variables/>
|
||||
</rougail>
|
||||
Loading…
Reference in New Issue