nl:: ArgParser
Resumen
Enumeraciones |
|
---|---|
OptionArgumentType
|
enum Define los requisitos de argumentos para una opción de línea de comandos. |
Typedefs |
|
---|---|
NonOptionArgHandlerFunct)(const char *progName, int argc, char *argv[])
|
typedefbool(*
Una función a la que se puede llamar para manejar cualquier argumento restante de la línea de comandos que no sea de opciones. |
OptionHandlerFunct)(const char *progName, OptionSet *optSet, int id, const char *name, const char *arg)
|
typedefbool(*
Una función a la que se puede llamar para controlar un conjunto de opciones de la línea de comandos. |
Variables |
|
---|---|
PrintArgError = DefaultPrintArgError)(const char *msg,...)
|
void(*
Es un puntero a la función que se usa para imprimir errores que ocurren durante el análisis de argumentos.
|
gActiveOptionSets = NULL
|
OptionSet **
Es la lista de OptionSets pasados a la llamada ParseArgs() actualmente activa.
|
Funciones |
|
---|---|
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
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 de no 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
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 cadena 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 cadena de bytes en formato hexadecimal.
|
ParseIPAddress(const char *str, IPAddress & output)
|
bool
Analiza una dirección IP en formato de texto.
|
ParseInt(const char *str, uint64_t & output, int base)
|
bool
Analiza y trata de convertir una cadena en un número entero sin firma de 64 bits. Para ello, 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 sin firma de 32 bits. Para ello, 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 string en un número entero firmado de 32 bits con 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 valor decimal en un número entero sin firma de 64 bits. 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 valor decimal en un número entero sin firma de 32 bits. 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 con firma de 32 bits 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 valor decimal en un número entero sin firma de 16 bits. Para ello, 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 con firma de 16 bits 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 un valor decimal en un número entero de 8 bits sin firma, aplicando la interpretación adecuada según el parámetro base.
|
ParseNodeId(const char *str, uint64_t & nodeId)
|
bool
Analizar un ID de nodo de Weave en forma de texto
|
ParseSubnetId(const char *str, uint16_t & subnetId)
|
bool
Analiza y trata de convertir una string en un ID de subred sin firma de 16 bits y la interpreta 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:: |
OptionSet común para controlar las opciones informativas (ayuda, versión). |
nl:: |
Un OptionSet donde el controlador es una función virtual. |
Structs |
|
---|---|
nl:: |
Define una opción de línea de comandos. |
nl:: |
Define un grupo de opciones de línea de comandos reutilizables y relacionadas de forma lógica. |
Enumeraciones
OptionArgumentType
OptionArgumentType
Define los requisitos de argumentos 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 manejar cualquier argumento restante de la línea de comandos 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 la línea de comandos.
Variables
PrintArgError
void(* PrintArgError)(const char *msg,...) = DefaultPrintArgError
Es un puntero a la función que se usa para imprimir errores que ocurren durante el análisis de argumentos.
Las aplicaciones deben llamar a PrintArgError() para informar errores en las funciones de manejo de argumentos de opciones y no opciones, en lugar de imprimir directamente en stdout/stderr.
El valor predeterminado es un puntero de la función DefaultPrintArgError()
.
gActiveOptionSets
OptionSet ** gActiveOptionSets = NULL
Es la lista de OptionSets pasados a la llamada ParseArgs() actualmente activa.
Este valor será NULL cuando no haya ninguna llamada a ParseArgs() en curso.
Funciones
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 de argumentos.
Función predeterminada que se usa para imprimir los mensajes de error que surgen debido al análisis de argumentos.
Detalles | |||
---|---|---|---|
Parámetros |
|
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 de no 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 tanto largas (opt) como cortas (-o) e implementa la misma sintaxis de opciones que la función getopt_long(3) de GNU.
Detalles | |||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Parámetros |
|
||||||||||||
Resultado que se muestra |
true si todas las opciones y los argumentos no opciones se analizaron correctamente. Es false si no se reconoce una opción o si falla una de las funciones del controlador (es decir, se muestra 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 argumentos de opciones en el orden determinado y llama a la función de controlador respectiva para cada opción reconocida. Una vez que se analizaron todas las opciones, se llama a una función de controlador independiente (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 de controlador a la 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 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 para mantener múltiples aplicaciones que aceptan opciones similares (p.ej., aplicaciones de prueba).
Existen dos patrones para definir OptionSetsone que puede inicializar una instancia del struct OptionSet en sí, p.ej., como un global estático o una subclase OptionSetBase, y proporciona un constructor. Este último 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. 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 OPCIONES
Las opciones se definen con la estructura OptionDef
. Las definiciones de opciones se organizan como un array de elementos OptionDef, en el que cada elemento contiene lo siguiente: 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. 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 } };
IDS DE OPCIONES
Los IDs de opción identifican opciones para el código que los administra (función OptionHandler). Los ID de opción están relacionados con el OptionSet en el que aparecen y, por lo tanto, se pueden volver a usar en diferentes OptionSets (sin embargo, consulta SHORT OPTIONS a continuación). Convención común es comenzar los IDs de las opciones de numeración en 1000; sin embargo, cualquier número > 128. Las opciones de alias se pueden crear usando el mismo ID de opción con diferentes nombres de opción.
OPCIONES BREVE
A diferencia de getopt_long(3), ParseArgs() no toma una cadena separada que especifica 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 utilice como una opción corta.
ParseArgs() requiere que los caracteres de opciones cortos sean únicos en todos los OptionSets. Por este motivo, no se recomienda el uso de opciones cortas para los OptionSets que se comparten entre programas debido a la posibilidad significativa de colisiones. Los caracteres de opciones cortas se pueden volver a usar en un solo OptionSet para permitir la creación de nombres de opciones largos de alias.
AYUDA CON LA OPCIÓN
Cada OptionSet contiene una cadena 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 de opción consisten en 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 proporciona antes del nombre largo principal. Para que haya 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. Una sola línea en blanco sigue a la descripción de cada 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 LAS OPCIONES
Los OptionSets contienen 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 OptionSets juntos bajo un título de sección 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 con nombre y pasa el valor a ParseArgsFromString()
para su análisis. Si la variable de entorno no está configurada, la función no hace nada.
Detalles | |||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|
Parámetros |
|
||||||||||
Resultado que se muestra |
true si todas las opciones y los argumentos no opciones se analizaron correctamente, o si no se estableció la variable de entorno especificada. Es false si no se reconoce una opción, si falla una de las funciones del controlador (es decir, se muestra un valor falso) o si se produce 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 cadena determinada.
ParseArgsFromString() divide una cadena determinada (argStr
) en un conjunto de argumentos y los analiza con la función ParseArgs().
Detalles | |||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|
Parámetros |
|
||||||||||
Resultado que se muestra |
true si todas las opciones y los argumentos no opciones se analizaron correctamente. Es false si no se reconoce una opción, si falla una de las funciones del controlador (es decir, se muestra un valor falso) o si se produce un error interno. |
La sintaxis de las cadenas de entrada es similar a la sintaxis del comando shell 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 el espacio en blanco esté entre comillas o escape.
- Una barra invertida escapa el siguiente carácter, lo que hace que se lo trate como un carácter normal. Se quita la barra inversa.
- Las comillas simples o dobles comienzan o terminan en las subcadenas entrecomilladas. Dentro de una subcadena, los únicos caracteres especiales son la barra inversa, que escapa el carácter siguiente y las comillas de cierre correspondientes. Se quitan los caracteres de comillas de inicio y fin.
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 )
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 |
|
||||
Resultado que se muestra |
verdadero sobre el éxito; de lo contrario, es falso en caso de falla.
|
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 "0x" inicial.
Detalles | |||||||
---|---|---|---|---|---|---|---|
Parámetros |
|
||||||
Resultado que se muestra |
true si el valor se analizó correctamente; false si no es así.
|
ParseHexString
bool ParseHexString( const char *hexStr, uint32_t strLen, uint8_t *outBuf, uint32_t outBufSize, uint32_t & outDataLen )
Analiza una cadena de bytes en formato hexadecimal.
ParseHexString() espera que la entrada tenga el formato de pares de dígitos hexadecimales (mayúsculas o minúsculas). Los pares hexadecimales se pueden separar opcionalmente por 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 cadena de entrada.
Detalles | |||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|
Parámetros |
|
||||||||||
Resultado que se muestra |
true 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 formato de texto.
Detalles | |||||
---|---|---|---|---|---|
Parámetros |
|
||||
Resultado que se muestra |
true si el valor se analizó correctamente; false si no es así.
|
ParseInt
bool ParseInt( const char *str, uint64_t & output, int base )
Analiza y trata de convertir una cadena en un número entero sin firma de 64 bits. Para ello, aplica la interpretación adecuada según el parámetro base.
Detalles | |||||||
---|---|---|---|---|---|---|---|
Parámetros |
|
||||||
Resultado que se muestra |
verdadero sobre el éxito; de lo contrario, es falso en caso de falla.
|
ParseInt
bool ParseInt( const char *str, uint32_t & output, int base )
Analiza y trata de convertir una cadena en un número entero sin firma de 32 bits. Para ello, aplica la interpretación adecuada según el parámetro base.
Detalles | |||||||
---|---|---|---|---|---|---|---|
Parámetros |
|
||||||
Resultado que se muestra |
verdadero sobre el éxito; de lo contrario, es falso en caso de falla.
|
ParseInt
bool ParseInt( const char *str, int32_t & output, int base )
Analiza y trata de convertir una string en un número entero firmado de 32 bits con la interpretación adecuada según el parámetro base.
Detalles | |||||||
---|---|---|---|---|---|---|---|
Parámetros |
|
||||||
Resultado que se muestra |
verdadero sobre el éxito; de lo contrario, es falso en caso de falla.
|
ParseInt
bool ParseInt( const char *str, uint64_t & output )
Analiza y trata de convertir una cadena interpretada como valor decimal en un número entero sin firma de 64 bits. Para ello, aplica la interpretación adecuada según el parámetro base.
Detalles | |||||
---|---|---|---|---|---|
Parámetros |
|
||||
Resultado que se muestra |
verdadero sobre el éxito; de lo contrario, es falso en caso de falla.
|
ParseInt
bool ParseInt( const char *str, uint32_t & output )
Analiza y trata de convertir una cadena interpretada como valor decimal en un número entero sin firma de 32 bits. Para ello, aplica la interpretación adecuada según el parámetro base.
Detalles | |||||
---|---|---|---|---|---|
Parámetros |
|
||||
Resultado que se muestra |
verdadero sobre el éxito; de lo contrario, es falso en caso de falla.
|
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 con firma de 32 bits y aplica la interpretación adecuada según el parámetro base.
Detalles | |||||
---|---|---|---|---|---|
Parámetros |
|
||||
Resultado que se muestra |
verdadero sobre el éxito; de lo contrario, es falso en caso de falla.
|
ParseInt
bool ParseInt( const char *str, uint16_t & output )
Analiza y trata de convertir una cadena interpretada como valor decimal en un número entero sin firma de 16 bits. Para ello, aplica la interpretación adecuada según el parámetro base.
Detalles | |||||
---|---|---|---|---|---|
Parámetros |
|
||||
Resultado que se muestra |
verdadero sobre el éxito; de lo contrario, es falso en caso de falla.
|
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 con firma de 16 bits y aplica la interpretación adecuada según el parámetro base.
Detalles | |||||
---|---|---|---|---|---|
Parámetros |
|
||||
Resultado que se muestra |
verdadero sobre el éxito; de lo contrario, es falso en caso de falla.
|
ParseInt
bool ParseInt( const char *str, uint8_t & output )
Analiza y trata de convertir una cadena interpretada como un valor decimal en un número entero de 8 bits sin firma, aplicando la interpretación adecuada según el parámetro base.
Detalles | |||||
---|---|---|---|---|---|
Parámetros |
|
||||
Resultado que se muestra |
verdadero sobre el éxito; de lo contrario, es falso en caso de falla.
|
ParseNodeId
bool ParseNodeId( const char *str, uint64_t & nodeId )
Analizar 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 "0x" inicial) o las palabras "any" o "todos" que se interpretan como el ID de cualquier nodo (0xFFFFFFFFFFFFFFFF).
Detalles | |||||
---|---|---|---|---|---|
Parámetros |
|
||||
Resultado que se muestra |
true si el valor se analizó correctamente; false si no es así.
|
ParseSubnetId
bool ParseSubnetId( const char *str, uint16_t & subnetId )
Analiza y trata de convertir una string en un ID de subred sin firma de 16 bits y la interpreta como hexadecimal.
Detalles | |||||
---|---|---|---|---|---|
Parámetros |
|
||||
Resultado que se muestra |
verdadero sobre el éxito; de lo contrario, es falso en caso de falla.
|
PrintOptionHelp
void PrintOptionHelp( OptionSet *optSets[], FILE *s )
Imprime el texto de ayuda de una lista específica de opciones en un flujo.
Detalles | |||||
---|---|---|---|---|---|
Parámetros |
|
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 )