Aller au contenu principal

Ressources

Configuration des ressources "resources"​

Certaines fonctions nécessitent, en plus de leurs paramètres de fonction dynamiques, une configuration statique complémentaire. Il s'agit par exemple de tables de correspondance (lookup) ou de fonctions de la technique de commande avec des largeurs de registre ou des plages de comptage. Cette configuration statique est transmise à l'appel de la fonction comme dernier paramètre, sous la forme d'un objet JSON.

La configuration directement dans l'appel de fonction reste judicieuse pour quelques paramètres isolés ; pour des configurations volumineuses, par exemple une classification ou un filtre, ces ressources peuvent être déportées dans une zone dédiée du module math afin d'améliorer la lisibilité du jeu de formules. Ce déport permet en outre de réutiliser la même configuration à différents endroits du jeu de formules.

Dans le cadre de ce que l'on appelle les ressources, il est possible

  • de stocker du texte pour la configuration ou un traitement ultérieur,
  • de déporter des objets JSON complexes du jeu de formules vers une zone de la configuration prévue à cet effet, et
  • de permettre, à l'aide de ce que l'on appelle des décodeurs, un processus de traitement de données quelconques (texte ou binaires).

Ces ressources sont initialisées UNE SEULE FOIS au démarrage du fonctionnement de mesure et peuvent être configurées comme suit

{
  "module":"math1",
  "factory":"mathmodule",
  "config": {

    ...

    "resources": {
      "someTextResource": [

          < LINES OF TEXT >

      ],
      "someObjectResource": {

          < JSON STYLE Configuration >

      },
      "someDecodableResource": {
        "decoder": [

          < DECODERS >

        ],
        "value": "someInitialResourceValueString"
      }
      ...
    }
  }
}

Nous distinguons ici

  • les ressources texte pures, qui spécifient le texte, de manière similaire au paramètre math, sous la forme d'une unique chaîne ou d'une liste de chaînes (sous la forme d'un tableau JSON). Les chaînes individuelles de la liste sont reliées au moyen de '\n' avant utilisation. (dans l'exemple ci-dessus someTextResource)

  • les ressources objet, qui fournissent des objets JSON représentables pour la configuration de fonctions dans le texte de formule (dans l'exemple ci-dessus someObjectResource)

  • et les ressources décodables, qui appliquent successivement une suite de processus de traitement (décodeurs) à un paquet de données initial et fournissent le résultat également sous forme de paquet de données (dans l'exemple ci-dessus someDecodableResource). Ce paquet de données peut être un texte lisible, mais aussi un paquet de données binaire.

Accès aux ressources et conversion​

L'accès aux ressources ne peut se faire **qu'**à la place du dernier paramètre d'une fonction qui accepte un objet JSON comme paramètre

someJsonObjectAcceptingFunction( ... , {$ref:'someResource'} )

et renvoie généralement un objet JSON. Une exception est par exemple la fonction lookup(), qui attend de la ressource un bloc de texte comportant un en-tête de données propriétaire et une suite de valeurs de données pour remplir la table.

Si, en revanche, une représentation sous forme de chaîne est attendue, le contenu de la ressource peut être converti comme suit

someStringAcceptingFunction( ... , sResource({$ref:'someResource'}), ... )

Dans tous les cas, il incombe à l'utilisateur de fournir les données de telle sorte que la fonction utilisée ou le jeu de formules puisse les interpréter et les traiter.

Exemple : fourniture d'une configuration textuelle à partir d'une ressource texte :​

Dans l'exemple suivant, la configuration d'une table de correspondance est attendue sous la forme d'un format texte propriétaire. Les points de données suivent les lignes d'en-tête.

{
  "module":"math1",
  "factory":"mathmodule",
  "config": {
    "math": "someTextAcceptingFunction( ... , {$ref:'someText'} );",
    "resources": {
      "someText": [
          "IN kPa 0.0 0.167751 161"
        , "OUT l"
        , ""
        , "0"
        , "42.942"
        , "87.924"
        , "134.946"
        , "184.008"
        , "235.11"
        , "288.252"
        , "343.434"
        , "400.656"
        , "459.918"
        , "521.22"
        , "584.562"
        , "..."
      ],
      ...
    }
  }
}

D'autres exemples d'application pourraient être :

  • Un texte d'e-mail prédéfini pour une notification, dans lequel des marqueurs de texte sont remplacés par des valeurs concrètes dans le jeu de formules.

  • Une structure XML pour un sous-système, qui doit ainsi être configuré pour une tâche de mesure.

Exemple : fourniture d'un objet JSON attendu à partir d'une ressource objet​

Dans l'exemple suivant, une configuration de fonction statique est attendue sous la forme d'un objet JSON

{
  "module":"math1",
  "factory":"mathmodule",
  "config": {
    "math": "someObjectAcceptingFunction( ... , { someParam: value } );"
  }
}

Celui-ci peut être fourni par une ressource objet comme suit

{
  "module":"math1",
  "factory":"mathmodule",
  "config": {
    "math": "someObjectAcceptingFunction( ... , {$ref:'someObject'} );",
    "resources": {
      "someObject": {
        someParam: value
      },
      ...
    }
  }
}

Exemple : fourniture d'une chaîne de caractères traitée à partir de ressources​

Dans l'exemple suivant, la fonction "someObjectAcceptingFunction" attend une chaîne de caractères traitée (par exemple le contenu d'un fichier ou une représentation décodée ou décompressée de la chaîne, voir la section "decoder" pour plus de détails).

Cela peut être réalisé par une ressource décodable comme suit

{
  "module":"math1",
  "factory":"mathmodule",
  "config": {
    "math": "someObjectAcceptingFunction({$ref:'someDecodableResource'});",
    "resources": {
      "someDecodableResource": {
        "decoder": [
          "someFirstDecoderStage someFirstFirstDecoderArgument ... someLastFirstDecoderArgument",
          ...,
          "someLastDecoderStage someFirstLastDecoderArgument ... someLastLastDecoderArgument"
        ],
        "value": "someInitialStringValue"
      }
    }
  }
}

Ici, la première étape de décodage "someDecoderStageFIRST" convertit d'abord la valeur de chaîne initiale de la ressource "someInitialValueString" en un résultat intermédiaire, et toutes les étapes de décodage suivantes calculent le résultat intermédiaire suivant à partir du résultat intermédiaire précédent, la dernière étape de décodage renvoyant son résultat intermédiaire comme résultat final sous la forme d'une valeur JSON de type chaîne.

Remarque : si ce résultat doit être utilisé là où une chaîne est attendue, il doit - comme décrit plus haut - être converti lors de l'accès au moyen de "sResource".

Décodage des ressources "decoder"​

Un décodeur a pour tâche de convertir une chaîne source en une chaîne cible.

Les décodeurs suivants sont actuellement disponibles

  • file pour la lecture d'un fichier
  • base64 pour le décodage d'une chaîne au format base64
  • unzip pour la décompression du contenu d'un fichier compressé en gzip

Ainsi qu'un décodeur d'usage très flexible

  • system pour l'appel de processus système

Décodeur "file"​

Le décodeur "file" sert à lire un fichier "/sdi/config/some/file/name", comme suit

{
  "module":"math1",
  "factory":"mathmodule",
  "config": {
    "math": "someJsonValueAcceptingFunction({$ref:'someFileResource'});",
    "resources": {
      "someFileResource": {
        "decoder": [
          "file"
        ],
        "value": "some/file/name"
      }
    }
  }
}

Si un chemin relatif est spécifié comme "value" du décodeur, il est interprété relativement au répertoire de configuration smartCORE /sdi/config/. Il est toutefois également possible de spécifier un chemin absolu.

Décodeur "unzip"​

Pour décompresser des fichiers compressés en gzip, on peut utiliser le décodeur "unzip", par exemple comme suit

{
  "module":"math1",
  "factory":"mathmodule",
  "config": {
    "math": "someJsonValueAcceptingFunction({$ref:'someFileResource'});",
    "resources": {
      "someFileResource": {
        "decoder": [
          "file",
          "unzip"
        ],
        "value": "some/compressed/file/name.gz"
      }
    }
  }
}

Décodeur "base64"​

Pour décoder des fichiers encodés en base64, on peut utiliser le décodeur "base64", par exemple comme suit

{
  "module":"math1",
  "factory":"mathmodule",
  "config": {
    "math": "someJsonValueAcceptingFunction({$ref:'someFileResource'});",
    "resources": {
      "someFileResource": {
        "decoder": [
          "file",
          "base64"
        ],
        "value": "some/base64/encoded/file.b64"
      }
    }
  }
}

Décodeur "system"​

Pour l'initialisation de ressources à l'aide d'appels système quelconques, on peut utiliser le décodeur "system". Celui-ci prend en charge des paramètres d'appel. Exemple :

{
  "module":"math1",
  "factory":"mathmodule",
  "config": {
    "math": "someJsonValueAcceptingFunction({$ref:'someEditedResource'});",
    "resources": {
      "someEditedResource": {
        "decoder": [
          "file",
          "system sed -e 's/hello/world/g'"
        ],
        "value": "some/source/file"
      }
    }
  }
}