Google se compromete a impulsar la igualdad racial para las comunidades afrodescendientes. Obtén información al respecto.
Organiza tus páginas con colecciones Guarda y categoriza el contenido según tus preferencias.

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 sin 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 un puntero a una función que se usa para imprimir errores que se producen durante el análisis de los argumentos.
gActiveOptionSets = NULL
La lista de SetSets pasados a la llamada ParseArgs() actualmente activa.

Functions

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 de argumentos.
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
Analizar un conjunto de argumentos de estilo de línea de comandos, llamar a funciones de control para procesar cada opción y argumento que no es una opción
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
Analizar un conjunto de argumentos desde 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
Analizar un conjunto de argumentos desde 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
Analizar una string 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 en formato hexadecimal.
ParseIPAddress(const char *str, IPAddress & output)
bool
Analizar una dirección IP en forma de texto.
ParseInt(const char *str, uint64_t & output, int base)
bool
Analizar y tratar de convertir una string en un número entero de 64 bits sin signo, aplicando la interpretación apropiada según el parámetro base
ParseInt(const char *str, uint32_t & output, int base)
bool
Analizar y tratar de convertir una string en un número entero de 32 bits sin signo, aplicando la interpretación apropiada según el parámetro base
ParseInt(const char *str, int32_t & output, int base)
bool
Analizar y tratar de convertir una string en un valor entero de 32 bits con signo y aplicar la interpretación apropiada según el parámetro base
ParseInt(const char *str, uint64_t & output)
bool
Analizar y tratar de convertir una string interpretada como un valor decimal en un número entero de 64 bits sin signo, aplicando la interpretación apropiada según el parámetro base
ParseInt(const char *str, uint32_t & output)
bool
Analizar y tratar de convertir una string interpretada como un valor decimal en un número entero de 32 bits sin signo, aplicando la interpretación apropiada según el parámetro base
ParseInt(const char *str, int32_t & output)
bool
Analizar y tratar de convertir una string interpretada como un valor decimal en un número entero de 32 bits con signo y aplicar la interpretación apropiada según el parámetro base
ParseInt(const char *str, uint16_t & output)
bool
Analizar y tratar de convertir una string interpretada como un valor decimal en un número entero de 16 bits sin signo, aplicando la interpretación apropiada según el parámetro base
ParseInt(const char *str, int16_t & output)
bool
Analizar y tratar de convertir una string interpretada como un valor decimal en un número entero de 16 bits con signo y aplicar la interpretación apropiada según el parámetro base
ParseInt(const char *str, uint8_t & output)
bool
Analizar y tratar de convertir una string interpretada como un valor decimal en un número entero de 8 bits sin signo, aplicando la interpretación apropiada 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 convierte una string en un ID de subred de 16 bits sin firmar; interpreta la string como hexadecimal.
PrintOptionHelp(OptionSet *optSets[], FILE *s)
void
Imprime el texto de ayuda de una lista específica de opciones en un flujo.
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

Es un OptionSet común para procesar 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

Tipo de argumento de opción

 OptionArgumentType

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

Typedefs

NoOptionArgHandlerFunct

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 sin opciones.

Opción HandlerHandlerFunct

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

ErrorErrorAArg

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

Es un puntero a una función que se usa para imprimir errores que se producen durante el análisis de los argumentos.

Las aplicaciones deben llamar a PrintArgError() a fin de informar errores en su función y en el manejo de argumentos sin opciones, en lugar de imprimir directamente en stdout/stderr.

La configuración predeterminada es un puntero a la función DefaultPrintArgError().

gActiveOptionSets

OptionSet ** gActiveOptionSets = NULL

La lista de SetSets pasados a la llamada ParseArgs() actualmente activa.

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

Functions

Recuento de todas las opciones

size_t CountAllOptions(
  OptionSet *optSets[]
)

Recuento de todas las opciones

size_t CountAllOptions(
  OptionSet **optSets
)

CountOptionSets

size_t CountOptionSets(
  OptionSet *optSets[]
)

CountOptionSets

size_t CountOptionSets(
  OptionSet **optSets
)

Error de impresión predeterminada

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

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

Función predeterminada para imprimir los 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 directamente a esta función.

IDDeOpciónDeBúsqueda

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
)

Opciones de MakeLong

struct option * MakeLongOptions(
  OptionSet **optSets
)

Opciones de Shorts

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
)

Analizar un conjunto de argumentos de estilo de línea de comandos, llamar a funciones de control para procesar cada opción y argumento que no es una opción

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 string se usará para agregar prefijos a mensajes y advertencias de error.
[in] argc
La cantidad de argumentos que se analizarán, más 1.
[in] argv
Un arreglo de strings de argumentos que se analizarán. La longitud del array debe ser 1 mayor que el valor especificado para argc, y el argumento argv[argc] debe establecerse como NULL. El análisis de argumentos comienza con el segundo elemento del array (argv[1]); se ignora el elemento 0.
[in] optSets
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 son opciones . Se llama a la función independientemente de si quedan argumentos o no. Si se pasa un valor NULL, ParseArgs() informará un error si hay argumentos sin opciones.
[in] ignoreUnknown
Si es verdadero, ignora de forma silenciosa las opciones no reconocidas.
Qué muestra
true si se analizaron correctamente todas las opciones y los argumentos sin opciones; false si no se reconoció una opción o si falló una de las funciones del controlador (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 opciones en el orden dado, llamando a la función del controlador respectiva para cada opción reconocida. Una vez que se analizaron todas las opciones, se llama a una función del controlador independiente de opciones (nonOptArgHandler) una vez para procesar los argumentos restantes.

Conjuntos de opciones

Un OptionSet contiene un conjunto de definiciones de opciones junto con un puntero para una función del 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 AYUDA PARA OPCIONES 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 que se necesita para mantener varias aplicaciones que aceptan opciones similares (p.ej., aplicaciones de prueba).

Hay dos patrones para definir una opción SetSetsone que pueden inicializar una instancia de la estructura OptionSet en sí misma, p.ej., como un global estático o una subclase OptionSetBase y proporcionar un constructor. Este último usa una función HandleOption() pura para delegar el control de opciones a la subclase.

Las listas de OptionSets se pasan a la función ParseArgs() como un arreglo de punteros finalizado con NULL. P.ej.:

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 LA OPCIÓN

Las opciones se definen con la estructura OptionDef. Las definiciones de las opciones se organizan como un arreglo 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 arreglo de opciones se indica mediante un campo NULL Name. P.ej.:

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 DE OPCIÓN

Los ID de opciones identifican las opciones del código que las administra (la función OptionHandler). Los ID de opciones se relacionan con el OptionSet en el que aparecen y, por lo tanto, se pueden volver a usar en diferentes SetSets (sin embargo, consulta SHORT OPTIONS a continuación). Una convención común es comenzar con la numeración de los ID de la opción en 1,000, pero se puede usar cualquier cifra de 128. Las opciones de alias se pueden crear usando el mismo ID de opción con diferentes nombres de opción.

OPCIONES SHORT

A diferencia de getopt_long(3), ParseArgs() no acepta una string separada que especifique la lista de caracteres de opciones cortas. Más bien, cualquier opción cuyo valor de ID se encuentre dentro del rango de caracteres ASCII gráficos permitirá que se use como una opción corta.

ParseArgs() requiere que los caracteres cortos de opciones sean únicos en todos los SetSets. Debido a esto, no se recomienda el uso de opciones cortas en los OpciónSets que se comparten entre programas debido a la posibilidad significativa de colisión. Los caracteres de opción corta se pueden volver a usar dentro de un mismo OptionSet para permitir la creación de nombres largos de opciones de alias.

AYUDA DE LA 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 strings para generar información de uso de las opciones.

Por convención, las strings de ayuda de opciones 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 asigna antes que el nombre largo principal. Por motivos de coherencia, las líneas de sintaxis tienen una sangría de 2 espacios, mientras que las de descripción tienen 7 espacios de sangría. Una sola línea en blanco aparece después de cada descripción de opción, incluida la última.

P.ej.:

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 LA OPCIÓN

Los SetSets contienen una string HelpGroupName que se usa para agrupar las opciones en el resultado de ayuda. La función PrintOptionHelp() usa el HelpGroupName como título de sección en el resultado de uso generado. Si varios SetSets tienen el mismo HelpGroupName, PrintOptionHelp() imprimirá la opción de ayuda para los diferentes SetSets en un mismo título de secció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
)

Analizar un conjunto de argumentos desde una variable de entorno con nombre

ParseArgsFromEnvVar() lee una variable de entorno con nombre y pasa el valor a ParseArgsFromString() para su análisis. Si no se configuró la variable de entorno, la función no hace nada.

Detalles
Parámetros
[in] progName
El nombre del programa o contexto en el que se analizan los argumentos. Esta string se usará para agregar prefijos a mensajes y advertencias de error.
[in] varName
Es el nombre de la variable de entorno.
[in] optSets
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 son opciones . Se llama a la función independientemente de si quedan argumentos o no. Si se pasa un valor NULL, ParseArgs() informará un error si hay argumentos sin opciones.
[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, si la variable de entorno especificada no se configuró, false si no se reconoció una opción, si falló una de las funciones del controlador (es decir, 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
)

Analizar un conjunto de argumentos desde una string determinada

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

Detalles
Parámetros
[in] progName
El nombre del programa o contexto en el que se analizan los argumentos. Esta string se usará para agregar prefijos a mensajes y advertencias de error.
[in] argStr
Una string que contiene las opciones y los argumentos que se analizarán.
[in] optSets
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 son opciones . Se llama a la función independientemente de si quedan argumentos o no. Si se pasa un valor NULL, ParseArgs() informará un error si hay argumentos sin opciones.
[in] ignoreUnknown
Si es verdadero, ignora de forma silenciosa las opciones no reconocidas.
Qué muestra
true si se analizaron correctamente todas las opciones y los argumentos sin opciones; false si no se reconoció una opción, si falló una de las funciones del controlador (es decir, se mostró un valor falso) o si se produjo un error interno.

La sintaxis de las strings de entrada es similar a la sintaxis de comando de shell de Unix, pero con un esquema de comillas simplificado. En particular, las siguientes:

  • Los argumentos están delimitados por espacios en blanco, a menos que los espacios en blanco estén entre comillas o que tengan escape.
  • Una barra inversa se escapa del carácter siguiente, lo que hace que se trate como un carácter normal. La barra inversa se quita.
  • Comillas simples o dobles de inicio y finalización En una substring, los únicos caracteres especiales son la barra inversa, que se escapa con el carácter siguiente, y la cita final correspondiente. Se quitan los caracteres de inicio y finalización.

P.ej.:

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

Analizar una string como un valor booleano

Esta función acepta los siguientes valores de entrada (distinción entre mayúsculas y minúsculas): "true", "yes", "false, false; no&;;f&ft;ft, f,

Detalles
Parámetros
[in] str
Un puntero para una string C terminada en NULL que representa el valor que se analizará.
[out] output
Una referencia al almacenamiento de un bool al que se almacenará el valor analizado si se realiza correctamente.
Qué muestra
Es verdadero para el éxito; de lo contrario, es falso para el fracaso.

ID de ParseFabric

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 dado en formato hexadecimal, con o sin un '0x'

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
Una referencia a un valor uint64_t en el que se almacenará correctamente el valor analizado.
[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; si no es así, es falso.

ParseHexString

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

Analiza una string de bytes 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 espacios en blanco en cualquier parte de la string de entrada.

Detalles
Parámetros
[in] hexStr
Un puntero para la string que se analizará.
[in] strLen
La cantidad de caracteres de 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
El tamaño del búfer al que apunta outBuf.
[out] outDataLen
Una 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 para contener la cantidad determinada de bytes, outDataLen se establecerá en UINT32_MAX.
Qué muestra
Es verdadero si el valor se analizó correctamente; si es incorrecto los datos de entrada o si outBuf es demasiado pequeño.

Dirección IP de análisis

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

Analizar 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 analizará.
[out] output
Una referencia a un objeto de IPAddress en el que se almacenará correctamente el valor analizado.
Qué muestra
Es verdadero si el valor se analizó correctamente; si no es así, es falso.

ParseInt

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

Analizar y tratar de convertir una string en un número entero de 64 bits sin signo, aplicando la interpretación apropiada según el parámetro base

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

ParseInt

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

Analizar y tratar de convertir una string en un número entero de 32 bits sin signo, aplicando la interpretación apropiada según el parámetro base

Detalles
Parámetros
[in] str
Un puntero para una string C terminada en NULL que representa el número entero que se analizará.
[out] output
Una referencia al almacenamiento para un valor entero de 32 bits sin signo en el que se almacenará correctamente el valor analizado.
[in] base
Base en la que se debe interpretar y analizar la string. Si el valor es 0 o 16, la string puede ser hexadecimal y contener el prefijo "&xt:0x". De lo contrario, un 0 se da como 10, a menos que se encuentre un 0 inicial en el que 8 esté implícito.
Qué muestra
Es verdadero para el éxito; de lo contrario, es falso para el fracaso.

ParseInt

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

Analizar y tratar de convertir una string en un valor entero de 32 bits con signo y aplicar la interpretación apropiada según el parámetro base

Detalles
Parámetros
[in] str
Un puntero para una string C terminada en NULL que representa el número entero que se analizará.
[out] output
Una referencia al almacenamiento de un número entero de 32 bits con signo en el que se almacenará correctamente el valor analizado.
[in] base
Base en la que se debe interpretar y analizar la string. Si el valor es 0 o 16, la string puede ser hexadecimal y contener el prefijo "&xt:0x". De lo contrario, un 0 se da como 10, a menos que se encuentre un 0 inicial en el que 8 esté implícito.
Qué muestra
Es verdadero para el éxito; de lo contrario, es falso para el fracaso.

ParseInt

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

Analizar y tratar de convertir una string interpretada como un valor decimal en un número entero de 64 bits sin signo, aplicando la interpretación apropiada según el parámetro base

Detalles
Parámetros
[in] str
Un puntero para una string C terminada en NULL que representa el número entero que se analizará.
[out] output
Una referencia al almacenamiento de un número entero de 64 bits sin signo en el que se almacenará correctamente el valor analizado.
Qué muestra
Es verdadero para el éxito; de lo contrario, es falso para el fracaso.

ParseInt

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

Analizar y tratar de convertir una string interpretada como un valor decimal en un número entero de 32 bits sin signo, aplicando la interpretación apropiada según el parámetro base

Detalles
Parámetros
[in] str
Un puntero para una string C terminada en NULL que representa el número entero que se analizará.
[out] output
Una referencia al almacenamiento para un valor entero de 32 bits sin signo en el que se almacenará correctamente el valor analizado.
Qué muestra
Es verdadero para el éxito; de lo contrario, es falso para el fracaso.

ParseInt

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

Analizar y tratar de convertir una string interpretada como un valor decimal en un número entero de 32 bits con signo y aplicar la interpretación apropiada según el parámetro base

Detalles
Parámetros
[in] str
Un puntero para una string C terminada en NULL que representa el número entero que se analizará.
[out] output
Una referencia al almacenamiento de un número entero de 32 bits con signo en el que se almacenará correctamente el valor analizado.
Qué muestra
Es verdadero para el éxito; de lo contrario, es falso para el fracaso.

ParseInt

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

Analizar y tratar de convertir una string interpretada como un valor decimal en un número entero de 16 bits sin signo, aplicando la interpretación apropiada según el parámetro base

Detalles
Parámetros
[in] str
Un puntero para una string C terminada en NULL que representa el número entero que se analizará.
[out] output
Una referencia al almacenamiento de un número entero de 16 bits sin signo en el que se almacenará correctamente el valor analizado.
Qué muestra
Es verdadero para el éxito; de lo contrario, es falso para el fracaso.

ParseInt

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

Analizar y tratar de convertir una string interpretada como un valor decimal en un número entero de 16 bits con signo y aplicar la interpretación apropiada según el parámetro base

Detalles
Parámetros
[in] str
Un puntero para una string C terminada en NULL que representa el número entero que se analizará.
[out] output
Una referencia al almacenamiento de un número entero de 16 bits con signo en el que se almacenará correctamente el valor analizado.
Qué muestra
Es verdadero para el éxito; de lo contrario, es falso para el fracaso.

ParseInt

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

Analizar y tratar de convertir una string interpretada como un valor decimal en un número entero de 8 bits sin signo, aplicando la interpretación apropiada según el parámetro base

Detalles
Parámetros
[in] str
Un puntero para una string C terminada en NULL que representa el número entero que se analizará.
[out] output
Una referencia al almacenamiento para un valor entero de 8 bits sin signo en el que se almacenará correctamente el valor analizado.
Qué muestra
Es verdadero para el éxito; de lo contrario, es falso para el fracaso.

ID del parseNode

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 dado en formato hexadecimal (con o sin un &'0x' inicial) o las palabras 'any'&'all' que se interpretan como el ID de cualquier nodo (0xFFFFFFFFFFFFFF).

Detalles
Parámetros
[in] str
Un puntero para una string C terminada en NULL que contiene el ID de nodo que se analizará.
[out] output
Una referencia a un valor uint64_t en el que se almacenará correctamente el valor analizado.
Qué muestra
Es verdadero si el valor se analizó correctamente; si no es así, es falso.

ID de la subred Parse

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

Analiza y convierte una string en un ID de subred de 16 bits sin firmar; interpreta la string como hexadecimal.

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

Ayuda de opción de impresión

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

Imprime el texto de ayuda de una lista específica de opciones en un flujo.

Detalles
Parámetros
[in] optSets
Lista de punteros a estructuras OptionSet que contienen el texto de ayuda que se imprimirá.
[in] s
Es la transmisión FILE en la que se debe imprimir el texto de ayuda.

PutStringWithBlankLine

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

PutStringWithNuevaLínea

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

SplitArgs

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