nl::ArgParser

Résumé

Énumérations

OptionArgumentType enum
Définit les exigences d'argument pour une option de ligne de commande.

Typedefs

NonOptionArgHandlerFunct)(const char *progName, int argc, char *argv[]) typedef
bool(*
Fonction pouvant être appelée pour gérer tous les arguments de ligne de commande restants qui ne sont pas des options.
OptionHandlerFunct)(const char *progName, OptionSet *optSet, int id, const char *name, const char *arg) typedef
bool(*
Fonction pouvant être appelée pour gérer un ensemble d'options de ligne de commande.

Variables

PrintArgError = DefaultPrintArgError)(const char *msg,...)
void(*
Pointeur de la fonction permettant d'afficher les erreurs qui se produisent lors de l'analyse des arguments.
gActiveOptionSets = NULL
Liste d'OptionSets transmise à l'appel ParseArgs() actuellement actif.

distantes

CountAllOptions(OptionSet *optSets[])
size_t
CountAllOptions(OptionSet **optSets)
size_t
CountOptionSets(OptionSet *optSets[])
size_t
CountOptionSets(OptionSet **optSets)
size_t
DefaultPrintArgError(const char *msg, ...)
void
Affichez un message d'erreur associé à l'analyse des arguments.
FindOptionById(OptionSet **optSets, int optId, OptionSet *& optSet, OptionDef *& optDef)
void
FindOptionByIndex(OptionSet **optSets, int optIndex, OptionSet *& optSet, OptionDef *& optDef)
void
GetNextArg(char *& parsePoint)
bool
IsShortOptionChar(int ch)
bool
MakeLongOptions(OptionSet **optSets)
struct option *
MakeShortOptions(OptionSet **optSets)
char *
MakeUniqueHelpGroupNamesList(OptionSet *optSets[])
const char **
ParseArgs(const char *progName, int argc, char *argv[], OptionSet *optSets[], NonOptionArgHandlerFunct nonOptArgHandler, bool ignoreUnknown)
bool
Analyser un ensemble d'arguments de type ligne de commande en appelant des fonctions de traitement pour traiter chaque option et argument autre qu'une option.
ParseArgs(const char *progName, int argc, char *argv[], OptionSet *optSets[], NonOptionArgHandlerFunct nonOptArgHandler)
bool
ParseArgs(const char *progName, int argc, char *argv[], OptionSet *optSets[])
bool
ParseArgsFromEnvVar(const char *progName, const char *varName, OptionSet *optSets[], NonOptionArgHandlerFunct nonOptArgHandler, bool ignoreUnknown)
bool
Analyser un ensemble d'arguments à partir d'une variable d'environnement nommée
ParseArgsFromEnvVar(const char *progName, const char *varName, OptionSet *optSets[])
bool
ParseArgsFromEnvVar(const char *progName, const char *varName, OptionSet *optSets[], NonOptionArgHandlerFunct nonOptArgHandler)
bool
ParseArgsFromString(const char *progName, const char *argStr, OptionSet *optSets[], NonOptionArgHandlerFunct nonOptArgHandler, bool ignoreUnknown)
bool
Analyse un ensemble d'arguments à partir d'une chaîne donnée.
ParseArgsFromString(const char *progName, const char *argStr, OptionSet *optSets[], NonOptionArgHandlerFunct nonOptArgHandler)
bool
ParseArgsFromString(const char *progName, const char *argStr, OptionSet *optSets[])
bool
ParseBoolean(const char *str, bool & output)
bool
Analyser une chaîne en tant que valeur booléenne.
ParseFabricId(const char *str, uint64_t & fabricId, bool allowReserved)
bool
Analyser un ID de tissu Weave au format texte.
ParseHexString(const char *hexStr, uint32_t strLen, uint8_t *outBuf, uint32_t outBufSize, uint32_t & outDataLen)
bool
Analyser une chaîne d'octets données sous forme hexadécimale
ParseIPAddress(const char *str, IPAddress & output)
bool
Analyser une adresse IP sous forme de texte
ParseInt(const char *str, uint64_t & output, int base)
bool
Analysez une chaîne et tentez de la convertir en entier non signé de 64 bits, en appliquant l'interprétation appropriée en fonction du paramètre de base.
ParseInt(const char *str, uint32_t & output, int base)
bool
Analysez une chaîne et tentez de la convertir en entier non signé de 32 bits, en appliquant l'interprétation appropriée en fonction du paramètre de base.
ParseInt(const char *str, int32_t & output, int base)
bool
Analysez une chaîne et tentez de la convertir en entier signé de 32 bits, en appliquant l'interprétation appropriée en fonction du paramètre de base.
ParseInt(const char *str, uint64_t & output)
bool
Analysez et essayez de convertir une chaîne interprétée comme une valeur décimale en un entier non signé de 64 bits, en appliquant l'interprétation appropriée en fonction du paramètre de base.
ParseInt(const char *str, uint32_t & output)
bool
Analysez et essayez de convertir une chaîne interprétée comme une valeur décimale en un entier non signé de 32 bits, en appliquant l'interprétation appropriée en fonction du paramètre de base.
ParseInt(const char *str, int32_t & output)
bool
Analysez une chaîne interprétée comme une valeur décimale en un entier signé de 32 bits et essayez de la convertir, en appliquant l'interprétation appropriée en fonction du paramètre de base.
ParseInt(const char *str, uint16_t & output)
bool
Analysez et tentez de convertir une chaîne interprétée comme une valeur décimale en un entier non signé de 16 bits, en appliquant l'interprétation appropriée en fonction du paramètre de base.
ParseInt(const char *str, int16_t & output)
bool
Analysez et tentez de convertir une chaîne interprétée comme une valeur décimale en un entier signé de 16 bits, en appliquant l'interprétation appropriée en fonction du paramètre de base.
ParseInt(const char *str, uint8_t & output)
bool
Analysez et essayez de convertir une chaîne interprétée comme une valeur décimale en un entier non signé de 8 bits, en appliquant l'interprétation appropriée en fonction du paramètre de base.
ParseNodeId(const char *str, uint64_t & nodeId)
bool
Analyser un ID de nœud Weave au format texte.
ParseSubnetId(const char *str, uint16_t & subnetId)
bool
Analyser une chaîne et tenter de la convertir en ID de sous-réseau non signé de 16 bits en interprétant la chaîne comme du code hexadécimal.
PrintOptionHelp(OptionSet *optSets[], FILE *s)
void
Imprime le texte d'aide d'une liste d'options spécifiée dans un flux.
PutStringWithBlankLine(FILE *s, const char *str)
void
PutStringWithNewLine(FILE *s, const char *str)
void
SplitArgs(char *argStr, char **& argList, char *initialArg)
int32_t

Classes

nl::ArgParser::HelpOptions

Commun OptionSet pour gérer les options d'information (aide, version).

nl::ArgParser::OptionSetBase

Un OptionSet où le gestionnaire est une fonction virtuelle.

Structs

nl::ArgParser::OptionDef

Définit une option de ligne de commande.

nl::ArgParser::OptionSet

Définit un groupe d'options de ligne de commande réutilisables et liées de manière logique.

Énumérations

OptionArgumentType

 OptionArgumentType

Définit les exigences d'argument pour une option de ligne de commande.

Typedefs

NonOptionArgHandlerFunct

bool(* NonOptionArgHandlerFunct)(const char *progName, int argc, char *argv[])

Fonction pouvant être appelée pour gérer tous les arguments de ligne de commande restants qui ne sont pas des options.

OptionHandlerFunct

bool(* OptionHandlerFunct)(const char *progName, OptionSet *optSet, int id, const char *name, const char *arg)

Fonction pouvant être appelée pour gérer un ensemble d'options de ligne de commande.

Variables

PrintArgError

void(* PrintArgError)(const char *msg,...) = DefaultPrintArgError

Pointeur de la fonction permettant d'afficher les erreurs qui se produisent lors de l'analyse des arguments.

Les applications doivent appeler PrintArgError() pour signaler les erreurs dans leurs fonctions de traitement des arguments d'options et non-options, plutôt que d'imprimer directement sur stdout/stderr.

La valeur par défaut est un pointeur vers la fonction DefaultPrintArgError().

gActiveOptionSets

OptionSet ** gActiveOptionSets = NULL

Liste d'OptionSets transmise à l'appel ParseArgs() actuellement actif.

Cette valeur est NULL si aucun appel à ParseArgs() n'est en cours.

distantes

CountAllOptions

size_t CountAllOptions(
  OptionSet *optSets[]
)

CountAllOptions

size_t CountAllOptions(
  OptionSet **optSets
)

CountOptionSets

size_t CountOptionSets(
  OptionSet *optSets[]
)

CountOptionSets

size_t CountOptionSets(
  OptionSet **optSets
)

DefaultPrintArgError

void DefaultPrintArgError(
  const char *msg,
  ...
)

Affichez un message d'erreur associé à l'analyse des arguments.

Fonction par défaut utilisée pour imprimer les messages d'erreur causés par l'analyse des arguments.

Détails
Paramètres
[in] msg
Message à imprimer.

Les applications doivent appeler via le pointeur de fonction PrintArgError au lieu d'appeler cette fonction directement.

FindOptionById

void FindOptionById(
  OptionSet **optSets,
  int optId,
  OptionSet *& optSet,
  OptionDef *& optDef
)

FindOptionByIndex

void FindOptionByIndex(
  OptionSet **optSets,
  int optIndex,
  OptionSet *& optSet,
  OptionDef *& optDef
)

GetNextArg

bool GetNextArg(
  char *& parsePoint
)

IsShortOptionChar

bool IsShortOptionChar(
  int ch
)

MakeLongOptions

struct option * MakeLongOptions(
  OptionSet **optSets
)

MakeShortOptions

char * MakeShortOptions(
  OptionSet **optSets
)

MakeUniqueHelpGroupNamesList

const char ** MakeUniqueHelpGroupNamesList(
  OptionSet *optSets[]
)

ParseArgs

bool ParseArgs(
  const char *progName,
  int argc,
  char *argv[],
  OptionSet *optSets[],
  NonOptionArgHandlerFunct nonOptArgHandler,
  bool ignoreUnknown
)

Analyser un ensemble d'arguments de type ligne de commande en appelant des fonctions de traitement pour traiter chaque option et argument autre qu'une option.

ParseArgs() prend une liste d'arguments (argv) et les analyse en fonction d'un ensemble de définitions d'options fournies. La fonction prend en charge les options longues (opt) et courtes (-o) et implémente la même syntaxe d'option que la fonction GNU getopt_long(3).

Détails
Paramètres
[in] progName
Nom du programme ou du contexte dans lequel les arguments sont analysés. Cette chaîne sera utilisée pour préfixer les messages d'erreur et les avertissements.
[in] argc
Nombre d'arguments à analyser, plus 1.
[in] argv
Tableau de chaînes d'arguments à analyser. La longueur du tableau doit être supérieure de 1 à la valeur spécifiée pour argc, et argv[argc] doit être défini sur NULL. L'analyse de l'argument commence par le deuxième élément du tableau (argv[1]). L'élément 0 est ignoré.
[in] optSets
Liste de pointeurs vers des structures OptionSet qui définissent les options légales. La liste fournie doit se terminer par une valeur NULL.
[in] nonOptArgHandler
Pointeur vers une fonction qui sera appelée une fois l'analyse des options terminée, avec tous les autres arguments autres que les options . La fonction est appelée, qu'il reste ou non des arguments. Si une valeur NULL est transmise, ParseArgs() signale une erreur si des arguments autres qu'une option sont présents.
[in] ignoreUnknown
Si la valeur est "true", ignore silencieusement toutes les options non reconnues.
Renvoie
true si toutes les options et tous les arguments autres que les options ont été correctement analysés ; false si une option n'est pas reconnue ou si l'une des fonctions du gestionnaire a échoué (c'est-à-dire si elle renvoie la valeur "false").

Les définitions d'options sont transmises à ParseArgs() sous la forme d'un tableau de structures OptionSet (optSets). Chaque OptionSet contient un tableau de définitions d'options et une fonction de gestionnaire. ParseArgs() traite les arguments d'option dans l'ordre donné, en appelant la fonction de gestionnaire correspondante pour chaque option reconnue. Une fois toutes les options analysées, une fonction de gestionnaire distincte (nonOptArgHandler) est appelée une seule fois pour traiter les arguments restants.

ENSEMBLES D'OPTIONS

Un OptionSet contient un ensemble de définitions d'options ainsi qu'un pointeur vers une fonction de gestionnaire qui est appelée lorsque l'une des options associées est rencontrée. Les ensembles d'options contiennent également un texte d'aide décrivant la syntaxe et l'objectif de chaque option (voir l'aide sur les options ci-dessous). Les ensembles d'options sont conçus pour permettre la création de collections réutilisables d'options associées. Cela simplifie les efforts nécessaires pour gérer plusieurs applications qui acceptent des options similaires (par exemple, des applications de test).

Deux modèles permettent de définir OptionSetsone : soit initialiser une instance de la struct OptionSet elle-même, par exemple, en tant que global statique, soit la sous-classe OptionSetBase et fournir un constructeur. Ce dernier utilise une fonction HandleOption() virtuelle pure pour déléguer la gestion des options à la sous-classe.

Les listes d'OptionSets sont transmises à la fonction ParseArgs() en tant que tableau de pointeurs terminé par une valeur NULL. E.g.:

static OptionSet gToolOptions =
{
    HandleOption,        // handler function
    gToolOptionDefs,  // array of option definitions
    "GENERAL OPTIONS",   // help group
    gToolOptionHelp   // option help text
};

static OptionSet *gOptionSets[] =
{
    &gToolOptions,
    &gNetworkOptions,
    &gTestingOptions,
    &gHelpOptions,
    NULL
};

int main(int argc, char *argv[])
{
    if (!ParseArgs("test-app", argc, argv, gOptionSets))
    {
        ...
    }
}

DÉFINITIONS DES OPTIONS

Les options sont définies à l'aide de la structure OptionDef. Les définitions d'options sont organisées sous la forme d'un tableau d'éléments OptionDef, où chaque élément contient: le nom de l'option, un ID entier permettant d'identifier l'option et si l'option attend/autorise un argument. La fin du tableau d'options est signalée par un champ "Nom NULL". E.g.:

enum
{
    kOpt_Listen = 1000,
    kOpt_Length,
    kOpt_Count,
};

static OptionDef gToolOptionDefs[] =
{
    // NAME         REQUIRES/ALLOWS ARG?  ID/SHORT OPTION CHAR
    // ============================================================
    {  "listen",    kNoArgument,          kOpt_Listen     },
    {  "length",    kArgumentRequired,    kOpt_Length     },
    {  "count",     kArgumentRequired,    kOpt_Count      },
    {  "num",       kArgumentRequired,    kOpt_Count      }, // alias for --count
    {  "debug",     kArgumentOptional,    'd'             },
    {  "help",      kNoArgument,          'h'             },
    {  NULL }
};

ID DES OPTIONS

Les ID d'option identifient les options dans le code qui les gère (fonction OptionHandler). Les ID d'option sont relatifs à l'ensemble d'options OptionSet dans lequel ils apparaissent. Ils peuvent donc être réutilisés dans différents ensembles d'options (voir toutefois les OPTIONS COURTES ci-dessous). La convention courante consiste à commencer à numéroter les ID d'option de numérotation à 1 000, mais vous pouvez utiliser n'importe quel nombre supérieur à 128. Vous pouvez créer des options d'alias en utilisant le même identifiant d'option avec des noms d'option différents.

OPTIONS COURTES

Contrairement à getopt_long(3), ParseArgs() n'utilise pas de chaîne distincte spécifiant la liste de caractères d'option courts. À la place, toute option dont la valeur d'ID est comprise dans la plage de caractères ASCII graphiques permet d'utiliser ce caractère comme option abrégée.

La fonction ParseArgs() nécessite que les caractères d'option courts soient uniques dans tous les OptionsSets. C'est pourquoi l'utilisation d'options courtes est déconseillée pour les OptionsSets partagés entre les programmes en raison du risque important de collision. Vous pouvez réutiliser les caractères des options courtes dans un seul OptionSet pour permettre la création de noms d'options longs d'alias.

AIDE SUR LES OPTIONS

Chaque OptionSet contient une chaîne OptionHelp qui décrit l'objectif et la syntaxe des options associées. Ces chaînes sont utilisées par la fonction PrintOptionHelp() pour générer des informations sur l'utilisation des options.

Par convention, les chaînes d'aide d'option se composent d'un exemple de syntaxe suivi d'une description textuelle de l'option. Si l'option comporte une version courte ou un nom d'alias, celui-ci est inséré avant le nom long principal. Par souci de cohérence, les lignes de syntaxe sont en retrait avec deux espaces, tandis que les lignes de description sont en retrait de sept espaces. Une seule ligne vide suit la description de chaque option, y compris la dernière.

E.g.:

static const char *const gToolOptionHelp =
    "  --listen\n"
    "       Listen and respond to requests sent from another node.\n"
    "\n"
    "  --length \n"
    "       Send requests with the specified number of bytes in the payload.\n"
    "\n"
    "  --num, --count \n"
    "       Send the specified number of requests and exit.\n"
    "\n"
    "  -d, --debug []\n"
    "       Set debug logging to the given level. (Default: 1)\n"
    "\n"
    "  -h, --help\n"
    "       Print help information.\n"
    "\n";

GROUPES D'AIDE POUR LES OPTIONS

Les ensembles d'options contiennent une chaîne HelpGroupName qui permet de regrouper les options dans la sortie d'aide. La fonction PrintOptionHelp() utilise HelpGroupName comme titre de section dans le résultat d'utilisation généré. Si plusieurs OptionsSets ont le même HelpGroupName, PrintOptionHelp() imprimera l'aide sur les options des différents OptionsSets ensemble sous un titre de section commun.

ParseArgs

bool ParseArgs(
  const char *progName,
  int argc,
  char *argv[],
  OptionSet *optSets[],
  NonOptionArgHandlerFunct nonOptArgHandler
)

ParseArgs

bool ParseArgs(
  const char *progName,
  int argc,
  char *argv[],
  OptionSet *optSets[]
)

ParseArgsFromEnvVar

bool ParseArgsFromEnvVar(
  const char *progName,
  const char *varName,
  OptionSet *optSets[],
  NonOptionArgHandlerFunct nonOptArgHandler,
  bool ignoreUnknown
)

Analyser un ensemble d'arguments à partir d'une variable d'environnement nommée

ParseArgsFromEnvVar() lit une variable d'environnement nommée et la transmet à ParseArgsFromString() pour analyse. Si la variable d'environnement n'est pas définie, la fonction n'a aucun effet.

Détails
Paramètres
[in] progName
Nom du programme ou du contexte dans lequel les arguments sont analysés. Cette chaîne sera utilisée pour préfixer les messages d'erreur et les avertissements.
[in] varName
Nom de la variable d'environnement.
[in] optSets
Liste de pointeurs vers des structures OptionSet qui définissent les options légales. La liste fournie doit se terminer par une valeur NULL.
[in] nonOptArgHandler
Pointeur vers une fonction qui sera appelée une fois l'analyse des options terminée, avec tous les autres arguments autres que les options . La fonction est appelée, qu'il reste ou non des arguments. Si une valeur NULL est transmise, ParseArgs() signale une erreur si des arguments autres qu'une option sont présents.
[in] ignoreUnknown
Si la valeur est "true", ignore silencieusement toutes les options non reconnues.
Renvoie
true si toutes les options et tous les arguments autres que les options ont été correctement analysés, ou si la variable d'environnement spécifiée n'est pas définie ; false si une option n'est pas reconnue, si l'une des fonctions de gestionnaire a échoué (c'est-à-dire si elle a renvoyé la valeur "false") ou si une erreur interne s'est produite.

ParseArgsFromEnvVar

bool ParseArgsFromEnvVar(
  const char *progName,
  const char *varName,
  OptionSet *optSets[]
)

ParseArgsFromEnvVar

bool ParseArgsFromEnvVar(
  const char *progName,
  const char *varName,
  OptionSet *optSets[],
  NonOptionArgHandlerFunct nonOptArgHandler
)

ParseArgsFromString

bool ParseArgsFromString(
  const char *progName,
  const char *argStr,
  OptionSet *optSets[],
  NonOptionArgHandlerFunct nonOptArgHandler,
  bool ignoreUnknown
)

Analyse un ensemble d'arguments à partir d'une chaîne donnée.

ParseArgsFromString() divise une chaîne donnée (argStr) en un ensemble d'arguments et les analyse à l'aide de la fonction ParseArgs().

Détails
Paramètres
[in] progName
Nom du programme ou du contexte dans lequel les arguments sont analysés. Cette chaîne sera utilisée pour préfixer les messages d'erreur et les avertissements.
[in] argStr
Chaîne contenant les options et les arguments à analyser.
[in] optSets
Liste de pointeurs vers des structures OptionSet qui définissent les options légales. La liste fournie doit se terminer par une valeur NULL.
[in] nonOptArgHandler
Pointeur vers une fonction qui sera appelée une fois l'analyse des options terminée, avec tous les autres arguments autres que les options . La fonction est appelée, qu'il reste ou non des arguments. Si une valeur NULL est transmise, ParseArgs() signale une erreur si des arguments autres qu'une option sont présents.
[in] ignoreUnknown
Si la valeur est "true", ignore silencieusement toutes les options non reconnues.
Renvoie
true si toutes les options et tous les arguments autres que les options ont été correctement analysés ; false si une option n'a pas été reconnue, si l'une des fonctions du gestionnaire a échoué (c'est-à-dire si elle renvoie la valeur "false") ou si une erreur interne s'est produite.

La syntaxe des chaînes d'entrée est semblable à celle de la commande shell Unix, mais avec un schéma d'ajout de guillemets simplifié. Notamment :

  • Les arguments sont délimités par des espaces blancs, sauf si ces derniers sont entre guillemets ou échappés.
  • Une barre oblique inverse échappe le caractère suivant, ce qui le traite comme un caractère normal. La barre oblique inverse elle-même est supprimée.
  • Les sous-chaînes de guillemets simples ou doubles commencent/se terminent entre guillemets. Dans une sous-chaîne, les seuls caractères spéciaux sont la barre oblique inverse, qui protège le caractère suivant et le guillemet de fin correspondant. Les guillemets de début et de fin sont supprimés.

E.g.:

--listen --count 10 --sw-version '1.0 (DEVELOPMENT)' "--hostname=nest.com"

ParseArgsFromString

bool ParseArgsFromString(
  const char *progName,
  const char *argStr,
  OptionSet *optSets[],
  NonOptionArgHandlerFunct nonOptArgHandler
)

ParseArgsFromString

bool ParseArgsFromString(
  const char *progName,
  const char *argStr,
  OptionSet *optSets[]
)

ParseBoolean

bool ParseBoolean(
  const char *str,
  bool & output
)

Analyser une chaîne en tant que valeur booléenne.

Cette fonction accepte les valeurs d'entrée suivantes (non sensibles à la casse): "true", "yes", "t", "y", "1", "false", "no", "f", "n", "0".

Détails
Paramètres
[in] str
Pointeur vers une chaîne C se terminant par une valeur NULL qui représente la valeur à analyser.
[out] output
Référence au stockage d'une valeur booléenne dans laquelle la valeur analysée est stockée en cas de réussite.
Renvoie
"true" en cas de réussite, sinon, "false" en cas d'échec.

ParseFabricId

bool ParseFabricId(
  const char *str,
  uint64_t & fabricId,
  bool allowReserved
)

Analyser un ID de tissu Weave au format texte.

La fonction ParseFabricId() accepte un identifiant de fabric 64 bits fourni au format hexadécimal, avec ou sans un "0x" de début.

Détails
Paramètres
[in] str
Pointeur vers une chaîne C se terminant par une valeur NULL contenant l'ID de la fabric à analyser.
[out] output
Référence à une lvalue uint64_t dans laquelle la valeur analysée est stockée en cas de réussite.
[in] allowReserved
Si la valeur est "true", autorise l'analyse des identifiants de fabric dans la plage réservée.
Renvoie
"true" si la valeur a bien été analysée, "false" dans le cas contraire.

ParseHexString

bool ParseHexString(
  const char *hexStr,
  uint32_t strLen,
  uint8_t *outBuf,
  uint32_t outBufSize,
  uint32_t & outDataLen
)

Analyser une chaîne d'octets données sous forme hexadécimale

ParseHexString() s'attend à ce que l'entrée se présente sous la forme de paires de chiffres hexadécimaux (majuscules ou minuscules). Les paires hexadécimales peuvent éventuellement être séparées par l'un des caractères suivants: deux-points, point-virgule, virgule, point ou tiret. De plus, les espaces blancs n'importe où dans la chaîne d'entrée sont ignorés.

Détails
Paramètres
[in] hexStr
Pointeur vers la chaîne à analyser.
[in] strLen
Nombre de caractères hexStr à analyser.
[in] outBuf
Pointeur vers un tampon dans lequel les octets analysés seront stockés.
[in] outBufSize
Taille du tampon indiqué par outBuf.
[out] outDataLen
Référence à un entier qui recevra le nombre total d'octets analysés. Si la valeur "outBuf" n'est pas assez grande pour contenir le nombre d'octets donné, outDataLen est défini sur UINT32_MAX.
Renvoie
"true" si la valeur a bien été analysée ; "false" si les données d'entrée sont incorrectes ou si outBuf est trop petit.

ParseIPAddress

bool ParseIPAddress(
  const char *str,
  IPAddress & output
)

Analyser une adresse IP sous forme de texte

Détails
Paramètres
[in] str
Pointeur vers une chaîne C se terminant par une valeur NULL contenant l'adresse à analyser.
[out] output
Référence à un objet IPAddress dans lequel la valeur analysée est stockée en cas de réussite.
Renvoie
"true" si la valeur a bien été analysée, "false" dans le cas contraire.

ParseInt

bool ParseInt(
  const char *str,
  uint64_t & output,
  int base
)

Analysez une chaîne et tentez de la convertir en entier non signé de 64 bits, en appliquant l'interprétation appropriée en fonction du paramètre de base.

Détails
Paramètres
[in] str
Pointeur vers une chaîne C terminée par une valeur NULL représentant l'entier à analyser.
[out] output
Référence de stockage pour un entier non signé de 64 bits dans lequel la valeur analysée est stockée en cas de réussite.
[in] base
Base selon laquelle la chaîne doit être interprétée et analysée. Si vous obtenez 0 ou 16, la chaîne peut être hexadécimale et commencer par "0x". Dans le cas contraire, un 0 est implicite comme 10, sauf si un 0 initial est rencontré alors que 8 est implicite.
Renvoie
"true" en cas de réussite, sinon, "false" en cas d'échec.

ParseInt

bool ParseInt(
  const char *str,
  uint32_t & output,
  int base
)

Analysez une chaîne et tentez de la convertir en entier non signé de 32 bits, en appliquant l'interprétation appropriée en fonction du paramètre de base.

Détails
Paramètres
[in] str
Pointeur vers une chaîne C terminée par une valeur NULL représentant l'entier à analyser.
[out] output
Référence de stockage pour un entier non signé de 32 bits dans lequel la valeur analysée est stockée en cas de réussite.
[in] base
Base selon laquelle la chaîne doit être interprétée et analysée. Si vous obtenez 0 ou 16, la chaîne peut être hexadécimale et commencer par "0x". Dans le cas contraire, un 0 est implicite comme 10, sauf si un 0 initial est rencontré alors que 8 est implicite.
Renvoie
"true" en cas de réussite, sinon, "false" en cas d'échec.

ParseInt

bool ParseInt(
  const char *str,
  int32_t & output,
  int base
)

Analysez une chaîne et tentez de la convertir en entier signé de 32 bits, en appliquant l'interprétation appropriée en fonction du paramètre de base.

Détails
Paramètres
[in] str
Pointeur vers une chaîne C terminée par une valeur NULL représentant l'entier à analyser.
[out] output
Référence de stockage pour un entier signé de 32 bits dans lequel la valeur analysée est stockée en cas de réussite.
[in] base
Base selon laquelle la chaîne doit être interprétée et analysée. Si vous obtenez 0 ou 16, la chaîne peut être hexadécimale et commencer par "0x". Dans le cas contraire, un 0 est implicite comme 10, sauf si un 0 initial est rencontré alors que 8 est implicite.
Renvoie
"true" en cas de réussite, sinon, "false" en cas d'échec.

ParseInt

bool ParseInt(
  const char *str,
  uint64_t & output
)

Analysez et essayez de convertir une chaîne interprétée comme une valeur décimale en un entier non signé de 64 bits, en appliquant l'interprétation appropriée en fonction du paramètre de base.

Détails
Paramètres
[in] str
Pointeur vers une chaîne C terminée par une valeur NULL représentant l'entier à analyser.
[out] output
Référence de stockage pour un entier non signé de 64 bits dans lequel la valeur analysée est stockée en cas de réussite.
Renvoie
"true" en cas de réussite, sinon, "false" en cas d'échec.

ParseInt

bool ParseInt(
  const char *str,
  uint32_t & output
)

Analysez et essayez de convertir une chaîne interprétée comme une valeur décimale en un entier non signé de 32 bits, en appliquant l'interprétation appropriée en fonction du paramètre de base.

Détails
Paramètres
[in] str
Pointeur vers une chaîne C terminée par une valeur NULL représentant l'entier à analyser.
[out] output
Référence de stockage pour un entier non signé de 32 bits dans lequel la valeur analysée est stockée en cas de réussite.
Renvoie
"true" en cas de réussite, sinon, "false" en cas d'échec.

ParseInt

bool ParseInt(
  const char *str,
  int32_t & output
)

Analysez une chaîne interprétée comme une valeur décimale en un entier signé de 32 bits et essayez de la convertir, en appliquant l'interprétation appropriée en fonction du paramètre de base.

Détails
Paramètres
[in] str
Pointeur vers une chaîne C terminée par une valeur NULL représentant l'entier à analyser.
[out] output
Référence de stockage pour un entier signé de 32 bits dans lequel la valeur analysée est stockée en cas de réussite.
Renvoie
"true" en cas de réussite, sinon, "false" en cas d'échec.

ParseInt

bool ParseInt(
  const char *str,
  uint16_t & output
)

Analysez et tentez de convertir une chaîne interprétée comme une valeur décimale en un entier non signé de 16 bits, en appliquant l'interprétation appropriée en fonction du paramètre de base.

Détails
Paramètres
[in] str
Pointeur vers une chaîne C terminée par une valeur NULL représentant l'entier à analyser.
[out] output
Référence de stockage pour un entier non signé de 16 bits dans lequel la valeur analysée est stockée en cas de réussite.
Renvoie
"true" en cas de réussite, sinon, "false" en cas d'échec.

ParseInt

bool ParseInt(
  const char *str,
  int16_t & output
)

Analysez et tentez de convertir une chaîne interprétée comme une valeur décimale en un entier signé de 16 bits, en appliquant l'interprétation appropriée en fonction du paramètre de base.

Détails
Paramètres
[in] str
Pointeur vers une chaîne C terminée par une valeur NULL représentant l'entier à analyser.
[out] output
Référence de stockage pour un entier signé de 16 bits dans lequel la valeur analysée est stockée en cas de réussite.
Renvoie
"true" en cas de réussite, sinon, "false" en cas d'échec.

ParseInt

bool ParseInt(
  const char *str,
  uint8_t & output
)

Analysez et essayez de convertir une chaîne interprétée comme une valeur décimale en un entier non signé de 8 bits, en appliquant l'interprétation appropriée en fonction du paramètre de base.

Détails
Paramètres
[in] str
Pointeur vers une chaîne C terminée par une valeur NULL représentant l'entier à analyser.
[out] output
Référence de stockage pour un entier non signé de 8 bits dans lequel la valeur analysée est stockée en cas de réussite.
Renvoie
"true" en cas de réussite, sinon, "false" en cas d'échec.

ParseNodeId

bool ParseNodeId(
  const char *str,
  uint64_t & nodeId
)

Analyser un ID de nœud Weave au format texte.

La fonction ParseNodeId() accepte soit un ID de nœud de 64 bits au format hexadécimal (avec ou sans "0x" au début), ou les mots "any" ou "all" qui sont interprétés comme signifiant l'ID de nœud "N'importe lequel" (0xFFFFFFFFFFFFFFFF).

Détails
Paramètres
[in] str
Pointeur vers une chaîne C se terminant par une valeur NULL contenant l'ID du nœud à analyser.
[out] output
Référence à une lvalue uint64_t dans laquelle la valeur analysée est stockée en cas de réussite.
Renvoie
"true" si la valeur a bien été analysée, "false" dans le cas contraire.

ParseSubnetId

bool ParseSubnetId(
  const char *str,
  uint16_t & subnetId
)

Analyser une chaîne et tenter de la convertir en ID de sous-réseau non signé de 16 bits en interprétant la chaîne comme du code hexadécimal.

Détails
Paramètres
[in] str
Pointeur vers une chaîne C se terminant par une valeur NULL, qui représente l'ID de sous-réseau, au format hexadécimal, à analyser.
[in,out] subnetId
Référence au stockage d'un entier non signé de 16 bits, vers lequel la valeur de l'ID de sous-réseau analysée est stockée en cas de réussite.
Renvoie
"true" en cas de réussite, sinon, "false" en cas d'échec.

PrintOptionHelp

void PrintOptionHelp(
  OptionSet *optSets[],
  FILE *s
)

Imprime le texte d'aide d'une liste d'options spécifiée dans un flux.

Détails
Paramètres
[in] optSets
Liste de pointeurs vers des structures OptionSet contenant le texte d'aide à imprimer.
[in] s
Flux FILE dans lequel le texte d'aide doit être imprimé.

PutStringWithBlankLine

void PutStringWithBlankLine(
  FILE *s,
  const char *str
)

PutStringWithNewLine

void PutStringWithNewLine(
  FILE *s,
  const char *str
)

SplitArgs

int32_t SplitArgs(
  char *argStr,
  char **& argList,
  char *initialArg
)