do:IT - do IT differently

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 !" }




{ 
  "name" : "Hello", 
  "version" : "0.1", 
  "description" : "'Hello World' with 'do:IT'", 
 
  "do" : { 
    "flw:print" : "Salut '${opt:name%Toi}' ! ... Ici ${app:name}" 
  } 
 
} 





{ 
  "name" : "Hello-CMD", 
  "version" : "0.1", 
  "description" : "'Hello World' with 'do:IT'", 
 
  "design" : { 
    "type" : "MNGT", 
    "mode" : "CMD", 
    "channel" : "HCMD" 
  }, 
 
  "flows" : { 
 
    "main" : { 
      "flw:print" : "Salut '${opt:name%Toi}' ! ... Ici ${app:name}" 
    } 
 
  } 
 
} 





{ 
  "name" : "Hello-WEB", 
  "version" : "0.1", 
  "description" : "'Hello World' with 'do:IT'", 
 
  "design" : { 
    "type" : "INTR", 
    "mode" : "WEB", 
    "channel" : "HWEB" 
  }, 
 
  "flows" : { 
 
    "main" : { 
      "locations" : { 
        "/" : { 
          "as" : "WEB:MAPPING", 
          "name" : "Hello", 
          "mappings" : { 
            "hello/{you}" : { 
              "GET" : "Salut '${loc:you}' ! ... Ici ${app:name}" 
            } 
          } 
        } 
      } 
    } 
 
  } 
 
} 

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 :

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

{ 
  "flw:print" : [ 
    "Ceci est une saluation : ", "Hello World !" 
  ], 
  "new:line" : false
}

Description :

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

Exemple :

[ 
  "... instruction ...", 
  "... en serie ......", 
  "    (inactives)    "
]

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 :

{ 
  "with" : { 
    "text" : "Hello World !"
  }, 

  "ctx" : { 
    "obj" : { 
      "firstName" : "Rivo", 
      "lastName" : "RASOLOFOMANANA", 
      "company" : "GERRIX", 
    }
  }, 

  "do" : [ 
    "... instruction ...", 
    "... en bloc avec ..", 
    { "flw:print" : "${var:text}" } 
    { "flw:print" : "Hello ${obj:firstName} ${obj:lastName}" } 
  ] 
}

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 :

{ 
  "flow" : "SYS:EXEC", 
  "path" : "curl", 
  "with" : "https://doit.grx-tech.com/" 
}

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 :

{ 
  "name" : "RASOLOFOMANANA", 
  "active" : true, 
  "year" : 2020, 
  "nothing" : null 
}

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 :

{ 
  "sequence" : [ "RASOLOFOMANANA", true, 2020, null ] 
}

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 :

{ 
  "with" : { 
    "name" : "RASOLOFOMANANA", 
    "active" : true, 
    "year" : 2020, 
    "nothing" : null 
  }, 
  "do" : { 
    "flw:print" : [ 
      "Name ..........: ", { "ref" : "var:name" }, "\n", 
      "is active .....: ", { "ref" : "var:active" }, "\n", 
      "on the year ...: ", { "ref" : "var:year" }, "\n" 
    ], 
    "new:line" : false 
  } 
}

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 :

{ 
 
  "year" : { 
    "is" : "INT", 
    "value" : 2020 
  }, 
 
  "creation" : { 
    "is" : "DATE", 
    "value" : "01/10/2008", 
    "format" : "dd/MM/yyyy" 
  },
 
  "hero" : { 
    "is" : "ACTOR", 
    "with" : { 
      "name" : "Iron Man", 
      "creation" : 2008 
    } 
  } 
 
}

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 :

{ 
  "as" : "SYS:EXEC", 
  "path" : "curl", 
  "with" : "https://doit.grx-tech.com/", 
 
  "comment" : "Retourne le contenu du site en tant que STRING"
}

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.

{
  "with" : {
    "ai" : [
      {
        "acronym" : "J.A.R.V.i.S",
        "description" : "Just A Rather Very Intelligent System",
        "owners" : "Iron Man"
      },
      {
        "acronym" : "F.R.i.D.A.Y",
        "description" : "First Realistic Intelligence Data Analysis Yielder",
        "owners" : [ "Iron Man", "Spider Man" ]
      },
      {
        "acronym" : "G.E.R.R.i.X",
        "description" : "Generic Enterprise Reliable and Resilient Intelligent eXperience",
        "owners" : "Rivo"
      }
    ]
  }
}

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.

{
  "do" : [
   { "flw:print" : "For each item : " },
   {
     "flow" : "FOR", "in" : { "ref" : "ctx:ai" },
     "do" : {
       "flw:print" : " -> ${for:index} : ${for:item->acronym} (${for:item->description})"
     }
   },

   { "flw:print" : "For index : " },
   {
     "flow" : "FOR", "index" : 0, "to" : { "as" : "SIZE", "of" : { "ref" : "ctx:ai" } }, "strict" : true,
     "do" : {
       "flw:print" : " -> ${for:index} : ${ctx:ai[${for:index}]->acronym} (${ctx:ai[${for:index}]->description})"
     }
   }

   { "flw:print" : "By index : " },
   { "flw:print" : " -> 0 : ${ctx:ai[0]->acronym} (${ctx:ai[0]->description})" },
   { "flw:print" : " -> 1 : ${ctx:ai[1]->acronym} (${ctx:ai[1]->description})" },
   { "flw:print" : " -> 2 : ${ctx:ai[2]->acronym} (${ctx:ai[2]->description})" }
  ]
}

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.

{ 
  "flw:print" : [ 
    "*******************************************************************************", 
    "Bonjour ! C'est '${app:name}' (${app:description})", 
    " -> sur '${sys:host.name}' (${sys:os.name} - ${sys:os.version})", 
    " -> ID du processus (PID) : ${sys:pid}", 
    " -> vous êtes sur '${req:remote.ip}' (${web:agent%${req:headers->User-Agent%...}})", 
    " -> il est ${sys:now@TIME} (${sys:now@DATE%dd/MM/yyyy})", 
    "*******************************************************************************" 
  ] 
}

******************************************************************************* 
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.45.67' (CCBot/2.0 (https://commoncrawl.org/faq/)) 
 -> il est 03:10:36 (08/12/2024)
******************************************************************************* 

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 channel) de l'application "do:IT" .

args

LIST (STRING)

La liste des arguments de lancement de l'application.

Attribute(s)

Type(s)

Description

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

{ 
  "name" : "Hello", 
  "version" : "0.1", 
  "description" : "'Hello World' with 'do:IT'", 
 
  "do" : { 
    "flw:print" : "Salut '${opt:name%Toi}' ! ... Ici ${app:name}" 
  } 
 
}

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 .

{ 
  "ctx" : { 
    "own" : { 
      "company" : "GERRIX Arch'N Tech", 
      "ai" : "G.E.R.R.i.X", 
      "owner" : "Rivo RASOLOFOMANANA" 
    } 
  } 
 
  "do" : { 
    "flw:print" : " '${own:owner}' : you have '${own:ai}' by '${own:company}' " 
  } 
 
}

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

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.