nl::ArgParser

Resumen

Enumeraciones

OptionArgumentType enum
Define los requisitos del argumento para una opción de línea de comandos.

Typedefs

NonOptionArgHandlerFunct)(const char *progName, int argc, char *argv[]) typedef
bool(*
Una función a la que se puede llamar para controlar cualquier argumento de línea de comandos restante que no sea de opciones.
OptionHandlerFunct)(const char *progName, OptionSet *optSet, int id, const char *name, const char *arg) typedef
bool(*
Una función a la que se puede llamar para controlar un conjunto de opciones de línea de comandos.

Variables

PrintArgError = DefaultPrintArgError)(const char *msg,...)
void(*
Es el puntero para la función que se usa con el objetivo de imprimir errores que ocurren durante el análisis del argumento.
gActiveOptionSets = NULL
Es la lista de OptionSets pasadas a la llamada ParseArgs() actualmente activa.

remotas

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
Imprime un mensaje de error asociado con el análisis del argumento.
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
Analiza un conjunto de argumentos de estilo de línea de comandos y llama a las funciones de control para procesar cada opción y argumento que no sea de opciones.
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
Analiza un conjunto de argumentos de una variable de entorno con nombre.
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
Analiza un conjunto de argumentos de una string determinada.
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
Analiza una cadena como un valor booleano.
ParseFabricId(const char *str, uint64_t & fabricId, bool allowReserved)
bool
Analiza un ID de tela de Weave en forma de texto.
ParseHexString(const char *hexStr, uint32_t strLen, uint8_t *outBuf, uint32_t outBufSize, uint32_t & outDataLen)
bool
Analiza una string de bytes expresada en formato hexadecimal.
ParseIPAddress(const char *str, IPAddress & output)
bool
Analiza una dirección IP en forma de texto.
ParseInt(const char *str, uint64_t & output, int base)
bool
Analiza y trata de convertir una cadena en un número entero de 64 bits sin firma y aplica la interpretación adecuada según el parámetro base.
ParseInt(const char *str, uint32_t & output, int base)
bool
Analiza y trata de convertir una cadena en un número entero de 32 bits sin firma y aplica la interpretación adecuada según el parámetro base.
ParseInt(const char *str, int32_t & output, int base)
bool
Analiza y trata de convertir una cadena en un número entero de 32 bits con firma y aplica la interpretación adecuada según el parámetro base.
ParseInt(const char *str, uint64_t & output)
bool
Analiza y trata de convertir una cadena interpretada como un valor decimal en un número entero de 64 bits sin firma. Para ello, aplica la interpretación adecuada según el parámetro base.
ParseInt(const char *str, uint32_t & output)
bool
Analiza y trata de convertir una cadena interpretada como un valor decimal en un número entero de 32 bits sin firma. Para ello, aplica la interpretación adecuada según el parámetro base.
ParseInt(const char *str, int32_t & output)
bool
Analiza y trata de convertir una cadena interpretada como un valor decimal en un número entero de 32 bits con signo y aplica la interpretación adecuada según el parámetro base.
ParseInt(const char *str, uint16_t & output)
bool
Analiza y trata de convertir una cadena interpretada como un valor decimal en un número entero de 16 bits sin firma y aplica la interpretación adecuada según el parámetro base.
ParseInt(const char *str, int16_t & output)
bool
Analiza y trata de convertir una cadena interpretada como un valor decimal en un número entero de 16 bits con signo y aplica la interpretación adecuada según el parámetro base.
ParseInt(const char *str, uint8_t & output)
bool
Analiza y trata de convertir una cadena interpretada como valor decimal en un número entero de 8 bits sin firma. Para ello, aplica la interpretación adecuada según el parámetro base.
ParseNodeId(const char *str, uint64_t & nodeId)
bool
Analiza un ID de nodo de Weave en forma de texto.
ParseSubnetId(const char *str, uint16_t & subnetId)
bool
Analiza y trata de convertir una cadena en un ID de subred de 16 bits sin firma. Para ello, interpreta la cadena como hexadecimal.
PrintOptionHelp(OptionSet *optSets[], FILE *s)
void
Imprime el texto de ayuda de una lista específica de opciones en una transmisión.
PutStringWithBlankLine(FILE *s, const char *str)
void
PutStringWithNewLine(FILE *s, const char *str)
void
SplitArgs(char *argStr, char **& argList, char *initialArg)
int32_t

Clases

nl::ArgParser::HelpOptions

OptionSet común para manejar opciones informativas (ayuda, versión)

nl::ArgParser::OptionSetBase

Un OptionSet en el que el controlador es una función virtual.

Structs

nl::ArgParser::OptionDef

Define una opción de línea de comandos.

nl::ArgParser::OptionSet

Define un grupo de opciones de línea de comandos reutilizables y relacionadas de forma lógica.

Enumeraciones

OptionArgumentType

 OptionArgumentType

Define los requisitos del argumento para una opción de línea de comandos.

Typedefs

NonOptionArgHandlerFunct

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

Una función a la que se puede llamar para controlar cualquier argumento de línea de comandos restante que no sea de opciones.

OptionHandlerFunct

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

Una función a la que se puede llamar para controlar un conjunto de opciones de línea de comandos.

Variables

PrintArgError

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

Es el puntero para la función que se usa con el objetivo de imprimir errores que ocurren durante el análisis del argumento.

Las aplicaciones deben llamar a PrintArgError() para informar errores en sus funciones de control de argumentos de opción y no opciones, en lugar de imprimir directamente en stdout/stderr.

El valor predeterminado es un puntero para la función DefaultPrintArgError().

gActiveOptionSets

OptionSet ** gActiveOptionSets = NULL

Es la lista de OptionSets pasadas a la llamada ParseArgs() actualmente activa.

Este valor será NULL cuando no haya ninguna llamada a ParseArgs() en curso.

remotas

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,
  ...
)

Imprime un mensaje de error asociado con el análisis del argumento.

Es la función predeterminada que se usa para imprimir mensajes de error que surgen debido al análisis de argumentos.

Detalles
Parámetros
[in] msg
El mensaje que se imprimirá.

Las aplicaciones deben llamar a través del puntero de la función PrintArgError, en lugar de llamar a esta función directamente.

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
)

Analiza un conjunto de argumentos de estilo de línea de comandos y llama a las funciones de control para procesar cada opción y argumento que no sea de opciones.

ParseArgs() toma una lista de argumentos (argv) y los analiza según un conjunto de definiciones de opciones proporcionadas. La función admite opciones largas (opt) y cortas (-o), e implementa la misma sintaxis de opción que la función getopt_long(3) de GNU.

Detalles
Parámetros
[in] progName
El nombre del programa o contexto en el que se analizan los argumentos. Esta cadena se utilizará para anteponer los mensajes de error y las advertencias.
[in] argc
La cantidad de argumentos que se analizarán, más 1.
[in] argv
Un array de cadenas de argumento para analizar. La longitud del array debe ser 1 mayor que el valor especificado para argc, y argv[argc] debe configurarse como NULL. El análisis de argumentos comienza con el segundo elemento de array (argv[1]); se ignora el elemento 0.
[in] optSets
Es una lista de punteros a estructuras OptionSet que definen las opciones legales. La lista proporcionada debe terminar con un valor NULL.
[in] nonOptArgHandler
Un puntero a una función que se llamará una vez que se complete el análisis de la opción con los argumentos restantes que no sean opciones . Se llama a la función sin importar si quedan argumentos. Si se pasa un valor NULL, ParseArgs() informará un error si hay argumentos que no sean opciones presentes.
[in] ignoreUnknown
Si es verdadero, ignora de forma silenciosa las opciones no reconocidas.
Qué muestra
true si todas las opciones y los argumentos que no son opciones se analizaron correctamente; false si no se reconoció una opción o si una de las funciones del controlador falló (es decir, se mostró un valor falso).

Las definiciones de opciones se pasan a ParseArgs() como un array de estructuras OptionSet (optSets). Cada OptionSet contiene un array de definiciones de opciones y una función de controlador. ParseArgs() procesa los argumentos de la opción en el orden dado y llama a la función del controlador correspondiente para cada opción reconocida. Una vez que se analizaron todas las opciones, se llama una vez a una función separada que no es controlador de opciones (nonOptArgHandler) para procesar los argumentos restantes.

CONFIGURACIÓN DE OPCIONES

Un OptionSet contiene un conjunto de definiciones de opciones junto con un puntero a una función de controlador que se llamará cuando se encuentre una de las opciones asociadas. Los conjuntos de opciones también contienen texto de ayuda que describe la sintaxis y el propósito de cada opción (consulta la AYUDA DE LA OPCIÓN a continuación). Los conjuntos de opciones están diseñados para permitir la creación de colecciones reutilizables de opciones relacionadas. Esto simplifica el esfuerzo necesario de mantener múltiples aplicaciones que aceptan opciones similares (p.ej., aplicaciones de prueba).

Existen dos patrones para definir OpciónSetsone que puede inicializar una instancia de la estructura OptionSet, p.ej., como un global estático, o una subclase OptionSetBase y proporcionar un constructor. Esta última usa una función HandleOption() virtual pura para delegar el control de opciones a la subclase.

Las listas de OptionSets se pasan a la función ParseArgs() como un array de punteros terminado en 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))
    {
        ...
    }
}

DEFINICIONES DE LAS OPCIONES

Las opciones se definen con la estructura OptionDef. Las definiciones de las opciones se organizan como un array de elementos OptionDef, en el que cada elemento contiene: el nombre de la opción, un ID de número entero que se usa para identificar la opción, y si la opción espera o permite un argumento. El final del array de opciones se indica con un campo NULL Name. 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 }
};

IDS DE OPCIÓN

Los IDs de opción identifican opciones en el código que los maneja (la función OptionHandler). Los IDs de opción están relacionados con el OptionSet en el que aparecen y, por lo tanto, se pueden volver a usar en diferentes OptionsSets (sin embargo, consulta las OPCIONES CORTAS a continuación). La convención habitual es comenzar a numerar los ID de las opciones en 1000; sin embargo, se puede usar cualquier número superior a 128. Se pueden crear opciones de alias usando el mismo ID de opción con diferentes nombres de opción.

OPCIONES CORTAS

A diferencia de getopt_long(3), ParseArgs() no toma una cadena separada que especifique la lista de caracteres de opciones cortos. En cambio, cualquier opción cuyo valor de ID se encuentre dentro del rango de caracteres ASCII gráficos permitirá que ese carácter se use como una opción corta.

ParseArgs() requiere que los caracteres de opciones cortos sean únicos en todos los OptionSets. Debido a esto, no se recomienda el uso de opciones cortas para ningún Conjunto de opciones que se comparta entre programas debido a la gran posibilidad de colisiones. Los caracteres de opciones cortas se pueden volver a usar dentro de un solo OptionSet para permitir la creación de nombres de opciones largos de alias.

AYUDA DE OPCIÓN

Cada OptionSet contiene una string OptionHelp que describe el propósito y la sintaxis de las opciones asociadas. La función PrintOptionHelp() usa estas cadenas para generar información de uso de opciones.

Por convención, las cadenas de ayuda opcional constan de un ejemplo de sintaxis seguido de una descripción textual de la opción. Si la opción tiene una versión corta o un nombre de alias, se muestra antes del nombre largo principal. Para mantener la coherencia, las líneas de sintaxis tienen una sangría de 2 espacios, mientras que las líneas descriptivas tienen una sangría de 7 espacios. Después de la descripción de cada opción, incluida la última, se agrega una sola línea en blanco.

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";

GRUPOS DE AYUDA DE OPCIONES

OpciónSets contiene una cadena HelpGroupName que se usa para agrupar opciones en el resultado de ayuda. La función PrintOptionHelp() usa HelpGroupName como título de sección en el resultado de uso generado. Si varios OptionSets tienen el mismo HelpGroupName, PrintOptionHelp() imprimirá la ayuda de opciones para los diferentes OptionsSets juntos bajo un título de sección en común.

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
)

Analiza un conjunto de argumentos de una variable de entorno con nombre.

ParseArgsFromEnvVar() lee una variable de entorno denominada y pasa el valor a ParseArgsFromString() para su análisis. Si la variable de entorno no está configurada, la función no realiza ninguna acción.

Detalles
Parámetros
[in] progName
El nombre del programa o contexto en el que se analizan los argumentos. Esta cadena se utilizará para anteponer los mensajes de error y las advertencias.
[in] varName
El nombre de la variable de entorno.
[in] optSets
Es una lista de punteros a estructuras OptionSet que definen las opciones legales. La lista proporcionada debe terminar con un valor NULL.
[in] nonOptArgHandler
Un puntero a una función que se llamará una vez que se complete el análisis de la opción con los argumentos restantes que no sean opciones . Se llama a la función sin importar si quedan argumentos. Si se pasa un valor NULL, ParseArgs() informará un error si hay argumentos que no sean opciones presentes.
[in] ignoreUnknown
Si es verdadero, ignora de forma silenciosa las opciones no reconocidas.
Qué muestra
true si todas las opciones y los argumentos que no son opciones se analizaron correctamente o si no se configuró la variable de entorno especificada; false si no se reconoció una opción, si una de las funciones del controlador falló (es decir, si se mostró un valor falso) o si se produjo un error interno

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
)

Analiza un conjunto de argumentos de una string determinada.

ParseArgsFromString() divide una cadena determinada (argStr) en un conjunto de argumentos y analiza los argumentos con la función ParseArgs().

Detalles
Parámetros
[in] progName
El nombre del programa o contexto en el que se analizan los argumentos. Esta cadena se utilizará para anteponer los mensajes de error y las advertencias.
[in] argStr
Es una cadena que contiene opciones y argumentos para analizar.
[in] optSets
Es una lista de punteros a estructuras OptionSet que definen las opciones legales. La lista proporcionada debe terminar con un valor NULL.
[in] nonOptArgHandler
Un puntero a una función que se llamará una vez que se complete el análisis de la opción con los argumentos restantes que no sean opciones . Se llama a la función sin importar si quedan argumentos. Si se pasa un valor NULL, ParseArgs() informará un error si hay argumentos que no sean opciones presentes.
[in] ignoreUnknown
Si es verdadero, ignora de forma silenciosa las opciones no reconocidas.
Qué muestra
true si todas las opciones y los argumentos que no son opciones se analizaron correctamente; false si no se reconoció una opción, si una de las funciones del controlador falló (es decir, si se mostró un valor falso) o si se produjo un error interno

La sintaxis de las cadenas de entrada es similar a la sintaxis del comando de shell de Unix, pero con un esquema de comillas simplificado. En particular, haz lo siguiente:

  • Los argumentos están delimitados por espacios en blanco, a menos que estén entre comillas o escapes.
  • Una barra invertida escapa el siguiente carácter, lo que hace que se lo trate como un carácter normal. La barra inversa en sí se quita.
  • Comillas simples o dobles que comienzan o terminan en subcadenas entrecomilladas Dentro de una substring, los únicos caracteres especiales son la barra inversa, que se escapa del carácter siguiente y de la comilla final correspondiente. Se quitan los caracteres de comillas de inicio y fin.

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
)

Analiza una cadena como un valor booleano.

Esta función acepta los siguientes valores de entrada (no distingue mayúsculas de minúsculas): “true”, “yes”, “t”, “y”, “1”, “false”, “no”, “f”, “n” y “0”.

Detalles
Parámetros
[in] str
Un puntero a una string C terminada en NULL que representa el valor que se debe analizar.
[out] output
Referencia al almacenamiento para un bool al que se almacenará el valor analizado cuando se realice de forma correcta.
Qué muestra
Es verdadero en caso de éxito; de lo contrario, es falso.

ParseFabricId

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

Analiza un ID de tela de Weave en forma de texto.

La función ParseFabricId() acepta un ID de tela de 64 bits en formato hexadecimal, con o sin un “0x” inicial.

Detalles
Parámetros
[in] str
Un puntero para una string C terminada en NULL que contiene el ID de tejido que se analizará.
[out] output
Es una referencia a un valor uint64_t en el que el valor analizado se almacenará cuando se realice de forma correcta.
[in] allowReserved
Si es verdadero, permite el análisis de los ID de tejidos en el rango reservado.
Qué muestra
Es verdadero si el valor se analizó correctamente y falso si no lo es.

ParseHexString

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

Analiza una string de bytes expresada en formato hexadecimal.

ParseHexString() espera que la entrada tenga el formato de pares de dígitos hexadecimales (mayúsculas o minúsculas). De manera opcional, los pares hexadecimales se pueden separar con cualquiera de los siguientes caracteres: dos puntos, punto y coma, coma, punto o guion. Además, se ignoran los caracteres de espacio en blanco en cualquier parte de la string de entrada.

Detalles
Parámetros
[in] hexStr
Un puntero para la cadena que se analizará.
[in] strLen
La cantidad de caracteres en hexStr que se analizarán.
[in] outBuf
Un puntero para un búfer en el que se almacenarán los bytes de análisis.
[in] outBufSize
Es el tamaño del búfer al que apunta outBuf.
[out] outDataLen
Referencia a un número entero que recibirá la cantidad total de bytes analizados. En el caso de que outBuf no sea lo suficientemente grande como para contener el número especificado de bytes, outDataLen se establecerá en UINT32_MAX.
Qué muestra
Es verdadero si el valor se analizó correctamente. Es falso si los datos de entrada tienen errores de formato o si outBuf es demasiado pequeño.

ParseIPAddress

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

Analiza una dirección IP en forma de texto.

Detalles
Parámetros
[in] str
Un puntero para una string C terminada en NULL que contiene la dirección que se debe analizar.
[out] output
Es una referencia a un objeto IPAddress en el que el valor analizado se almacenará cuando se realice de forma correcta.
Qué muestra
Es verdadero si el valor se analizó correctamente y falso si no lo es.

ParseInt

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

Analiza y trata de convertir una cadena en un número entero de 64 bits sin firma y aplica la interpretación adecuada según el parámetro base.

Detalles
Parámetros
[in] str
Un puntero a una cadena C terminada en NULL que representa el número entero que se analizará.
[out] output
Es una referencia al almacenamiento para un número entero sin firma de 64 bits en el que se almacenará el valor analizado cuando se realice de forma correcta.
[in] base
Base según la cual la string se debe interpretar y analizar. Si es 0 o 16, la cadena puede ser hexadecimal y tener el prefijo "0x". De lo contrario, un 0 está implícito como 10, a menos que se encuentre un 0 inicial en el que 8 esté implícito.
Qué muestra
Es verdadero en caso de éxito; de lo contrario, es falso.

ParseInt

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

Analiza y trata de convertir una cadena en un número entero de 32 bits sin firma y aplica la interpretación adecuada según el parámetro base.

Detalles
Parámetros
[in] str
Un puntero a una cadena C terminada en NULL que representa el número entero que se analizará.
[out] output
Es una referencia al almacenamiento de un número entero sin firma de 32 bits en el que se almacenará el valor analizado cuando se realice de forma correcta.
[in] base
Base según la cual la string se debe interpretar y analizar. Si es 0 o 16, la cadena puede ser hexadecimal y tener el prefijo "0x". De lo contrario, un 0 está implícito como 10, a menos que se encuentre un 0 inicial en el que 8 esté implícito.
Qué muestra
Es verdadero en caso de éxito; de lo contrario, es falso.

ParseInt

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

Analiza y trata de convertir una cadena en un número entero de 32 bits con firma y aplica la interpretación adecuada según el parámetro base.

Detalles
Parámetros
[in] str
Un puntero a una cadena C terminada en NULL que representa el número entero que se analizará.
[out] output
Referencia al almacenamiento para un número entero de 32 bits firmado al que se almacenará el valor analizado cuando se realice de forma correcta.
[in] base
Base según la cual la string se debe interpretar y analizar. Si es 0 o 16, la cadena puede ser hexadecimal y tener el prefijo "0x". De lo contrario, un 0 está implícito como 10, a menos que se encuentre un 0 inicial en el que 8 esté implícito.
Qué muestra
Es verdadero en caso de éxito; de lo contrario, es falso.

ParseInt

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

Analiza y trata de convertir una cadena interpretada como un valor decimal en un número entero de 64 bits sin firma. Para ello, aplica la interpretación adecuada según el parámetro base.

Detalles
Parámetros
[in] str
Un puntero a una cadena C terminada en NULL que representa el número entero que se analizará.
[out] output
Es una referencia al almacenamiento para un número entero sin firma de 64 bits en el que se almacenará el valor analizado cuando se realice de forma correcta.
Qué muestra
Es verdadero en caso de éxito; de lo contrario, es falso.

ParseInt

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

Analiza y trata de convertir una cadena interpretada como un valor decimal en un número entero de 32 bits sin firma. Para ello, aplica la interpretación adecuada según el parámetro base.

Detalles
Parámetros
[in] str
Un puntero a una cadena C terminada en NULL que representa el número entero que se analizará.
[out] output
Es una referencia al almacenamiento de un número entero sin firma de 32 bits en el que se almacenará el valor analizado cuando se realice de forma correcta.
Qué muestra
Es verdadero en caso de éxito; de lo contrario, es falso.

ParseInt

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

Analiza y trata de convertir una cadena interpretada como un valor decimal en un número entero de 32 bits con signo y aplica la interpretación adecuada según el parámetro base.

Detalles
Parámetros
[in] str
Un puntero a una cadena C terminada en NULL que representa el número entero que se analizará.
[out] output
Referencia al almacenamiento para un número entero de 32 bits firmado al que se almacenará el valor analizado cuando se realice de forma correcta.
Qué muestra
Es verdadero en caso de éxito; de lo contrario, es falso.

ParseInt

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

Analiza y trata de convertir una cadena interpretada como un valor decimal en un número entero de 16 bits sin firma y aplica la interpretación adecuada según el parámetro base.

Detalles
Parámetros
[in] str
Un puntero a una cadena C terminada en NULL que representa el número entero que se analizará.
[out] output
Es una referencia al almacenamiento para un número entero sin firma de 16 bits en el que se almacenará el valor analizado cuando se realice de forma correcta.
Qué muestra
Es verdadero en caso de éxito; de lo contrario, es falso.

ParseInt

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

Analiza y trata de convertir una cadena interpretada como un valor decimal en un número entero de 16 bits con signo y aplica la interpretación adecuada según el parámetro base.

Detalles
Parámetros
[in] str
Un puntero a una cadena C terminada en NULL que representa el número entero que se analizará.
[out] output
Referencia al almacenamiento para un número entero de 16 bits firmado al que se almacenará el valor analizado cuando se realice de forma correcta.
Qué muestra
Es verdadero en caso de éxito; de lo contrario, es falso.

ParseInt

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

Analiza y trata de convertir una cadena interpretada como valor decimal en un número entero de 8 bits sin firma. Para ello, aplica la interpretación adecuada según el parámetro base.

Detalles
Parámetros
[in] str
Un puntero a una cadena C terminada en NULL que representa el número entero que se analizará.
[out] output
Referencia al almacenamiento para un número entero de 8 bits sin firma en el que se almacenará el valor analizado cuando se realice de forma correcta.
Qué muestra
Es verdadero en caso de éxito; de lo contrario, es falso.

ParseNodeId

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

Analiza un ID de nodo de Weave en forma de texto.

La función ParseNodeId() acepta un ID de nodo de 64 bits proporcionado en formato hexadecimal (con o sin un “0x” inicial) o las palabras “cualquier” o “todos” que se interpretan como el ID de cualquier nodo (0xFFFFFFFFFFFFFF).

Detalles
Parámetros
[in] str
Un puntero para una cadena C terminada en NULL que contiene el ID del nodo que se analizará.
[out] output
Es una referencia a un valor uint64_t en el que el valor analizado se almacenará cuando se realice de forma correcta.
Qué muestra
Es verdadero si el valor se analizó correctamente y falso si no lo es.

ParseSubnetId

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

Analiza y trata de convertir una cadena en un ID de subred de 16 bits sin firma. Para ello, interpreta la cadena como hexadecimal.

Detalles
Parámetros
[in] str
Un puntero hacia una cadena C terminada en NULL que representa el ID de la subred, con el formato hexadecimal, que se analizará.
[in,out] subnetId
Es una referencia al almacenamiento para un número entero de 16 bits sin firma en el que se almacenará el valor de ID de la subred analizada cuando se realice de forma correcta.
Qué muestra
Es verdadero en caso de éxito; de lo contrario, es falso.

PrintOptionHelp

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

Imprime el texto de ayuda de una lista específica de opciones en una transmisión.

Detalles
Parámetros
[in] optSets
Una lista de punteros a estructuras OptionSet que contienen el texto de ayuda para imprimir.
[in] s
El flujo FILE en el que se debe imprimir el texto de ayuda.

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
)