nl:: ArgParser
Resumo
Enumerações |
|
---|---|
OptionArgumentType
|
tipo enumerado Define os requisitos de argumento para uma opção de linha de comando. |
Typedefs |
|
---|---|
NonOptionArgHandlerFunct)(const char *progName, int argc, char *argv[])
|
typedefbool(*
Uma função que pode ser chamada para lidar com quaisquer argumentos de linha de comando não opcionais. |
OptionHandlerFunct)(const char *progName, OptionSet *optSet, int id, const char *name, const char *arg)
|
typedefbool(*
Uma função que pode ser chamada para processar um conjunto de opções de linha de comando. |
Variables |
|
---|---|
PrintArgError = DefaultPrintArgError)(const char *msg,...)
|
void(*
Ponteiro para função usada para imprimir erros que ocorrem durante a análise de argumentos.
|
gActiveOptionSets = NULL
|
OptionSet **
A lista de OptionSets transmitida para a chamada de ParseArgs() atualmente ativa.
|
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
Exibe uma mensagem de erro associada à análise do 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
Analisar um conjunto de argumentos no estilo da linha de comando, chamando funções de processamento para processar cada opção e argumento sem opção
|
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
Analisar um conjunto de argumentos de uma variável de ambiente nomeada.
|
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
Analisa um conjunto de argumentos de uma determinada string.
|
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
Analisar uma string como um valor booleano.
|
ParseFabricId(const char *str, uint64_t & fabricId, bool allowReserved)
|
bool
Analise um ID de tecido do Weave em forma de texto.
|
ParseHexString(const char *hexStr, uint32_t strLen, uint8_t *outBuf, uint32_t outBufSize, uint32_t & outDataLen)
|
bool
Analisa uma string de bytes fornecida em formato hexadecimal.
|
ParseIPAddress(const char *str, IPAddress & output)
|
bool
Analisar um endereço IP em formato de texto.
|
ParseInt(const char *str, uint64_t & output, int base)
|
bool
Analisar e tentar converter uma string em um inteiro não assinado de 64 bits, aplicando a interpretação apropriada com base no parâmetro base.
|
ParseInt(const char *str, uint32_t & output, int base)
|
bool
Analisar e tentar converter uma string em um inteiro não assinado de 32 bits, aplicando a interpretação apropriada com base no parâmetro base.
|
ParseInt(const char *str, int32_t & output, int base)
|
bool
Analisar e tentar converter uma string em um número inteiro assinado de 32 bits, aplicando a interpretação apropriada com base no parâmetro base.
|
ParseInt(const char *str, uint64_t & output)
|
bool
Analisar e tentar converter uma string interpretada como um valor decimal em um número inteiro não sinalizado de 64 bits, aplicando a interpretação apropriada com base no parâmetro base.
|
ParseInt(const char *str, uint32_t & output)
|
bool
Analisar e tentar converter uma string interpretada como um valor decimal em um número inteiro não sinalizado de 32 bits, aplicando a interpretação apropriada com base no parâmetro base.
|
ParseInt(const char *str, int32_t & output)
|
bool
Analisar e tentar converter uma string interpretada como um valor decimal em um número inteiro assinado de 32 bits, aplicando a interpretação apropriada com base no parâmetro base.
|
ParseInt(const char *str, uint16_t & output)
|
bool
Analisar e tentar converter uma string interpretada como um valor decimal em um número inteiro não sinalizado de 16 bits, aplicando a interpretação apropriada com base no parâmetro base.
|
ParseInt(const char *str, int16_t & output)
|
bool
Analisar e tentar converter uma string interpretada como um valor decimal em um número inteiro assinado de 16 bits, aplicando a interpretação apropriada com base no parâmetro base.
|
ParseInt(const char *str, uint8_t & output)
|
bool
Analisar e tentar converter uma string interpretada como um valor decimal em um número inteiro não sinalizado de 8 bits, aplicando a interpretação apropriada com base no parâmetro base.
|
ParseNodeId(const char *str, uint64_t & nodeId)
|
bool
Analisar um ID de nó do Weave em forma de texto.
|
ParseSubnetId(const char *str, uint16_t & subnetId)
|
bool
Analise e tente converter uma string em um ID de sub-rede não assinado de 16 bits, interpretando a string como hexadecimal.
|
PrintOptionHelp(OptionSet *optSets[], FILE *s)
|
void
Exibe o texto de ajuda de uma lista especificada de opções em um fluxo.
|
PutStringWithBlankLine(FILE *s, const char *str)
|
void
|
PutStringWithNewLine(FILE *s, const char *str)
|
void
|
SplitArgs(char *argStr, char **& argList, char *initialArg)
|
int32_t
|
Classes |
|
---|---|
nl:: |
OptionSet comum para processar opções informativas (ajuda, versão). |
nl:: |
Um OptionSet em que o gerenciador é uma função virtual. |
Estruturas |
|
---|---|
nl:: |
Define uma opção de linha de comando. |
nl:: |
Define um grupo de opções de linha de comando reutilizáveis e relacionadas logicamente. |
Enumerações
Tipo de Argumento da Opção
OptionArgumentType
Define os requisitos de argumento para uma opção de linha de comando.
Typedefs
NonOptionArgHandlerFunct
bool(* NonOptionArgHandlerFunct)(const char *progName, int argc, char *argv[])
Uma função que pode ser chamada para lidar com quaisquer argumentos de linha de comando não opcionais.
OptionHandlerFunct
bool(* OptionHandlerFunct)(const char *progName, OptionSet *optSet, int id, const char *name, const char *arg)
Uma função que pode ser chamada para processar um conjunto de opções de linha de comando.
Variables
Erro de impressão
void(* PrintArgError)(const char *msg,...) = DefaultPrintArgError
Ponteiro para função usada para imprimir erros que ocorrem durante a análise de argumentos.
Os apps precisam chamar PrintArgError() para relatar erros nas funções de opção e de tratamento de argumentos sem opção, em vez de imprimir diretamente em stdout/stderr.
O padrão é um ponteiro para a função DefaultPrintArgError()
.
gActiveOptionSets
OptionSet ** gActiveOptionSets = NULL
A lista de OptionSets transmitida para a chamada de ParseArgs() atualmente ativa.
Esse valor será NULL quando nenhuma chamada para ParseArgs() estiver em andamento.
Functions
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, ... )
Exibe uma mensagem de erro associada à análise do argumento.
Função padrão usada para imprimir mensagens de erro que surgem devido à análise de argumentos.
Detalhes | |||
---|---|---|---|
Parâmetros |
|
Os apps precisam chamar o ponteiro da função PrintArgError em vez de chamar essa função diretamente.
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 (em inglês)
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 )
Analisar um conjunto de argumentos no estilo da linha de comando, chamando funções de processamento para processar cada opção e argumento sem opção
O ParseArgs() usa uma lista de argumentos (argv
) e os analisa de acordo com um conjunto de definições de opções fornecidas. A função é compatível com opções longas (opt) e curtas (-o) e implementa a mesma sintaxe de opções da função GNU getopt_long(3).
Detalhes | |||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Parâmetros |
|
||||||||||||
Retorna |
true se todas as opções e argumentos sem opção tiverem sido analisados, false se uma opção não tiver sido reconhecida ou se uma das funções do gerenciador falhou (ou seja, retornou "false"). |
As definições da opção são transmitidas para ParseArgs() como uma matriz de estruturas OptionSet (optSets
). Cada OptionSet contém uma matriz de definições de opção e uma função de gerenciador. O ParseArgs() processa os argumentos de opção na ordem especificada, chamando a respectiva função de gerenciador para cada opção reconhecida. Depois que todas as opções forem analisadas, uma função separada de gerenciador não opcional (nonOptArgHandler
) será chamada uma vez para processar os argumentos restantes.
CONJUNTOS DE OPÇÕES
Um OptionSet contém um conjunto de definições de opção junto com um ponteiro para uma função de gerenciador que será chamada quando uma das opções associadas for encontrada. Os conjuntos de opções também contêm um texto explicativo que descreve a sintaxe e a finalidade de cada opção (consulte AJUDA DE OPÇÃO abaixo). Os conjuntos de opções foram criados para permitir a criação de coleções reutilizáveis de opções relacionadas. Isso simplifica o esforço necessário para manter vários aplicativos que aceitam opções semelhantes (por exemplo, aplicativos de teste).
Há dois padrões para definir o OptionSetsone. Ele pode inicializar uma instância da estrutura OptionSet propriamente dita, por exemplo, como um global estático ou a subclasse OptionSetBase e fornecer um construtor. O último usa uma função HandleOption()
pura virtual para delegar o gerenciamento de opções à subclasse.
As listas de OptionSets são transmitidas para a função ParseArgs() como uma matriz de ponteiros terminada em NULL. Por exemplo:
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)) { ... } }
DEFINIÇÕES DA OPÇÃO
As opções são definidas usando a estrutura OptionDef
. As definições da opção são organizadas como uma matriz de elementos OptionDef, em que cada elemento contém: o nome da opção, um código de número inteiro usado para identificar a opção e se a opção espera/permite um argumento. O final da matriz de opções é sinalizado por um campo de nome NULL. Por exemplo:
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 OPÇÃO
Os IDs das opções identificam opções para o código que as processa (a função OptionHandler). Os IDs das opções são relativos aos OptionSet em que aparecem e, portanto, podem ser reutilizados em diferentes SetSets (consulte a seção SHORT OPTIONS abaixo). A convenção comum é começar a numeração de IDs de opção em 1.000, mas qualquer número > 128 pode ser usado. As opções de alias podem ser criadas usando o mesmo ID de opção com diferentes nomes de opções.
OPÇÕES CURTA
Ao contrário de getopt_long(3), o ParseArgs() não usa uma string separada que especifique a lista de caracteres curtos de opção. Em vez disso, qualquer opção cujo valor de ID esteja no intervalo de caracteres ASCII gráficos permitirá que esse caractere seja usado como uma opção curta.
O ParseArgs() exige que os caracteres de opção curtos sejam exclusivos em all OptionSets. Por isso, o uso de opções curtas não é recomendado para nenhum conjunto de Option compartilhado entre os programas devido à possibilidade significativa de colisões. Os caracteres das opções curtas podem ser reutilizados em um único OptionSet para permitir a criação de nomes de opções longas de alias.
AJUDA DA OPÇÃO
Cada OptionSet contém uma string OptionHelp
que descreve a finalidade e a sintaxe das opções associadas. Essas strings são usadas pela função PrintOptionHelp()
para gerar informações de uso de opções.
Por convenção, as strings de ajuda são um exemplo de sintaxe seguido de uma descrição textual da opção. Se a opção tiver uma versão curta ou um nome de alias, ela será fornecida antes do nome longo principal. Para manter a consistência, as linhas de sintaxe são recuadas em dois espaços, e as linhas de descrição são recuadas em sete. Uma única linha em branco segue cada descrição das opções, incluindo a última.
Por exemplo:
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 AJUDA DE OPÇÃO
OptionSets contém uma string HelpGroupName
usada para agrupar opções na saída de ajuda. A função PrintOptionHelp()
usa o HelpGroupName como um título de seção na saída de uso gerada. Se vários OptionSets tiverem o mesmo HelpGroupName, o PrintOptionHelp() imprimirá a ajuda para os diferentes SetSets juntos em um título de seção comum.
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 )
Analisar um conjunto de argumentos de uma variável de ambiente nomeada.
ParseArgsFromEnvVar() lê uma variável de ambiente nomeada e transmite o valor para ParseArgsFromString()
para análise. Se a variável de ambiente não estiver definida, a função não terá efeito.
Detalhes | |||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|
Parâmetros |
|
||||||||||
Retorna |
true se todas as opções e argumentos que não são de opção tiverem sido analisados com sucesso ou se a variável de ambiente especificada não tiver sido definida. false se uma opção não foi reconhecida, se uma das funções do gerenciador falhou (ou seja, retornou "false") ou se ocorreu um erro 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 )
Analisa um conjunto de argumentos de uma determinada string.
ParseArgsFromString() divide uma determinada string (argStr
) em um conjunto de argumentos e os analisa usando a função ParseArgs().
Detalhes | |||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|
Parâmetros |
|
||||||||||
Retorna |
true : se todas as opções e argumentos que não são de opção foram analisados com sucesso, false se uma opção não foi reconhecida, se uma das funções do gerenciador falhou (ou seja, retornou "false") ou se ocorreu um erro interno. |
A sintaxe das strings de entrada é semelhante à sintaxe do comando shell do Unix, mas com um esquema de aspas simplificado. Em especial:
- Os argumentos são delimitados por espaços em branco, a menos que o espaço em branco seja entre aspas ou com escape.
- Uma barra invertida escapa do caractere a seguir, fazendo com que ele seja tratado como um caractere normal. A barra invertida é removida.
- As substrings de início e término entre aspas simples ou duplas ficam disponíveis. Em uma substring, os únicos caracteres especiais são a barra invertida, que faz o escape do próximo caractere e das aspas finais correspondentes. Os caracteres de citação inicial/final são removidos.
Por exemplo:
--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[] )
Booleana
bool ParseBoolean( const char *str, bool & output )
Analisar uma string como um valor booleano.
Esta função aceita os seguintes valores de entrada (não diferenciam maiúsculas de minúsculas): "true", "yes", "t", "y", "1", "false", "no", "f"&&t;&t;&t;&0;
Detalhes | |||||
---|---|---|---|---|---|
Parâmetros |
|
||||
Retorna |
"true" em caso de sucesso. Caso contrário, "false" em caso de falha.
|
ParseFabricId
bool ParseFabricId( const char *str, uint64_t & fabricId, bool allowReserved )
Analise um ID de tecido do Weave em forma de texto.
A função ParseFabricId() aceita um código de tecido de 64 bits fornecido em formato hexadecimal, com ou sem um '0x' inicial.
Detalhes | |||||||
---|---|---|---|---|---|---|---|
Parâmetros |
|
||||||
Retorna |
"true" se o valor tiver sido analisado, e "false" se não tiver sido analisado.
|
ParseHexString
bool ParseHexString( const char *hexStr, uint32_t strLen, uint8_t *outBuf, uint32_t outBufSize, uint32_t & outDataLen )
Analisa uma string de bytes fornecida em formato hexadecimal.
ParseHexString() espera que a entrada esteja na forma de pares de dígitos hexadecimais (letras maiúsculas ou minúsculas). Os pares hexadecimais podem ser separados por qualquer um dos seguintes caracteres: dois pontos, ponto e vírgula, vírgula, ponto ou traço. Além disso, os caracteres de espaço em branco em qualquer lugar na string de entrada são ignorados.
Detalhes | |||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|
Parâmetros |
|
||||||||||
Retorna |
Verdadeiro se o valor tiver sido analisado com sucesso. Isso será falso se os dados de entrada estiverem incorretos ou se
outBuf for muito pequeno. |
EndereçoAnalisar
bool ParseIPAddress( const char *str, IPAddress & output )
Analisar um endereço IP em formato de texto.
Detalhes | |||||
---|---|---|---|---|---|
Parâmetros |
|
||||
Retorna |
"true" se o valor tiver sido analisado, e "false" se não tiver sido analisado.
|
ParseInt
bool ParseInt( const char *str, uint64_t & output, int base )
Analisar e tentar converter uma string em um inteiro não assinado de 64 bits, aplicando a interpretação apropriada com base no parâmetro base.
Detalhes | |||||||
---|---|---|---|---|---|---|---|
Parâmetros |
|
||||||
Retorna |
"true" em caso de sucesso. Caso contrário, "false" em caso de falha.
|
ParseInt
bool ParseInt( const char *str, uint32_t & output, int base )
Analisar e tentar converter uma string em um inteiro não assinado de 32 bits, aplicando a interpretação apropriada com base no parâmetro base.
Detalhes | |||||||
---|---|---|---|---|---|---|---|
Parâmetros |
|
||||||
Retorna |
"true" em caso de sucesso. Caso contrário, "false" em caso de falha.
|
ParseInt
bool ParseInt( const char *str, int32_t & output, int base )
Analisar e tentar converter uma string em um número inteiro assinado de 32 bits, aplicando a interpretação apropriada com base no parâmetro base.
Detalhes | |||||||
---|---|---|---|---|---|---|---|
Parâmetros |
|
||||||
Retorna |
"true" em caso de sucesso. Caso contrário, "false" em caso de falha.
|
ParseInt
bool ParseInt( const char *str, uint64_t & output )
Analisar e tentar converter uma string interpretada como um valor decimal em um número inteiro não sinalizado de 64 bits, aplicando a interpretação apropriada com base no parâmetro base.
Detalhes | |||||
---|---|---|---|---|---|
Parâmetros |
|
||||
Retorna |
"true" em caso de sucesso. Caso contrário, "false" em caso de falha.
|
ParseInt
bool ParseInt( const char *str, uint32_t & output )
Analisar e tentar converter uma string interpretada como um valor decimal em um número inteiro não sinalizado de 32 bits, aplicando a interpretação apropriada com base no parâmetro base.
Detalhes | |||||
---|---|---|---|---|---|
Parâmetros |
|
||||
Retorna |
"true" em caso de sucesso. Caso contrário, "false" em caso de falha.
|
ParseInt
bool ParseInt( const char *str, int32_t & output )
Analisar e tentar converter uma string interpretada como um valor decimal em um número inteiro assinado de 32 bits, aplicando a interpretação apropriada com base no parâmetro base.
Detalhes | |||||
---|---|---|---|---|---|
Parâmetros |
|
||||
Retorna |
"true" em caso de sucesso. Caso contrário, "false" em caso de falha.
|
ParseInt
bool ParseInt( const char *str, uint16_t & output )
Analisar e tentar converter uma string interpretada como um valor decimal em um número inteiro não sinalizado de 16 bits, aplicando a interpretação apropriada com base no parâmetro base.
Detalhes | |||||
---|---|---|---|---|---|
Parâmetros |
|
||||
Retorna |
"true" em caso de sucesso. Caso contrário, "false" em caso de falha.
|
ParseInt
bool ParseInt( const char *str, int16_t & output )
Analisar e tentar converter uma string interpretada como um valor decimal em um número inteiro assinado de 16 bits, aplicando a interpretação apropriada com base no parâmetro base.
Detalhes | |||||
---|---|---|---|---|---|
Parâmetros |
|
||||
Retorna |
"true" em caso de sucesso. Caso contrário, "false" em caso de falha.
|
ParseInt
bool ParseInt( const char *str, uint8_t & output )
Analisar e tentar converter uma string interpretada como um valor decimal em um número inteiro não sinalizado de 8 bits, aplicando a interpretação apropriada com base no parâmetro base.
Detalhes | |||||
---|---|---|---|---|---|
Parâmetros |
|
||||
Retorna |
"true" em caso de sucesso. Caso contrário, "false" em caso de falha.
|
ParseNodeId
bool ParseNodeId( const char *str, uint64_t & nodeId )
Analisar um ID de nó do Weave em forma de texto.
A função ParseNodeId() aceita um ID de nó de 64 bits em formato hexadecimal (com ou sem um '0x') ou as palavras 'any' ou 'all' que são interpretadas como significando o ID de qualquer nó (0xFFFFFFFFFFFFFFFFFF).
Detalhes | |||||
---|---|---|---|---|---|
Parâmetros |
|
||||
Retorna |
"true" se o valor tiver sido analisado, e "false" se não tiver sido analisado.
|
Analisar sub-redeId
bool ParseSubnetId( const char *str, uint16_t & subnetId )
Analise e tente converter uma string em um ID de sub-rede não assinado de 16 bits, interpretando a string como hexadecimal.
Detalhes | |||||
---|---|---|---|---|---|
Parâmetros |
|
||||
Retorna |
"true" em caso de sucesso. Caso contrário, "false" em caso de falha.
|
Ajuda para impressão
void PrintOptionHelp( OptionSet *optSets[], FILE *s )
Exibe o texto de ajuda de uma lista especificada de opções em um fluxo.
Detalhes | |||||
---|---|---|---|---|---|
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 )