User Guide    ▶    Language Structure
"do:IT" est un langage basé sur la notation JSON
et compilé en objets élémentaires exécutables


Contraitement à la majorité des 'Flow-based Programming',
les descriptions "do:IT" ne nécessitent pas de génération de code cible, elles sont exécutables en l'état.
D'où son double aspect Descriptif et Instructif.



{ "flw:print" : "Hello World !" }










Description :

Il y a 5 types d'instruction :
  l'instruction d'affichage 'print', qui est en 'JSON:OBJECT',
  le bloc d'instruction, 'block', qui est en 'JSON:ARRAY',
  la section d'instruction 'do', qui est en 'JSON:OBJECT',
  l'instruction principale de Flow-based Programming, 'flow', qui est en 'JSON:OBJECT'
  et le module embarqué 'inline_module', qui est aussi en 'JSON:OBJECT'.

"do:IT" étant basé sur JSON, en instruction, seuls les 'JSON:OBJECT' et 'JSON:ARRAY' qui sont actifs mais les autres types ('JSON:SIMPLE' : String, Number, Boolean et NULL) sont considérés comme du 'nothing' ou 'No Operation'.



Description :

L'instruction flw:print , sous forme de 'JSON:OBJECT', est un flow simplifié qui permet d'afficher une ou des valeurs (en tableau).

L'option new:line permet d'afficher à la ligne chaque valeur d'un tableau ( sa valeur par défaut est true ).
Exemples :






Description :

Les instructions peuvent être mises en série sous forme de bloc 'JSON:ARRAY'.
Exemple :




Description :

L'instruction do est la forme enrichie en 'JSON:OBJECT' de l'instruction block.

Elle comporte une section with , pour le contexte des variables locales.

La section ctx permet de préciser un gestionnaire de contexte ou 'Context Hanlder'.
Exemple :




Description :

L'instruction flow est la première forme Flow-based de "do:IT" qui est en 'JSON:OBJECT'.

Toutes les instructions sont représentées en flow ou en let .
Exemple :




Le module 'inline', en 'JSON:OBJECT', est une sorte de module embarqué avec la clé flw:result .
Le module 'inline' est à la fois un FLOW (en tant qu'INSTRUCTION) et une EVALUATION (en tant que VALUE).



Les instructions sous forme de 'JSON:SIMPLE' sont inactives (NOP : No Operation) et peuvent faire office de commentaire dans les instructions.


Description :

Il y a 3 catégories de valeurs basées sur JSON :
  les valeurs simples basées sur 'JSON:SIMPLE',
  les séquences, les collections ou les tableaux de valeur en 'JSON:ARRAY',
  et les valeurs structurées basées sur 'JSON:OBJECT'.

Les valeurs simples sont représentées directement par les valeurs en 'JSON:SIMPLE' :
  'JSON:STRING' (en tant que String),
  'JSON:NUMBER' (en tant que Number),
  'JSON:BOOLEAN' (en tant que Boolean)
  et 'JSON:NULL' (en tant que valeur NULL).


Les valeurs en 'JSON:ARRAY' représentent les sequences de valeur, 'sequence_value' :
  en tant que Array ou tableau de valeur,
  ou List de valeur,
  ou Set de valeur,
  ou Iterator ou itération de valeur.


Les valeurs en 'JSON:OBJECT' varient suivant leur mot clé :
  les références de valeur, 'ref_value', si la structure dispose du mot clé 'ref',
  les valeurs typées, 'typed_value', si la structure dispose du mot clé 'is',
  l'évaluation par module, 'evaluation', si la structure dispose du mot clé 'as',
  l'évaluation 'inline_module', si la structure dispose du mot clé 'flw:result',
  ou sinon la structure est considérée comme une valeur structurée quelconque 'structure_value'.



Description :

Les valeurs simples, non structurées en JSON, représentent seulement les types classiques 'JSON:STRING' (en tant que String), 'JSON:NUMBER' (en tant que nombre Integer) et 'JSON:BOOLEAN' (en tant que Boolean). La valeur 'NULL' est représentée par la valeur 'JSON:NULL'.
Pour les valeurs d'autre type, il faudra l'expréssion typée, 'typed_value'.
Exemple :




Description :

Les séquences de valeurs en 'JSON:ARRAY' représentent par défaut des tableaux (de type Array). Par trans-typage, il est possible de les manipuler en tant que List ou Set ou Iterator (itération d'objet).
Exemple :




Description :

Les références de valeur en 'JSON:OBJECT' ( avec le mot clé ref ) représentent les objets gérés par context (Context Handler).
Exemple :




Description :

Les valeurs typées en 'JSON:OBJECT' ( avec le mot clé is ) permettent de forcer le type d'une valeur et aussi de faire le trans-typage.

Le type peut être :
type simple (ex : BOOLEAN, INT, STRING, TEXT, DATE, ...),
type référencé en modèle (ex : PERSON, ACTOR, ...),
type Java importé en tant que OBJECT ou ENUM.

Les valeurs peuvent être précisées :
  • par valeur directe : avec le mot clé value ,
  • ou par référence : avec le mot clé ref ,
  • ou par construction avec les attributs, pour les OBJECT ou ENUM : avec le mot clé with .

  • Le trans-typage peut être formaté grâce au mot clé format (ex : pour les types DATE, TIMESTAMP, BOOLEAN, ...).
    Exemple :




    Description :

    L'évaluation est une forme de Flow-based de "do:IT" avec le mot clé as au lieu de 'flow'. Elle retourne une valeur contrairement à 'flow'.

    Par comparaison :
  • flow est comme une procédure (void),
  • et as est comme une fonction (typée).
  • Exemple :




    Le module 'inline', en 'JSON:OBJECT', est une sorte de module embarqué avec la clé flw:result .
    Le module 'inline' est à la fois un FLOW (en tant qu'INSTRUCTION) et une EVALUATION (en tant que VALUE).



    Sans spécicité, la structure 'JSON:OBJECT' est considérée comme une MAP de clé/valeur.



    Description :

    L'usage de type est nécessaire lors d'une déclaration de contexte :
      Paramètre (préfixe 'par') de fonction (OBJECT ou ENUM), d'évaluation (as) ou de procédure (flow),
      Variable locale (préfixe 'var') avec le mot clé with,
      Variable globale (préfixe 'ctx') avec le mot clé with au niveau principal,
      Ressource (préfixe 'res') avec la section resources.

    En "do:IT" , la déclaration de type permet d'activer le transtypage automatique lors d'une affectation en utilisant le flow "SET" (contrairement au flow "RE:SET" qui permet de changer le type cible).

    Type JSON
    expression
    Java
    type(s)
    Description
    BOOLEAN "BOOLEAN" boolean,
    java.lang.Boolean
    C'est le type booléen.
    Il supporte le format,
    ex : Oui|Non|(flou) représentant respectivement les valeurs true , false , null
    CHAR "CHAR" char,
    java.lang.Character
    C'est le type caractère équivalent au type char en Java.
    Il supporte le format Java.
    BYTE "BYTE" byte,
    java.lang.Byte
    C'est le type numérique entier équivalent au type byte en Java.
    Il supporte le format Java.
    SHORT "SHORT" short,
    java.lang.Short
    C'est le type numérique entier équivalent au type short en Java.
    Il supporte le format Java.
    INT "INT" int,
    java.lang.Integer
    C'est le type numérique entier équivalent au type int en Java.
    Il supporte le format Java.
    LONG "LONG" long,
    java.lang.Long
    C'est le type numérique entier équivalent au type long en Java.
    Il supporte le format Java.
    FLOAT "FLOAT" float,
    java.lang.Float
    C'est le type numérique décimal (simple précision) équivalent au type float en Java.
    Il supporte le format Java.
    DOUBLE "DOUBLE" double,
    java.lang.Double
    C'est le type numérique décimal (double précision) équivalent au type double en Java.
    Il supporte le format Java.
    BIG_INTEGER
    INTEGER
    "BIG:INTEGER"
    "INTEGER"
    java.math.BigInteger C'est le type numérique entier (étendu, lourd) équivalent au type BigInteger en Java.
    Il supporte le format Java.
    BIG_DECIMAL
    DECIMAL
    "BIG:DECIMAL"
    "DECIMAL"
    java.math.BigDecimal C'est le type numérique décimal (étendu, lourd) équivalent au type BigDecimal en Java.
    Il supporte le format Java.
    NUMBER "NUMBER" java.lang.Number,
    java.math.BigDecimal
    C'est le type numérique générique équivalent à l'interface Number en Java.
    Il supporte le format Java.
    STRING "STRING" java.lang.String C'est le type chaîne de caractères équivalent au type String en Java.
    STRING_BUFFER "STRING:BUFFER" java.lang.StringBuffer C'est le type chaîne de caractères (Buffer) équivalent au type StringBuffer en Java.
    STRING_BUILDER "STRING:BUILDER" java.lang.StringBuilder C'est le type chaîne de caractères (Builder) équivalent au type StringBuilder en Java.
    TEXT "TEXT" java.lang.CharSequence,
    java.lang.String
    C'est le type chaîne de caractères (en mode paragraphe) équivalent au type String en Java.
    Le trans-typage en TEXT d'une sequence de valeurs se traduit par la concaténation des valeurs par \n .
    DATE "DATE" java.util.Date C'est le type date équivalent au type Date en Java.
    Il supporte le format Java.
    DATE_SQL "DATE:SQL" java.sql.Date C'est le type date (SQL) équivalent au type Date en Java.
    Il supporte le format Java.
    DATE_LOCAL "DATE:LOCAL" java.time.LocalDate C'est le type date (Local) équivalent au type LocalDate en Java.
    Il supporte le format (Temporal) Java.
    DATE_TIME "DATE:TIME" java.time.LocalDateTime C'est le type horodate (Local) équivalent au type LocalDateTime en Java.
    Il supporte le format (Temporal) Java.
    TIME "TIME" java.sql.Time C'est le type horaire (SQL) équivalent au type Time en Java.
    Il supporte le format Java.
    TIME_SQL "TIME:SQL" java.sql.Time C'est un type équivalent à TIME
    TIME_LOCAL "TIME:LOCAL" java.time.LocalTime C'est le type horaire (Local) équivalent au type LocalTime en Java.
    Il supporte le format (Temporal) Java.
    TIMESTAMP "TIMESTAMP" java.sql.Timestamp C'est le type horodatage (SQL) équivalent au type Timestamp en Java.
    Il supporte le format Java.
    CALENDAR "CALENDAR" java.util.Calendar,
    java.util.
    GregorianCalender
    C'est le type date calendaire équivalent au type Calendar en Java.
    VOID "VOID" void C'est le type vide (rien) ou void en Java.
    Type JSON
    expression
    Java
    type(s)
    Description
    ARRAY "ARRAY" [...] C'est le type tableau de valeurs équivalent au type Array en Java.
    LIST "LIST" java.util.List C'est le type liste de valeurs équivalent à l'interface List en Java.
    SET "SET" java.util.Set C'est le type set de valeurs uniques équivalent à l'interface Set en Java.
    SEQUENCE "SEQ" java.util.Iterator C'est le type iterateur de collection équivalent à l'interface Iterator en Java.
    ITERABLE "SEQ:ITERABLE" java.lang.Itarable C'est le type collection iterable équivalent à l'interface Iterable en Java.
    ENUMERATION "SEQ:ENUM" java.util.Enumeration C'est le type énumération de valeurs équivalent à l'interface Enumeration en Java.
    PROPERTIES "PROPERTIES" java.util.Properties C'est le type propriété (clé/valeur) équivalent au type Properties en Java.
    JSON "JSON" javax.json.JsonObject C'est le type JSON équivalent à l'interface JsonObject en Java.
    D'autres interfaces JSON sont présentées ci-dessous :
    JSON:BOOLEAN : javax.json.JsonValue.FALSE ou javax.json.JsonValue.TRUE
    JSON:NUMBER : javax.json.JsonNumber
    JSON:STRING : javax.json.JsonString
    JSON:ARRAY : javax.json.JsonArray
    JSON:OBJECT : équivalent à JSON
    XML "XML" org.w3c.dom.Document C'est le type XML (document) équivalent à l'interface Document (XML) en Java.
    D'autres interfaces XML sont présentées ci-dessous :
    XML:ATTRIBUTE : org.w3c.dom.Attr
    XML:CDATA : org.w3c.dom.CDATASection
    XML:COMMENT : org.w3c.dom.Comment
    XML:ENTITY : org.w3c.dom.Entity
    XML:ENTITY_REFERENCE : org.w3c.dom.EntityReference
    XML:INSTRUCTION : org.w3c.dom.ProcessingInstruction
    XML:NOTATION : org.w3c.dom.Notation
    XML:TEXT : org.w3c.dom.Text
    XML:DOCUMENT_TYPE : org.w3c.dom.DocumentType
    XML:DOCUMENT_FRAGMENT : org.w3c.dom.DocumentFragment
    XML:DOCUMENT : équivalent à XML
    XML:ELEMENT : org.w3c.dom.Element
    MAP "MAP" java.util.Map C'est le type tableau de clé/valeur équivalent au type Map en Java.
    CONTEXT "CONTEXT" - C'est le type contextuel à attribut et valeur, la base de toute contextualisation de "do:IT" .
    Type JSON
    expression
    Java
    type(s)
    Description
    CONTENT "CONTENT" - C'est le type contenu accessible représentant tout contenu accessible en "do:IT" .
    BINARY "BINARY" byte[] C'est le type binaire en "do:IT" .
    INPUT "IO:INPUT" java.io.InputStream C'est le type flux d'entrée équivalent au type abstrait InputStream en Java.
    OUTPUT "IO:OUTPUT" java.io.OutputStream C'est le type flux de sortie équivalent au type abstrait OutputStream en Java.
    READER "IO:READER" java.io.Reader C'est le type lecteur de flux équivalent au type abstrait Reader en Java.
    WRITER "IO:WRITER" java.io.Writer C'est le type écriture de flux équivalent au type abstrait Writer en Java.
    PRINTER "IO:PRINTER" java.io.PrintStream C'est le type écriture de flux (mode print) équivalent au type PrintStream en Java.
    Type JSON
    expression
    Java
    type(s)
    Description
    OBJECT { "is" : "OBJECT", "of" : "java.class.Name" } java.class.Name C'est le type représenant n'importe quel type Java.
    Model of
    OBJECT
    "Model of
    OBJECT",

    { "is" : "Model of
    OBJECT", "on" : "model.package.path" }
    - C'est le type d'objet référencé en modèle "do:IT" .
    Note : Le modèle peut être organisé en package.
    ENUM { "is" : "ENUM", "of" : "java.enum.Name" } java.enum.Name C'est le type représenant n'importe quel énumération Java.
    Model of
    ENUM
    "Model of
    ENUM",

    { "is" : "Model of
    ENUM", "on" : "model.package.path" }
    - C'est le type d'énumération référencé en modèle "do:IT" .
    Note : Le modèle peut être organisé en package.
    CLASS "CLASS" java.lang.Class C'est le type équivalent à Class en Java.
    VALUE "VALUE" - C'est le type représenant des valeurs dynamiques en "do:IT" .
    INSTRUCTION "INSTRUCTION" - C'est le type représenant des instructions dynamiques en "do:IT" .
    FUNCTION "FUNCTION" - C'est le type représenant des fonctions dynamiques en "do:IT" .
    FLOW "FLOW" - C'est le type représenant des procédures dynamiques (flow) en "do:IT" .
    EVALUATION "EVALUATION" - C'est le type représenant des évaluations dynamiques (as) en "do:IT" .
    TYPE "TYPE" - C'est le type représenant n'importe quel type "do:IT" .
    ANY "ANY" java.lang.Object C'est le type représenant n'importe quel objet équivalent au type Object en Java.
    Type JSON
    expression
    Java
    type(s)
    Description
    FILE "FILE" - C'est le type représenant les fichiers dans un système de fichier (File System).
    FILE_CONTENT "FILE:CONTENT" - C'est le type représenant le contenu d'un fichier (CONTENT).
    DIR "DIR" - C'est le type représenant les répertoires de fichiers dans un système de fichier (File System).
    FILE_LOCATION "FILE:LOCATION" - C'est le type représenant un fichier (FILE) ou un répertoire (DIR).
    FILE_SYSTEM "FILE:SYSTEM" - C'est le type représenant un système de fichier (File System).
    FILE_STORE "FILE:STORE" - C'est le type représenant une zone de stockage de fichier au sein d'un système de fichier (File System).
    FILE_COMPRESS "FILE:COMPRESS" - C'est le type représenant une méthode de compression applicable à un système de fichier (File System).
    Type JSON
    expression
    Java
    type(s)
    Description
    MESSAGE "MESSAGE" - C'est le type représenant un message élémentaire dans un canal de messages (Message Channel).
    MSG_CONTENT "MSG:CONTENT" - C'est le type représenant le contenu d'un message élémentaire (CONTENT).
    MSG_CHANNEL "MSG:CHANNEL" - C'est le type représenant le canal de messages (Message Channel).
    MSG_BROKER "MSG:BROKER" - C'est le type représenant le fournisseur de flux de message (Message Broker).
    C'est le fournisseur de :
    Message Channel : canal d'acheminement de message,
    Message Receiver : recepteur de message (GET, READ),
    Message Sender : émetteur de message (PUT, SEND).
    MSG_RECEIVER "MSG:RECEIVER" - C'est le type représenant le réception message (Message Receiver).
    MSG_SENDER "MSG:SENDER" - C'est le type représenant l'émetteur message (Message Sender).
    MSG_LISTENER "MSG:LISTENER" - C'est le type représenant le service d'écoute de message (Message Listener).
    C'est le fournisseur de flux de réception de message, suivant le mode :
    Message Listening : flux élémentaire de message (UNIT),
    Message Sequencing : flux de séquence de message (SEQUENCE),
    Message Streaming : flux de message de message (BULK).
    Type JSON
    expression
    Java
    type(s)
    Description
    DATA "DATA" - C'est le type représenant une donnée élémentaire (CONTENT).
    DATA_STORE "DATA:STORE" - C'est le type représenant le stockage de donnée au sein d'un système de stockage de données (Data Storage).
    Le modèle de stockage peut être :
    DATA:TABLE : structure tabulaire,
    DATA:WIDE : structure à colonne étendue ou en famille,
    DATA:TREE : structure hierarchique,
    DATA:KEY/VALUE : structure à clé/valeur,
    DATA:DOCUMENT : structure documentaire,
    DATA_STORAGE "DATA:STORAGE" - C'est le type représenant le fournisseur de stockage de données (Data Storage).
    C'est le fournisseur de :
    Data Store : stockage de données,
    Data Access : accès élémentaire aux données,
    Data Query : requête en masse aux données.
    DATA_ACCESS "DATA:ACCESS" - C'est le type représenant le mécanisme d'accès élémentaire aux données (Data Access).
    DATA_QUERY "DATA:QUERY" - C'est le type représenant le mécanisme de requêtage en message aux données (Data Query).



    Seuls les mots clés flow et as
    qui determinent respectivement si une expression est un appel de FLOW (procédure) ou un appel d'EVALUATION (fonction).

    Pour chaque expression d'appel, des propriétés spécifiques "flw:" sont applicables afin d'introduire des comportements par aspect
    (AOP : Aspect-oriented Programming).


    Attribute Type(s) Description
    "flw:name" STRING Afin qu'une instance de module (ou section) soit gérée en runtime, il faut qu'elle soit nommée.
    Ainsi il sera possible de la contrôler et de l'introspecter à travers d'un système de monitoring ou de sécurité.


    "flw:commented" BOOLEAN Ce flag permet d'ignorer lors de l'interprétation de l'expression, ainsi l'instance de module (ou section) n'est même pas chargée en memoire.
    Si la section était prévue pour une VALUE ou une EVALUATION, la valeur sera NULL.


    "flw:enabled" BOOLEAN Ce flag permet d'ignorer à l'exécution (runtime) une instance de module (ou section). C'est l'équivalent d'un test IF (sans ELSE).
    Contrairement au flag "flw:commented" , ce flag interprète la section mais n'agit qu'à l'exécution (runtime).


    "flw:begin" TEXT Cette propriété permet d'ajouter une trace avant l'exécution d'une instance de module (ou section).


    "flw:end" TEXT Cette propriété permet d'ajouter une trace après l'exécution d'une instance de module (ou section).


    "flw:before" INSTRUCTION Cette propriété permet d'introduire, par aspect, une instruction avant l'exécution d'une instance de module (ou section).


    "flw:after" INSTRUCTION Cette propriété permet d'introduire, par aspect, une instruction après l'exécution d'une instance de module (ou section).
    Pour une EVALUATION, il est possible de modifier le résultat dans cette section en modifiant le contenu du contexte "flw:result" .


    "flw:allowed" BOOLEAN Cette propriété permet d'introduire, par aspect, un contrôle d'autorisation à l'exécution de l'instance de module (ou section) :
      Contrôle de sécurité (habilitation),
      Contrôle de conformité par rapport à un environnement (ex : seulement en phase de DEV),
      Contrôle temporel (ex : dans une tranche horaire),
      ...

    Si le résultat est TRUE, l'exécution sera effectuée.
    Sinon, FALSE, une exception (SecurityException : Not Allowed) sera levée.


    "flw:catch" INSTRUCTION
    VALUE
    Cette propriété permet d'introduire, par aspect, un gestionnaire d'erreur.
    Si cette propriété est positionnée, en cas d'erreur, l'instruction indiquée sera exécutée. Les informations sur l'erreur sera accessible avec le contexte "flw:failure" .


    "comment" TEXT Cette propriété permet juste de poser un commentaire quelconque. Mais le commentaire est accessible à l'exécution (runtime) grâce au contexte "flw:expression->comment" .



    Les contextes représentent les objets manipulables et accessibles par "do:IT" .
    Soit ils sont déjà disponibles grâce aux Context Handler,
    Soit on les crée en tant que Variables Globales, en tant que Paramètres ou en tant que Variables Locales.



    Les contextes sont des objets structurés, composés d'attributs.

    Prenons les exemples ci-dessous.


    Les contextes sont accessibles par référence.


    La référence de contexte peut servir en tant qu'expression contextuelle.


    Avec la variable ai , essayons d'y accéder un par un.


    For each item :
    -> 0 : J.A.R.V.i.S (Just A Rather Very Intelligent System)
    -> 1 : F.R.i.D.A.Y (First Realistic Intelligence Data Analysis Yielder)
    -> 2 : G.E.R.R.i.X (Generic Enterprise Reliable and Resilient Intelligent eXperience)
    For index :
    -> 0 : J.A.R.V.i.S (Just A Rather Very Intelligent System)
    -> 1 : F.R.i.D.A.Y (First Realistic Intelligence Data Analysis Yielder)
    -> 2 : G.E.R.R.i.X (Generic Enterprise Reliable and Resilient Intelligent eXperience)
    By index :
    -> 0 : J.A.R.V.i.S (Just A Rather Very Intelligent System)
    -> 1 : F.R.i.D.A.Y (First Realistic Intelligence Data Analysis Yielder)
    -> 2 : G.E.R.R.i.X (Generic Enterprise Reliable and Resilient Intelligent eXperience)

    Avec le formatage contextuel, ci-dessous quelques exemples.


    *******************************************************************************
    Bonjour ! C'est 'Web-Site' ('do:IT' web site)
    -> sur 'ip-172-31-43-24.eu-central-1.compute.internal' (Linux - 4.14.177-139.254.amzn2.x86_64)
    -> ID du processus (PID) : 7756
    -> vous êtes sur '172.31.7.0' (CCBot/2.0 (https://commoncrawl.org/faq/))
    -> il est 14:40:40 (15/06/2021)
    *******************************************************************************


    Attribute(s) Type(s) Description
    name STRING Le nom de l'application qui est indiqué dans le fichier '.def'
    version CONTEXT (VERSION) La version de l'application qui est indiquée dans le fichier '.def'
    description STRING La description de l'application qui est indiquée dans le fichier '.def'
    type.name STRING Le type d'application "do:IT" :
    do (code = do) : do:IT lighweight application (application légère, simplifiée),
    application (code = app) : do:IT application.
    type.code STRING Le type (en code simplifié) de l'application "do:IT" .
    jar.path STRING Le chemin absolu de la librairie JAR de "do:IT" .
    jar.dir STRING Le répertoire contenant la librairie JAR de "do:IT" .
    def.path STRING Le chemin absolu de la definition .def de l'application "do:IT" en cours d'exécution.
    def.dir STRING Le répertoire contenant la definition .def de l'application "do:IT" en cours d'exécution.
    design CONTEXT (DESIGN) Le modèle d'exécution de l'application (APP) "do:IT" .
    design->type ,
    flow.type
    STRING
    ENUM
    Le type d'application "do:IT" :
      « INTR » : Interaction Layer,
      « INTG » : Integration Layer (Exchange),
      « PROC » : Processing Layer,
      « COMP » : Computing Layer,
      « MGNT » : Management layer;
    design->mode ,
    flow.mode
    STRING
    ENUM
    Le mode d'exécution d'application "do:IT" :
      « CMD » : Application composée de séquence de commandes,
      « WEB » : Application orientée Web (client léger),
      « DSK » : Application orientée Desktop (client lourd),
      « STR » : Application orientée Streaming,
      « BAT » : Application orientée Batch Contrôlé (phasing : PREPARE, PROCESS, COMMIT, ROLLBACK, CONFIRM).
    design->code ,
    flow.code
    STRING Le code (ou chennel) de l'application "do:IT" .
    Attribute(s) Type(s) Description
    id LONG L'identifiant unique (natif) du 'thread'.
    name STRING Le nom du 'thread'.
    priority INT La priorité associé du 'thread'.
    state ENUM L'état du 'thread' :
    NEW : le 'thread' vient d'être créé mais pas actif,
    RUNNABLE : le 'thread' est en cours d'exécution,
    BLOCKED : le 'thread' est bloqué à cause d'un 'wait()',
    WAITING : le 'thread' est en attente de déblocage ( après 'wait()' ) ou de jointure (après 'join()' ),
    TIMED_WAITING : l'attente du 'thread' est interrompue,
    TERMINATED : le 'thread' est terminé.
    group CONTEXT Le groupe d'appartenance du 'thread'.
    alive BOOLEAN Le flag indiquant que le 'thread' est vivant (en cours d'exécution).
    daemon BOOLEAN Le flag indiquant que le 'thread' est en mode 'daemon'.
    daemon BOOLEAN Le flag indiquant que l'exécution du 'thread' a été interrompue.
    ... ... Les autres 'Custom Context' attachés par programmation.
    Attribute(s) Type(s) Description
    name STRING Le nom de l'instance de module (ou section), si existant.
    type STRING Le nom du type de module (si module) au niveau du 'Repository'.
    module ENUM Le type de module (si instance de module) :
    FLOW : une instance de module d'instruction,
    EVALUATION : une instance de module d'évaluation,
    FUNCTION : une instance de module de fonction.
    parent CONTEXT (STACK) Le contexte du 'stack' parent (appelant) de l'instance de module.
    failure CONTEXT (EXCEPTION) L'exception survenue en cas d'erreur, récupérée en cas de capture d'erreur.
    result ANY La valeur retour seulement récupérable lors d'une capture d'aspect après exécution.

    C'est le contexte représenant les options de lancement d'une application "do:IT" .

    > grx-do.sh -do.def demo-00-Hello-DO.def -name Rivo
    Les ressources sont objets référencés dans la section 'resources' des applications.
    (cf. Runtime Structure)
    Il y a 3 types de contexts déclarés sont les contextes renseignés :

    ctx: qui est le contexte global au niveau de l'application, défini par le mot clé with ,

    par: qui est le contexte des paramètres d'appel d'un module, défini par le mot clé params ,

    var: qui est le contexte des variables locales au sein d'une section ou bloc d'instruction , défini par le mot clé with
    Il est possible de définir d'autre type de contexte (préfix) avec le mot clé ctx .




    C'est le contexte représentant les Java Runtime Properties,
    soit en standard au niveau de la JVM,
    soit par l'option de lancement -D
    soit via la section Runtime / Properties au niveau de l'application "do:IT"
    C'est le contexte représentant les variables d'environnement d'exécution (OS).
    Attribute(s) Type(s) Description
    os CONTEXT (OS) L'information de l'OS hôte de l'exécution.
    os->name ,
    os.name
    STRING Le nom de l'OS (eq. 'run:os.name').
    os->version ,
    os.version
    STRING La version de l'OS (eq. 'run:os.version').
    os->posix ,
    os.type.posix
    BOOLEAN Le flag indiquant si l'OS est un POSIX.
    os->unix ,
    os.type.unix
    BOOLEAN Le flag indiquant si l'OS est un UNIX.
    os->windows ,
    os.type.windows
    BOOLEAN Le flag indiquant si l'OS est un Windows.
    os->desktop ,
    desktop
    BOOLEAN Le flag indiquant si l'OS est un Windows.
    os->hostAddress ,
    host.address
    STRING L'adresse IP du système hôte (host).
    os->hostName ,
    host.name
    STRING Le nom du système hôte (host).
    os->architectureModel ,
    cpu.arch.model
    STRING Le modèle d'architecture de l'OS (32 bits ou 64 bits).
    os->architecture32 ,
    cpu.arch.32
    BOOLEAN Le flag indiquant que la version de l'OS est en 32 bits (le CPU doit être compatible).
    os->architecture64 ,
    cpu.arch.64
    BOOLEAN Le flag indiquant que la version de l'OS est en 64 bits (le CPU doit être compatible).
    cpu.endian STRING Le modèle de rangement des bits en mémoire : 'big' ou 'little'.
    os->encoding ,
    encoding
    BOOLEAN L'encoding par défaut de l'OS (ex : UTF8).
    proc.nb INT Le nombre de CPU (core) disponible dans le système hôte (host).
    pid INT Le PID associé à la JVM en cours d'exécution.
    now DATE
    TIMESTAMP
    L'horodatage en cours (évalué à chaque invocation).
    random DOUBLE Une valeur décimale aléatoire entre 0 et 1 (évaluée à chaque invocation).
    mem.max LONG La taille en octet de la mémoire maximale utilisable, en cas d'extension, par la JVM (évaluée à chaque invocation).
    mem.total LONG La taille en octet de la mémoire totale utilisée par la JVM (évaluée à chaque invocation).
    mem.free LONG La taille en octet de la mémoire libre utilisable par la JVM (évaluée à chaque invocation).
    mem.used LONG La taille en octet : mem.total - mem.free.
    Attribute(s) Type(s) Description
    name STRING L'identifiant de l'user d'exécution (eq. 'run:user.name')
    home STRING Le repertoire d'acceuil de l'user d'exécution (eq. 'run:user.home')
    temp STRING Le repertoire temporaire de l'user d'exécution (eq. 'run:java.io.tmpdir')
    locale CONTEXT (LOCALE) L'information concernant la localisation linguistique de l'user d'exécution
    locale->country ,
    country
    STRING Le pays associé à la localisation linguistique de l'user d'exécution (eq. 'run:user.country')
    locale->language ,
    language
    STRING La langue associée à la localisation linguistique de l'user d'exécution (eq. 'run:user.language')
    Attribute(s) Type(s) Description
    version STRING La version du coeur (moteur) de "do:IT" (GERRIX).
    app.type STRING Le type d'application "do:IT" (GERRIX)
    (eq. 'app:type.name').
    app.type STRING Le type (en code simplifié) de l'application "do:IT" (GERRIX)
    (eq. 'app:type.code').
    types REPOSITORY (TYPE) L'annuaire des TYPEs accessible au sein de "do:IT" .
    Ce context est nécessaire pour introspecter les types manipulés au sein de "do:IT" : les attributs et les fonctions d'un type.
    flows REPOSITORY (FLOW) L'annuaire des FLOWs accessible au sein de "do:IT" .
    evaluations REPOSITORY (EVALUATION) L'annuaire des EVALUATIONs accessible au sein de "do:IT" .




    Le contexte représentant les attributs d'une instance d'objet, OBJECT ou ENUM.
    C'est l'équivalent de this ou self pour les autres langages.

    Attribute(s) Type(s) Description
    ‹type› CONTEXT (TYPE) La description du type de l'instance d'objet.



    Attribute(s) Type(s) Description
    index LONG L'index en cours dans l'itération FOR, qui commence par 0.
    order LONG L'ordre en cours dans l'itération FOR, qui commence par 1.
    size INT FOR (in) :
    Le nombre d'élément à itérer dans une collection ((LIST ou SET) ou un tableau (ARRAY).
    item INT FOR (in) :
    L'élément en cours correspondant l'itération dans une collection ((LIST ou SET) ou un tableau (ARRAY).
    first LONG FOR (index) :
    Le début de l'index d'itération.
    skip INT FOR (index) :
    Le saut d'index de l'itération.
    last LONG FOR (index) :
    Le dernier index d'itération.



    Attribute(s) Type(s) Description
    index LONG L'index en cours dans la séquence, qui commence par 0.
    order LONG L'ordre en cours dans la séquence, qui commence par 1.
    item ANY L'élément en cours dans la séquence.