nl :: ArgParser
Resumen
Enumeraciones | |
---|---|
OptionArgumentType | enumeración Define los requisitos de argumento para una opción de línea de comando. |
Typedefs | |
---|---|
NonOptionArgHandlerFunct )(const char *progName, int argc, char *argv[]) | typedefbool(* Una función que se puede llamar para manejar cualquier argumento de línea de comando restante que no sea de opción. |
OptionHandlerFunct )(const char *progName, OptionSet *optSet, int id, const char *name, const char *arg) | typedefbool(* Una función que se puede llamar para manejar un conjunto de opciones de línea de comando. |
Variables | |
---|---|
PrintArgError = DefaultPrintArgError)(const char *msg,...) | void(* Puntero a función que se utiliza para imprimir errores que ocurren durante el análisis de argumentos. |
gActiveOptionSets = NULL | OptionSet ** La lista de OptionSets pasada 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 comando, llamando a funciones de manejo para procesar cada opción y argumento que no es de 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 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 Analizar 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 Analizar una identificación de tejido Weave en forma de texto. |
ParseHexString (const char *hexStr, uint32_t strLen, uint8_t *outBuf, uint32_t outBufSize, uint32_t & outDataLen) | bool Analizar una cadena 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 Analice e intente convertir una cadena en un entero sin signo de 64 bits, aplicando la interpretación adecuada basada en el parámetro base. |
ParseInt (const char *str, uint32_t & output, int base) | bool Analice e intente convertir una cadena en un entero sin signo de 32 bits, aplicando la interpretación adecuada basada en el parámetro base. |
ParseInt (const char *str, int32_t & output, int base) | bool Analice e intente convertir una cadena en un entero de 32 bits con signo, aplicando la interpretación adecuada según el parámetro base. |
ParseInt (const char *str, uint64_t & output) | bool Analice e intente convertir una cadena interpretada como un valor decimal en un entero sin signo de 64 bits, aplicando la interpretación adecuada según el parámetro base. |
ParseInt (const char *str, uint32_t & output) | bool Analice e intente convertir una cadena interpretada como un valor decimal en un entero sin signo de 32 bits, aplicando la interpretación adecuada según el parámetro base. |
ParseInt (const char *str, int32_t & output) | bool Analice e intente convertir una cadena interpretada como un valor decimal en un entero de 32 bits con signo, aplicando la interpretación adecuada según el parámetro base. |
ParseInt (const char *str, uint16_t & output) | bool Analice e intente convertir una cadena interpretada como un valor decimal en un entero sin signo de 16 bits, aplicando la interpretación adecuada según el parámetro base. |
ParseInt (const char *str, int16_t & output) | bool Analice e intente convertir una cadena interpretada como un valor decimal en un entero de 16 bits con signo, aplicando la interpretación adecuada según el parámetro base. |
ParseInt (const char *str, uint8_t & output) | bool Analice e intente convertir una cadena interpretada como un valor decimal en un entero sin signo de 8 bits, aplicando la interpretación adecuada basada en el parámetro base. |
ParseNodeId (const char *str, uint64_t & nodeId) | bool Analizar un ID de nodo Weave en forma de texto. |
ParseSubnetId (const char *str, uint16_t & subnetId) | bool Analice e intente convertir una cadena en un ID de subred sin firmar de 16 bits, interpretando la cadena como hexadecimal. |
PrintOptionHelp ( OptionSet *optSets[], FILE *s) | void Imprima el texto de ayuda para una lista específica de opciones en una ruta. |
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 | Common OptionSet para manejar opciones informativas (ayuda, versión). |
nl :: ArgParser :: OptionSetBase | Un OptionSet donde el controlador es una función virtual. |
Estructuras | |
---|---|
nl :: ArgParser :: OptionDef | Define una opción de línea de comando. |
nl :: ArgParser :: OptionSet | Define un grupo de opciones de línea de comando reutilizables y relacionadas lógicamente. |
Enumeraciones
OptionArgumentType
OptionArgumentType
Define los requisitos de argumento para una opción de línea de comando.
Typedefs
NonOptionArgHandlerFunct
bool(* NonOptionArgHandlerFunct)(const char *progName, int argc, char *argv[])
Una función que se puede llamar para manejar cualquier argumento de línea de comando restante que no sea de opción.
OptionHandlerFunct
bool(* OptionHandlerFunct)(const char *progName, OptionSet *optSet, int id, const char *name, const char *arg)
Una función que se puede llamar para manejar un conjunto de opciones de línea de comando.
Variables
PrintArgError
void(* PrintArgError)(const char *msg,...) = DefaultPrintArgError
Puntero a función que se utiliza para imprimir errores que ocurren durante el análisis de argumentos.
Las aplicaciones deben llamar a PrintArgError () para informar errores en sus funciones de manejo de argumentos de opción y no opción, en lugar de imprimir directamente en stdout / stderr.
Por defecto es un puntero a la función DefaultPrintArgError()
.
gActiveOptionSets
OptionSet ** gActiveOptionSets = NULL
La lista de OptionSets pasada a la llamada ParseArgs () actualmente activa.
Este valor será NULL cuando no haya ninguna llamada en curso a ParseArgs ().
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 utilizada para imprimir 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 comando, llamando a funciones de manejo para procesar cada opción y argumento que no es de opción.
ParseArgs () toma una lista de argumentos ( argv
) y los analiza de acuerdo con 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 GNU getopt_long (3).
Detalles | |||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Parámetros |
| ||||||||||||
Devoluciones | true si todas las opciones y los argumentos que no son opciones se analizaron correctamente; false si una opción no fue reconocida o si una de las funciones del controlador falló (es decir, devolvió falso). |
Definiciones de las opciones se pasan a ParseArgs () como una matriz de optionset estructuras ( optSets
). Cada OptionSet contiene una matriz de definiciones de opciones y una función de controlador. ParseArgs () procesa los argumentos de las opciones en el orden dado, llamando a la función del controlador respectivo para cada opción reconocida. Una vez que se han analizado todas las opciones, se llama una vez a una función de controlador que no es de opción ( nonOptArgHandler
) para procesar los argumentos restantes.
CONJUNTOS OPCIONALES
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 (consulte AYUDA DE 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 necesario para mantener múltiples aplicaciones que aceptan opciones similares (por ejemplo, aplicaciones de prueba).
Hay dos patrones para definir OptionSetsone que puede inicializar una instancia de la estructura OptionSet en sí, por ejemplo, como un global estático, o una subclaseOptionSetBase y proporcionar un constructor. Este último usa una función puramente virtual HandleOption()
para delegar el manejo de opciones a la subclase.
Las listas de OptionSets se pasan a la función ParseArgs () como una matriz de punteros terminada en NULL. Por ejemplo:
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 mediante la estructura OptionDef
. Las definiciones de las opciones están organizadas como una matriz de elementos OptionDef , donde cada elemento contiene: el nombre de la opción, un ID entero que se usa para identificar la opción y si la opción espera / permite un argumento. El final de la matriz de opciones se indica mediante un campo de nombre NULL. Por ejemplo:
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 opción identifican opciones para el código que las maneja (la función OptionHandler). Los identificadores de opciones son relativos al OptionSet en el que aparecen y, por lo tanto, pueden reutilizarse en diferentes OptionSets (sin embargo, consulte OPCIONES CORTAS a continuación). La convención común es comenzar a numerar los ID de opción en 1000, sin embargo, se puede usar 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 CORTAS
A diferencia de getopt_long (3), ParseArgs () no toma una cadena separada que especifique la lista de caracteres de opción cortos. Por el contrario, cualquier opción cuyo valor de identificación se encuentre en el rango de caracteres gráficos ASCII permitirá que ese carácter se utilice como una opción corta.
ParseArgs () requiere que los caracteres de opción cortos sean únicos en todos los OptionSets. Debido a esto, se desaconseja el uso de opciones cortas para los OptionSets que se comparten entre programas debido a la gran posibilidad de colisiones. Los caracteres de opciones cortos se pueden reutilizar dentro de un único OptionSet para permitir la creación de nombres de opciones largos de alias.
AYUDA DE OPCIÓN
Cada OptionSet contiene una cadena OptionHelp
que describe el propósito y la sintaxis de las opciones asociadas. Estas cadenas son utilizadas por la función PrintOptionHelp()
para generar información de uso de opciones.
Por convención, las cadenas de ayuda de opciones 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 alias, se da antes del nombre largo principal. Para mantener la coherencia, las líneas de sintaxis se sangran con 2 espacios, mientras que las líneas descriptivas se sangran con 7 espacios. Una sola línea en blanco sigue a la descripción de cada opción, incluida la última.
Por ejemplo:
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";
OPCIÓN GRUPOS DE AYUDA
Los OptionSets contienen una cadena HelpGroupName
que se utiliza para agrupar opciones en la salida de ayuda. La función PrintOptionHelp()
utiliza HelpGroupName como título de sección en la salida de uso generada. 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 )
Analizar 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 no se establece la variable de entorno, la función no hace nada.
Detalles | |||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|
Parámetros |
| ||||||||||
Devoluciones | true si todas las opciones y los argumentos que no son de opción se analizaron correctamente o si la variable de entorno especificada no está establecida; false si una opción no fue reconocida, si una de las funciones del controlador falló (es decir, devolvió falso) o si ocurrió 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 de una cadena determinada.
ParseArgsFromString () divide una cadena dada ( argStr
) en un conjunto de argumentos y analiza los argumentos usando la función ParseArgs ().
Detalles | |||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|
Parámetros |
| ||||||||||
Devoluciones | true si todas las opciones y los argumentos que no son opciones se analizaron correctamente; false si una opción no fue reconocida, si una de las funciones del controlador falló (es decir, devolvió falso) o si ocurrió un error interno. |
La sintaxis de las cadenas de entrada es similar a la sintaxis de comandos del shell de Unix, pero con un esquema de comillas simplificado. Específicamente:
- 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 al siguiente carácter, lo que hace que se trate como un carácter normal. La barra invertida en sí se elimina.
- Las comillas simples o dobles comienzan / terminan subcadenas entre comillas. Dentro de una subcadena, los únicos caracteres especiales son la barra invertida, que escapa al siguiente carácter y la comilla final correspondiente. Se eliminan los caracteres de comillas de inicio / fin.
Por ejemplo:
--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 entre mayúsculas y minúsculas): "verdadero", "sí", "t", "y", "1", "falso", "no", "f", "n", " 0 ".
Detalles | |||||
---|---|---|---|---|---|
Parámetros |
| ||||
Devoluciones | verdadero en el éxito; de lo contrario, falso en caso de falla. |
ParseFabricId
bool ParseFabricId( const char *str, uint64_t & fabricId, bool allowReserved )
Analizar una identificación de tejido Weave en forma de texto.
La función ParseFabricId () acepta un ID de estructura de 64 bits en formato hexadecimal, con o sin un '0x' inicial.
Detalles | |||||||
---|---|---|---|---|---|---|---|
Parámetros |
| ||||||
Devoluciones | Es verdadero si el valor se analizó correctamente; falso si no. |
ParseHexString
bool ParseHexString( const char *hexStr, uint32_t strLen, uint8_t *outBuf, uint32_t outBufSize, uint32_t & outDataLen )
Analizar una cadena de bytes en formato hexadecimal.
ParseHexString () espera que la entrada esté en forma de pares de dígitos hexadecimales (mayúsculas o minúsculas). Los pares hexadecimales pueden separarse opcionalmente con cualquiera de los siguientes caracteres: dos puntos, punto y coma, coma, punto o guión. Además, se ignoran los espacios en blanco en cualquier lugar de la cadena de entrada.
Detalles | |||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|
Parámetros |
| ||||||||||
Devoluciones | Es verdadero si el valor se analizó correctamente; false si los datos de entrada están mal formados o si outBuf es demasiado pequeño. |
ParseIPAddress
bool ParseIPAddress( const char *str, IPAddress & output )
Analizar una dirección IP en forma de texto.
Detalles | |||||
---|---|---|---|---|---|
Parámetros |
| ||||
Devoluciones | Es verdadero si el valor se analizó correctamente; falso si no. |
ParseInt
bool ParseInt( const char *str, uint64_t & output, int base )
Analice e intente convertir una cadena en un entero sin signo de 64 bits, aplicando la interpretación adecuada basada en el parámetro base.
Detalles | |||||||
---|---|---|---|---|---|---|---|
Parámetros |
| ||||||
Devoluciones | verdadero en el éxito; de lo contrario, falso en caso de falla. |
ParseInt
bool ParseInt( const char *str, uint32_t & output, int base )
Analice e intente convertir una cadena en un entero sin signo de 32 bits, aplicando la interpretación adecuada basada en el parámetro base.
Detalles | |||||||
---|---|---|---|---|---|---|---|
Parámetros |
| ||||||
Devoluciones | verdadero en el éxito; de lo contrario, falso en caso de falla. |
ParseInt
bool ParseInt( const char *str, int32_t & output, int base )
Analice e intente convertir una cadena en un entero de 32 bits con signo, aplicando la interpretación adecuada según el parámetro base.
Detalles | |||||||
---|---|---|---|---|---|---|---|
Parámetros |
| ||||||
Devoluciones | verdadero en el éxito; de lo contrario, falso en caso de falla. |
ParseInt
bool ParseInt( const char *str, uint64_t & output )
Analice e intente convertir una cadena interpretada como un valor decimal en un entero sin signo de 64 bits, aplicando la interpretación adecuada según el parámetro base.
Detalles | |||||
---|---|---|---|---|---|
Parámetros |
| ||||
Devoluciones | cierto sobre el éxito; de lo contrario, falso en caso de falla. |
ParseInt
bool ParseInt( const char *str, uint32_t & output )
Analice e intente convertir una cadena interpretada como un valor decimal en un entero sin signo de 32 bits, aplicando la interpretación adecuada según el parámetro base.
Detalles | |||||
---|---|---|---|---|---|
Parámetros |
| ||||
Devoluciones | verdadero en el éxito; de lo contrario, falso en caso de falla. |
ParseInt
bool ParseInt( const char *str, int32_t & output )
Analice e intente convertir una cadena interpretada como un valor decimal en un entero de 32 bits con signo, aplicando la interpretación adecuada según el parámetro base.
Detalles | |||||
---|---|---|---|---|---|
Parámetros |
| ||||
Devoluciones | verdadero en el éxito; de lo contrario, falso en caso de falla. |
ParseInt
bool ParseInt( const char *str, uint16_t & output )
Analice e intente convertir una cadena interpretada como un valor decimal en un entero sin signo de 16 bits, aplicando la interpretación apropiada basada en el parámetro base.
Detalles | |||||
---|---|---|---|---|---|
Parámetros |
| ||||
Devoluciones | verdadero en el éxito; de lo contrario, falso en caso de falla. |
ParseInt
bool ParseInt( const char *str, int16_t & output )
Analice e intente convertir una cadena interpretada como un valor decimal en un entero de 16 bits con signo, aplicando la interpretación adecuada según el parámetro base.
Detalles | |||||
---|---|---|---|---|---|
Parámetros |
| ||||
Devoluciones | verdadero en el éxito; de lo contrario, falso en caso de falla. |
ParseInt
bool ParseInt( const char *str, uint8_t & output )
Analice e intente convertir una cadena interpretada como un valor decimal en un entero sin signo de 8 bits, aplicando la interpretación adecuada basada en el parámetro base.
Detalles | |||||
---|---|---|---|---|---|
Parámetros |
| ||||
Devoluciones | verdadero en el éxito; de lo contrario, falso en caso de falla. |
ParseNodeId
bool ParseNodeId( const char *str, uint64_t & nodeId )
Analizar un ID de nodo Weave en forma de texto.
La función ParseNodeId () acepta una identificación de nodo de 64 bits dada en formato hexadecimal (con o sin un '0x' inicial), o las palabras 'cualquiera' o 'todos' que se interpretan como cualquier identificación de nodo (0xFFFFFFFFFFFFFFFF) .
Detalles | |||||
---|---|---|---|---|---|
Parámetros |
| ||||
Devoluciones | Es verdadero si el valor se analizó correctamente; falso si no. |
ParseSubnetId
bool ParseSubnetId( const char *str, uint16_t & subnetId )
Analice e intente convertir una cadena en un ID de subred sin firmar de 16 bits, interpretando la cadena como hexadecimal.
Detalles | |||||
---|---|---|---|---|---|
Parámetros |
| ||||
Devoluciones | verdadero en el éxito; de lo contrario, falso en caso de falla. |
PrintOptionHelp
void PrintOptionHelp( OptionSet *optSets[], FILE *s )
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 )