nl :: ArgParser
Resumo
Enumerações | |
---|---|
OptionArgumentType | enum 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 restantes. |
OptionHandlerFunct )(const char *progName, OptionSet *optSet, int id, const char *name, const char *arg) | typedefbool(* Uma função que pode ser chamada para lidar com um conjunto de opções de linha de comando. |
Variáveis | |
---|---|
PrintArgError = DefaultPrintArgError)(const char *msg,...) | void(* Ponteiro para função usado para imprimir erros que ocorrem durante a análise de argumento. |
gActiveOptionSets = NULL | OptionSet ** A lista de OptionSets passada para a chamada ParseArgs () atualmente ativa. |
Funções | |
---|---|
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 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 Analisa um conjunto de argumentos de estilo de linha de comando, chamando funções de manipulação para processar cada opção e argumento de não 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 Analisa 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 Analisa uma string como um valor booleano. |
ParseFabricId (const char *str, uint64_t & fabricId, bool allowReserved) | bool Analisa a identificação de um tecido Weave em formato 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 Analisa um endereço IP em formato de texto. |
ParseInt (const char *str, uint64_t & output, int base) | bool Analise e tente converter uma string em um inteiro sem sinal de 64 bits, aplicando a interpretação apropriada com base no parâmetro base. |
ParseInt (const char *str, uint32_t & output, int base) | bool Analise e tente converter uma string em um inteiro sem sinal de 32 bits, aplicando a interpretação apropriada com base no parâmetro base. |
ParseInt (const char *str, int32_t & output, int base) | bool Analise e tente converter uma string em um inteiro assinado de 32 bits, aplicando a interpretação apropriada com base no parâmetro base. |
ParseInt (const char *str, uint64_t & output) | bool Analise e tente converter uma string interpretada como um valor decimal em um inteiro sem sinal de 64 bits, aplicando a interpretação apropriada com base no parâmetro base. |
ParseInt (const char *str, uint32_t & output) | bool Analise e tente converter uma string interpretada como um valor decimal em um inteiro sem sinal de 32 bits, aplicando a interpretação apropriada com base no parâmetro base. |
ParseInt (const char *str, int32_t & output) | bool Analise e tente converter uma string interpretada como um valor decimal em um inteiro assinado de 32 bits, aplicando a interpretação apropriada com base no parâmetro base. |
ParseInt (const char *str, uint16_t & output) | bool Analise e tente converter uma string interpretada como um valor decimal em um inteiro sem sinal de 16 bits, aplicando a interpretação apropriada com base no parâmetro base. |
ParseInt (const char *str, int16_t & output) | bool Analise e tente converter uma string interpretada como um valor decimal em um inteiro com sinal de 16 bits, aplicando a interpretação apropriada com base no parâmetro base. |
ParseInt (const char *str, uint8_t & output) | bool Analise e tente converter uma string interpretada como um valor decimal em um inteiro sem sinal de 8 bits, aplicando a interpretação apropriada com base no parâmetro base. |
ParseNodeId (const char *str, uint64_t & nodeId) | bool Analisa a id de um nó Weave em formato de texto. |
ParseSubnetId (const char *str, uint16_t & subnetId) | bool Analise e tente converter uma string em uma ID de sub-rede não assinada de 16 bits, interpretando a string como hexadecimal. |
PrintOptionHelp ( OptionSet *optSets[], FILE *s) | void Imprima o texto de ajuda para uma lista especificada de opções para 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 |
Aulas | |
---|---|
nl :: ArgParser :: HelpOptions | Comum optionset para lidar com opções informativos (ajuda, versão). |
nl :: ArgParser :: OptionSetBase | Um optionset onde o manipulador é uma função virtual. |
Structs | |
---|---|
nl :: ArgParser :: optiondef | Define uma opção de linha de comando. |
nl :: ArgParser :: optionset | Define um grupo de opções de linha de comando reutilizáveis e relacionadas de forma lógica. |
Enumerações
OptionArgumentType
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 restantes.
OptionHandlerFunct
bool(* OptionHandlerFunct)(const char *progName, OptionSet *optSet, int id, const char *name, const char *arg)
Uma função que pode ser chamada para lidar com um conjunto de opções de linha de comando.
Variáveis
PrintArgError
void(* PrintArgError)(const char *msg,...) = DefaultPrintArgError
Ponteiro para função usado para imprimir erros que ocorrem durante a análise de argumento.
Os aplicativos devem chamar PrintArgError () para relatar erros em suas funções de manipulação de argumentos de opções e não opções, em vez de imprimir diretamente em stdout / stderr.
O padrão é um ponteiro para o DefaultPrintArgError()
função.
gActiveOptionSets
OptionSet ** gActiveOptionSets = NULL
A lista de OptionSets passada para a chamada ParseArgs () atualmente ativa.
Este valor será NULL quando nenhuma chamada para ParseArgs () estiver em andamento.
Funções
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 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 aplicativos devem chamar por meio do ponteiro de 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
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 )
Analisa um conjunto de argumentos de estilo de linha de comando, chamando funções de manipulação para processar cada opção e argumento de não opção.
ParseArgs () recebe uma lista de argumentos ( argv
) e analisa-los de acordo com um conjunto de definições de opções fornecidas. A função suporta as opções long (opt) e short (-o) e implementa a mesma sintaxe de opção que a função GNU getopt_long (3).
Detalhes | |||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Parâmetros |
| ||||||||||||
Devoluções | true se todas as opções e argumentos que não sejam opções foram analisadas com êxito; false se uma opção não foi reconhecido ou se uma das funções do identificador de falha (ou seja retornado false). |
Definições de opções são passados para ParseArgs () como uma matriz de optionset estruturas ( optSets
). Cada optionset contém uma série de definições de opções e uma função de manipulador. ParseArgs () processa os argumentos das opções na ordem dada, chamando a respectiva função de tratamento para cada opção reconhecida. Uma vez que todas as opções foram analisadas, uma função separada manipulador de não-opção ( nonOptArgHandler
) é chamado uma vez para processar todos os demais argumentos.
CONJUNTOS DE OPÇÕES
Um optionset contém um conjunto de definições de opções, juntamente com um ponteiro para uma função de manipulador que será chamado quando uma das opções associadas é encontrado. Os conjuntos de opções também contêm texto de ajuda que descreve a sintaxe e o propósito de cada opção (consulte AJUDA DE OPÇÕES abaixo). Os conjuntos de opções são projetados 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).
Existem dois padrões para definir OptionSetsone pode inicializar uma instância do optionset struct em si, por exemplo, como estática global, ou subclasseOptionSetBase e fornecer um construtor. Estas últimas utilizações um virtual pura HandleOption()
função delegar manuseamento opção para a subclasse.
Listas de OptionSets são passadas para a função ParseArgs () como uma matriz terminada em NULL de ponteiros. 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 o OptionDef
estrutura. Definições de opções são organizadas como uma série de optiondef elementos, em que cada elemento contém: o nome da opção, um ID de número inteiro que é usada para identificar a opção, e se as espera opção / permite um argumento. O fim do array de opções é sinalizado por um campo NULL Name. 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 } };
OPÇÃO IDS
Os IDs de opção identificam opções para o código que os manipula (a função OptionHandler). Ids opção são relativas ao optionset em que eles aparecem, e, portanto, podem ser reutilizados em diferentes OptionSets (no entanto, ver SHORT opções abaixo). A convenção comum é começar a numerar os ids de opção em 1000; no entanto, qualquer número> 128 pode ser usado. As opções de alias podem ser criadas usando o mesmo id de opção com nomes de opção diferentes.
OPÇÕES CURTAS
Ao contrário de getopt_long (3), ParseArgs () não usa uma string separada especificando a lista de caracteres de opção curtos. Em vez disso, qualquer opção cujo valor de id caia no intervalo de caracteres ASCII gráficos permitirá que esse caractere seja usado como uma opção curta.
ParseArgs () requer que os caracteres curtas de opções ser exclusivo em todos OptionSets. Por causa disso, o uso de opções curtas é desencorajado para quaisquer OptionSets que são compartilhados entre programas devido à chance significativa de colisões. Opções curtas caracteres podem ser reutilizados dentro de um único optionset para permitir a criação de nomes de alias longo de opção.
AJUDA DE OPÇÃO
Cada optionset contém um OptionHelp
cadeia que descreve a finalidade ea sintaxe das opções associadas. Essas seqüências são usados pelo PrintOptionHelp()
função para gerar informações de uso opção.
Por convenção, as strings de ajuda da opção consistem em um exemplo de sintaxe seguido por uma descrição textual da opção. Se a opção tiver uma versão curta ou um nome alternativo, ela será fornecida antes do nome longo principal. Para consistência, as linhas de sintaxe são indentadas com 2 espaços, enquanto as linhas de descrição são indentadas com 7 espaços. Uma única linha em branco segue a descrição de cada opção, 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ÇÕES
OptionSets conter uma HelpGroupName
corda que é usado para opções de agrupar na saída ajuda. O PrintOptionHelp()
função utiliza o HelpGroupName como um título de secção no uso de saída gerados. Se vários OptionSets tiverem o mesmo HelpGroupName, PrintOptionHelp () imprimirá a ajuda da opção para os diferentes OptionSets juntos sob 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 )
Analisa um conjunto de argumentos de uma variável de ambiente nomeada.
ParseArgsFromEnvVar () lê uma variável de ambiente chamada e passa o valor para ParseArgsFromString()
para analisar. Se a variável de ambiente não for definida, a função não fará nada.
Detalhes | |||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|
Parâmetros |
| ||||||||||
Devoluções | true se todas as opções e argumentos não-opção foi analisado com êxito, ou se a variável de ambiente especificada não está definido; false se uma opção não foi reconhecido, se uma das funções do identificador de falha (ou seja retornado 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 analisa os argumentos usando a função de () ParseArgs.
Detalhes | |||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|
Parâmetros |
| ||||||||||
Devoluções | true se todas as opções e argumentos que não sejam opções foram analisadas com êxito; false se uma opção não foi reconhecido, se uma das funções do identificador de falha (ou seja retornado false) ou se ocorreu um erro interno. |
A sintaxe das strings de entrada é semelhante à sintaxe de comando do shell Unix, mas com um esquema de aspas simplificado. Especificamente:
- Os argumentos são delimitados por espaços em branco, a menos que o espaço em branco esteja entre aspas ou com escape.
- Uma barra invertida escapa do caractere seguinte, fazendo com que seja tratado como um caractere normal. A barra invertida em si é removida.
- Aspas simples ou duplas começam / terminam substrings entre aspas. Em uma substring, os únicos caracteres especiais são a barra invertida, que escapa ao próximo caractere e a aspa final correspondente. Os caracteres de aspas de início / fim 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[] )
ParseBoolean
bool ParseBoolean( const char *str, bool & output )
Analisa uma string como um valor booleano.
Esta função aceita os seguintes valores de entrada (não diferencia maiúsculas de minúsculas): "verdadeiro", "sim", "t", "y", "1", "falso", "não", "f", "n", " 0 ".
Detalhes | |||||
---|---|---|---|---|---|
Parâmetros |
| ||||
Devoluções | verdadeiro no sucesso; caso contrário, falso em caso de falha. |
ParseFabricId
bool ParseFabricId( const char *str, uint64_t & fabricId, bool allowReserved )
Analisa a identificação de um tecido Weave em formato de texto.
A função ParseFabricId () aceita um ID de malha de 64 bits fornecido em formato hexadecimal, com ou sem um '0x' à esquerda.
Detalhes | |||||||
---|---|---|---|---|---|---|---|
Parâmetros |
| ||||||
Devoluções | true se o valor foi analisado com sucesso; falso se não. |
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 (maiúsculas ou minúsculas). Os pares hexadecimais podem ser separados opcionalmente 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 da string de entrada são ignorados.
Detalhes | |||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|
Parâmetros |
| ||||||||||
Devoluções | true se o valor foi analisado com sucesso; false se os dados de entrada é mal formado ou se outBuf é muito pequeno. |
ParseIPAddress
bool ParseIPAddress( const char *str, IPAddress & output )
Analisa um endereço IP em formato de texto.
Detalhes | |||||
---|---|---|---|---|---|
Parâmetros |
| ||||
Devoluções | true se o valor foi analisado com sucesso; falso se não. |
ParseInt
bool ParseInt( const char *str, uint64_t & output, int base )
Analise e tente converter uma string em um inteiro sem sinal de 64 bits, aplicando a interpretação apropriada com base no parâmetro base.
Detalhes | |||||||
---|---|---|---|---|---|---|---|
Parâmetros |
| ||||||
Devoluções | verdadeiro no sucesso; caso contrário, falso em caso de falha. |
ParseInt
bool ParseInt( const char *str, uint32_t & output, int base )
Analise e tente converter uma string em um inteiro sem sinal de 32 bits, aplicando a interpretação apropriada com base no parâmetro base.
Detalhes | |||||||
---|---|---|---|---|---|---|---|
Parâmetros |
| ||||||
Devoluções | verdadeiro no sucesso; caso contrário, falso em caso de falha. |
ParseInt
bool ParseInt( const char *str, int32_t & output, int base )
Analise e tente converter uma string em um inteiro assinado de 32 bits, aplicando a interpretação apropriada com base no parâmetro base.
Detalhes | |||||||
---|---|---|---|---|---|---|---|
Parâmetros |
| ||||||
Devoluções | verdadeiro no sucesso; caso contrário, falso em caso de falha. |
ParseInt
bool ParseInt( const char *str, uint64_t & output )
Analise e tente converter uma string interpretada como um valor decimal em um inteiro sem sinal de 64 bits, aplicando a interpretação apropriada com base no parâmetro base.
Detalhes | |||||
---|---|---|---|---|---|
Parâmetros |
| ||||
Devoluções | verdadeiro no sucesso; caso contrário, falso em caso de falha. |
ParseInt
bool ParseInt( const char *str, uint32_t & output )
Analise e tente converter uma string interpretada como um valor decimal em um inteiro sem sinal de 32 bits, aplicando a interpretação apropriada com base no parâmetro base.
Detalhes | |||||
---|---|---|---|---|---|
Parâmetros |
| ||||
Devoluções | verdadeiro no sucesso; caso contrário, falso em caso de falha. |
ParseInt
bool ParseInt( const char *str, int32_t & output )
Analise e tente converter uma string interpretada como um valor decimal em um inteiro assinado de 32 bits, aplicando a interpretação apropriada com base no parâmetro base.
Detalhes | |||||
---|---|---|---|---|---|
Parâmetros |
| ||||
Devoluções | verdadeiro no sucesso; caso contrário, falso em caso de falha. |
ParseInt
bool ParseInt( const char *str, uint16_t & output )
Analise e tente converter uma string interpretada como um valor decimal em um inteiro sem sinal de 16 bits, aplicando a interpretação apropriada com base no parâmetro base.
Detalhes | |||||
---|---|---|---|---|---|
Parâmetros |
| ||||
Devoluções | verdadeiro no sucesso; caso contrário, falso em caso de falha. |
ParseInt
bool ParseInt( const char *str, int16_t & output )
Analise e tente converter uma string interpretada como um valor decimal em um inteiro com sinal de 16 bits, aplicando a interpretação apropriada com base no parâmetro base.
Detalhes | |||||
---|---|---|---|---|---|
Parâmetros |
| ||||
Devoluções | verdadeiro no sucesso; caso contrário, falso em caso de falha. |
ParseInt
bool ParseInt( const char *str, uint8_t & output )
Analise e tente converter uma string interpretada como um valor decimal em um inteiro sem sinal de 8 bits, aplicando a interpretação apropriada com base no parâmetro base.
Detalhes | |||||
---|---|---|---|---|---|
Parâmetros |
| ||||
Devoluções | verdadeiro no sucesso; caso contrário, falso em caso de falha. |
ParseNodeId
bool ParseNodeId( const char *str, uint64_t & nodeId )
Analisa a id de um nó Weave em formato de texto.
A função ParseNodeId () aceita um id de nó de 64 bits fornecido em formato hexadecimal (com ou sem um '0x' à esquerda) ou as palavras 'qualquer' ou 'todos', que são interpretadas como significando o ID de qualquer nó (0xFFFFFFFFFFFFFFFF) .
Detalhes | |||||
---|---|---|---|---|---|
Parâmetros |
| ||||
Devoluções | true se o valor foi analisado com sucesso; falso se não. |
ParseSubnetId
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 |
| ||||
Devoluções | verdadeiro no sucesso; caso contrário, falso em caso de falha. |
PrintOptionHelp
void PrintOptionHelp( OptionSet *optSets[], FILE *s )
Imprima o texto de ajuda para uma lista especificada de opções para 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 )