Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.

nl::ArgParser

Fazit

Aufzählungen

OptionArgumentType enum
Definiert die Anforderungen an das Argument für eine Befehlszeilenoption.

Typdef.

NonOptionArgHandlerFunct)(const char *progName, int argc, char *argv[]) Typdef
bool(*
Eine Funktion, die aufgerufen werden kann, um alle Befehlszeilenargumente zu speichern, die keine Optionen sind.
OptionHandlerFunct)(const char *progName, OptionSet *optSet, int id, const char *name, const char *arg) Typdef
bool(*
Eine Funktion, die aufgerufen werden kann, um eine Reihe von Befehlszeilenoptionen zu verarbeiten.

Variablen

PrintArgError = DefaultPrintArgError)(const char *msg,...)
void(*
Zeiger zur Funktion, die zum Drucken von Fehlern verwendet wird, die beim Parsen des Arguments auftreten.
gActiveOptionSets = NULL
Die Liste der OptionSets, die an den derzeit aktiven ParseArgs()-Aufruf übergeben wird.

Funktionen

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
Gibt eine Fehlermeldung aus, die mit dem Argument-Parsing verknüpft ist.
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
Parsen Sie eine Reihe von Befehlszeilenargumenten, in denen Bearbeitungsfunktionen für die Verarbeitung jeder Option und jedes Arguments ohne Option aufgerufen werden.
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
Parsen Sie eine Reihe von Argumenten aus einer benannten Umgebungsvariablen.
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
Parsen Sie eine Reihe von Argumenten aus einem bestimmten 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
String als booleschen Wert parsen
ParseFabricId(const char *str, uint64_t & fabricId, bool allowReserved)
bool
Parsen Sie eine Weave-Stoff-ID in Textform.
ParseHexString(const char *hexStr, uint32_t strLen, uint8_t *outBuf, uint32_t outBufSize, uint32_t & outDataLen)
bool
Parsen eines als Hexadezimalwert angegebenen Strings in Byte.
ParseIPAddress(const char *str, IPAddress & output)
bool
IP-Adresse im Text parsen
ParseInt(const char *str, uint64_t & output, int base)
bool
Parsen und Umwandeln eines Strings in eine nicht signierte 64-Bit-Ganzzahl mit der entsprechenden Interpretation auf der Grundlage des Basisparameters
ParseInt(const char *str, uint32_t & output, int base)
bool
Parsen und Konvertieren eines Strings in eine nicht signierte 32-Bit-Ganzzahl mit der entsprechenden Interpretation auf der Grundlage des Basisparameters
ParseInt(const char *str, int32_t & output, int base)
bool
Parsen und Konvertieren eines Strings in eine 32-Bit-Vorzeichen-Ganzzahl unter Anwendung der entsprechenden Interpretation auf der Grundlage des Basisparameters
ParseInt(const char *str, uint64_t & output)
bool
Parsen eines als Dezimalwert interpretierten Strings in eine 64-Bit-Ganzzahl ohne Vorzeichen, wobei die passende Interpretation auf Grundlage des Basisparameters angewendet wird.
ParseInt(const char *str, uint32_t & output)
bool
Parsen eines als Dezimalwert interpretierten Strings in eine 32-Bit-Ganzzahl ohne Vorzeichen, wobei die passende Interpretation auf Grundlage des Basisparameters angewendet wird.
ParseInt(const char *str, int32_t & output)
bool
String, der als Dezimalwert interpretiert wird, parsen und in eine vorzeichenbehaftete 32-Bit-Ganzzahl umwandeln, wobei die Interpretation auf Grundlage des Basisparameters angewendet wird
ParseInt(const char *str, uint16_t & output)
bool
Parsen Sie einen als Dezimalwert interpretierten String in eine 16-Bit-Ganzzahl ohne Vorzeichen. Dabei wird die Interpretation auf Grundlage des Basisparameters angewendet.
ParseInt(const char *str, int16_t & output)
bool
Parsen eines als Dezimalwert interpretierten Strings in eine 16-Bit-Ganzzahl mit Ganzzahl, wobei die passende Interpretation auf Grundlage des Basisparameters angewendet wird.
ParseInt(const char *str, uint8_t & output)
bool
String, der als Dezimalwert ausgewertet wird, muss in eine 8-Bit-Ganzzahl ohne Vorzeichen konvertiert werden. Dabei wird die geeignete Interpretation auf Grundlage des Basisparameters angewendet.
ParseNodeId(const char *str, uint64_t & nodeId)
bool
Parsen Sie eine Weave-Knoten-ID in Textform.
ParseSubnetId(const char *str, uint16_t & subnetId)
bool
Parsen und Konvertieren eines Strings in eine 16-Bit-Subnetz-ID ohne Vorzeichen. Dabei wird der String als Hexadezimalwert interpretiert.
PrintOptionHelp(OptionSet *optSets[], FILE *s)
void
Drucken Sie den Hilfetext für eine bestimmte Liste von Optionen zu einem Stream.
PutStringWithBlankLine(FILE *s, const char *str)
void
PutStringWithNewLine(FILE *s, const char *str)
void
SplitArgs(char *argStr, char **& argList, char *initialArg)
int32_t

Klassen

nl::ArgParser::Hilfeoptionen

Allgemeine OptionSet für die Verarbeitung von Informationsoptionen (Hilfe, Version).

nl::ArgParser::OptionSetBase.

Ein OptionSet, bei dem der Handler eine virtuelle Funktion ist.

Strebenklemmen

nl::ArgParser::OptionDef

Definiert eine Befehlszeilenoption.

nl::ArgParser::OptionSet

Definiert eine Gruppe logischer und wiederverwendbarer Befehlszeilenoptionen.

Aufzählungen

OptionArgumentType

 OptionArgumentType

Definiert die Anforderungen an das Argument für eine Befehlszeilenoption.

Typdef.

NonOptionArgHandlerFunct

bool(* NonOptionArgHandlerFunct)(const char *progName, int argc, char *argv[])

Eine Funktion, die aufgerufen werden kann, um alle Befehlszeilenargumente zu speichern, die keine Optionen sind.

OptionHandlerFunct

bool(* OptionHandlerFunct)(const char *progName, OptionSet *optSet, int id, const char *name, const char *arg)

Eine Funktion, die aufgerufen werden kann, um eine Reihe von Befehlszeilenoptionen zu verarbeiten.

Variablen

PrintArgFehler

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

Zeiger zur Funktion, die zum Drucken von Fehlern verwendet wird, die beim Parsen des Arguments auftreten.

Anwendungen sollten PrintArgError() aufrufen, um Fehler in der Option und in Funktionen ohne Argumente zu melden.

Standardmäßig wird ein Zeiger auf die Funktion DefaultPrintArgError() angezeigt.

gActiveOptionSets

OptionSet ** gActiveOptionSets = NULL

Die Liste der OptionSets, die an den derzeit aktiven ParseArgs()-Aufruf übergeben wird.

Dieser Wert ist NULL, wenn kein Aufruf von ParseArgs() ausgeführt wird.

Funktionen

AnzahlAlleOptionen

size_t CountAllOptions(
  OptionSet *optSets[]
)

AnzahlAlleOptionen

size_t CountAllOptions(
  OptionSet **optSets
)

CountOptionSets

size_t CountOptionSets(
  OptionSet *optSets[]
)

CountOptionSets

size_t CountOptionSets(
  OptionSet **optSets
)

Standarddrucker-Fehler

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

Gibt eine Fehlermeldung aus, die mit dem Argument-Parsing verknüpft ist.

Standardfunktion zur Ausgabe von Fehlermeldungen, die beim Parsen von Argumenten auftreten.

Details
Parameter
[in] msg
Die zu druckende Nachricht

Anwendungen sollten den Funktionsaufruf „PrintArgError“ aufrufen, anstatt die Funktion direkt aufzurufen.

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
)

Logo: IsShortOptionChar

bool IsShortOptionChar(
  int ch
)

MakeLong-Optionen

struct option * MakeLongOptions(
  OptionSet **optSets
)

MakeShort-Optionen

char * MakeShortOptions(
  OptionSet **optSets
)

MakeUniqueHelpGroupNamesListe

const char ** MakeUniqueHelpGroupNamesList(
  OptionSet *optSets[]
)

ParseArgs

bool ParseArgs(
  const char *progName,
  int argc,
  char *argv[],
  OptionSet *optSets[],
  NonOptionArgHandlerFunct nonOptArgHandler,
  bool ignoreUnknown
)

Parsen Sie eine Reihe von Befehlszeilenargumenten, in denen Bearbeitungsfunktionen für die Verarbeitung jeder Option und jedes Arguments ohne Option aufgerufen werden.

ParseArgs() verwendet eine Liste von Argumenten (argv) und parst sie gemäß einer Reihe von bereitgestellten Optionsdefinitionen. Die Funktion unterstützt sowohl die Option „Lang (Opt)“ als auch die Option „Kurz“ (-O) und implementiert dieselbe Syntax wie die GNU getopt_long(3)-Funktion.

Details
Parameter
[in] progName
Der Name des Programms oder des Kontexts, in dem die Argumente geparst werden. Mit diesem String werden Fehlermeldungen und Warnungen vorangestellt.
[in] argc
Die Anzahl der zu parierenden Argumente, plus 1.
[in] argv
Ein Array von Argumenten, die geparst werden sollen. Die Array-Länge muss 1 größer als der für argc angegebene Wert sein, und argv[argc] muss auf NULL gesetzt werden. Das Parsen des Arguments beginnt mit dem Array-Element arg (argv[1]); Element 0 wird ignoriert.
[in] optSets
Eine Liste mit Verweisen auf OptionSet-Strukturen, mit denen die rechtlichen Optionen definiert werden. Die angegebene Liste muss mit NULL beendet werden.
[in] nonOptArgHandler
Ein Zeiger auf eine Funktion, die aufgerufen wird, wenn das Parsen von Optionen abgeschlossen ist, mit allen übrigen Argumenten, die keine Optionen sind . Die Funktion wird unabhängig davon aufgerufen, ob Argumente erhalten bleiben. Wenn ein NULL-Wert übergeben wird, meldet ParseArgs() einen Fehler, wenn Argumente, die keine Optionen sind, vorhanden sind.
[in] ignoreUnknown
Bei „true“ werden unbekannte Optionen ignoriert.
Rückgabe
true, wenn alle Optionen und Nicht-Optionsargumente erfolgreich geparst wurden; false, wenn eine Option nicht erkannt wurde oder eine der Handler-Funktionen fehlgeschlagen sind (d.h. false wurde zurückgegeben).

Optionsdefinitionen werden an ParseArgs() als Array mit OptionSet-Strukturen (optSets) übergeben. Jedes OptionSet enthält ein Array mit Optionsdefinitionen und eine Handler-Funktion. ParsingArgs()-Argumente werden in der angegebenen Reihenfolge verarbeitet. Die entsprechende Handler-Funktion wird für jede erkannte Option aufgerufen. Nachdem alle Optionen geparst wurden, wird eine separate Nicht-Handler-Funktion (nonOptArgHandler) aufgerufen, um alle verbleibenden Argumente zu verarbeiten.

OPTIONENSETS

Ein OptionSet enthält eine Reihe von Optionsdefinitionen sowie einen Mauszeiger auf eine Handler-Funktion, die aufgerufen wird, wenn eine der verknüpften Optionen gefunden wird. Optionssätze enthalten auch Hilfetext zur Beschreibung der Syntax und des Zwecks der einzelnen Optionen (siehe OPTION HILFE). Sie haben die Möglichkeit, wiederverwendbare Sammlungen ähnlicher Optionen zu erstellen. Das vereinfacht den Aufwand für die Wartung mehrerer Anwendungen, die ähnliche Optionen akzeptieren (z.B. Testanwendungen).

Es gibt zwei Muster zum Definieren von OptionSetsone: Entweder initialisieren Sie eine Instanz der Struktur OptionSet selbst, z.B. als statisches globales Element, oder als Unterklasse OptionSetBase und geben einen Konstruktor an. Letztere verwendet eine reine HandleOption()-Funktion, um die Verarbeitung von Optionen an die untergeordnete Klasse zu delegieren.

Listen von OptionSets werden als NULL-terminiertes Array von Zeigern an die ParseArgs()-Funktion übergeben. z.B.:

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))
    {
        ...
    }
}

OPTIONENDEFINITIONEN

Optionen werden mit der Struktur OptionDef definiert. Optionsdefinitionen sind als ein Array von OptionDef-Elementen organisiert, wobei jedes Element Folgendes enthält: den Namen der Option, eine Ganzzahl-ID, die zur Identifizierung der Option verwendet wird, und die Frage, ob die Option ein Argument erwartet/erlaubt. Das Ende des Optionsarrays wird durch das Feld NULL-Name signalisiert. z.B.:

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 }
};

OPTIONEN-IDs

Options-IDs kennzeichnen Optionen dem Code, der sie verarbeitet (OptionHandler). Options-IDs sind relativ zum OptionSet, in dem sie angezeigt werden, und können daher in verschiedenen OptionSets verwendet werden. Weitere Informationen finden Sie unter SHORT OPTIONS. Üblicherweise wird die Nummerierungsoption bei 1.000 begonnen, es kann jedoch jede Zahl 128 verwendet werden. Alias-Optionen können mit derselben Option-ID mit unterschiedlichen Optionsnamen erstellt werden.

KURZE OPTIONEN

Im Gegensatz zu getopt_long(3) verwendet ParseArgs() keine separate Zeichenfolge für die Liste von kurzen Optionszeichen. Für jede Option, deren ID-Wert in den Bereich der grafischen ASCII-Zeichen fällt, kann dieses Zeichen als kurze Option verwendet werden.

„ParseArgs()“ erfordert, dass die Kurzzeichenzeichen in all OptionSets eindeutig sind. Aus diesem Grund wird von der Verwendung von kurzen Optionen für OptionSets abgeraten, die von mehreren Programmen gemeinsam genutzt werden, da dies die Wahrscheinlichkeit von Konflikten erhöht. Kurze Optionszeichen können innerhalb eines einzelnen OptionSet wiederverwendet werden, um das Erstellen von Alias-Optionen zu erstellen.

OPTION HILFE

Jeder OptionSet enthält einen OptionHelp-String, der den Zweck und die Syntax der zugehörigen Optionen beschreibt. Diese Strings werden von der Funktion PrintOptionHelp() verwendet, um Informationen zur Nutzung von Optionen zu generieren.

Konventionelle Hilfestrings bestehen standardmäßig aus einem Syntaxbeispiel gefolgt von einer Textbeschreibung der Option. Wenn die Option eine kurze Version oder einen Alias-Namen hat, wird sie vor dem primären langen Namen angegeben. Aus Konsistenzgründen werden Syntaxzeilen mit zwei Leerzeichen, Textzeilen mit sieben Leerzeichen eingerückt. Nach jeder Optionsbeschreibung, einschließlich der letzten, wird eine einzelne leere Zeile angezeigt.

z.B.:

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";

OPTION HILFE

OptionSets enthalten einen HelpGroupName-String, mit dem Optionen in der Hilfe ausgegeben werden. Die Funktion PrintOptionHelp() verwendet den HelpGroupName als Abschnittstitel in der generierten Nutzungsausgabe. Wenn mehrere OptionSets denselben HelpGroupName haben, druckt PrintOptionHelp() die Hilfe für die verschiedenen Optionssätze unter einem gemeinsamen Abschnittstitel aus.

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

bool ParseArgsFromEnvVar(
  const char *progName,
  const char *varName,
  OptionSet *optSets[],
  NonOptionArgHandlerFunct nonOptArgHandler,
  bool ignoreUnknown
)

Parsen Sie eine Reihe von Argumenten aus einer benannten Umgebungsvariablen.

ParseArgsFromEnvVar() liest eine benannte Umgebungsvariable und übergibt den Wert zum Parsen an ParseArgsFromString(). Wenn die Umgebungsvariable nicht festgelegt ist, wird keine Funktion ausgeführt.

Details
Parameter
[in] progName
Der Name des Programms oder des Kontexts, in dem die Argumente geparst werden. Mit diesem String werden Fehlermeldungen und Warnungen vorangestellt.
[in] varName
Der Name der Umgebungsvariablen.
[in] optSets
Eine Liste mit Verweisen auf OptionSet-Strukturen, mit denen die rechtlichen Optionen definiert werden. Die angegebene Liste muss mit NULL beendet werden.
[in] nonOptArgHandler
Ein Zeiger auf eine Funktion, die aufgerufen wird, wenn das Parsen von Optionen abgeschlossen ist, mit allen übrigen Argumenten, die keine Optionen sind . Die Funktion wird unabhängig davon aufgerufen, ob Argumente erhalten bleiben. Wenn ein NULL-Wert übergeben wird, meldet ParseArgs() einen Fehler, wenn Argumente, die keine Optionen sind, vorhanden sind.
[in] ignoreUnknown
Bei „true“ werden unbekannte Optionen ignoriert.
Rückgabe
true, wenn alle Optionen und Nicht-Argumente erfolgreich geparst wurden oder die angegebene Umgebungsvariable nicht festgelegt ist; false, wenn eine Option nicht erkannt wurde, wenn eine der Handler-Funktionen fehlgeschlagen sind (z.B. „false“ zurückgegeben wurde) oder ein interner Fehler aufgetreten ist.

ParseArgsFromEnvVar-Element

bool ParseArgsFromEnvVar(
  const char *progName,
  const char *varName,
  OptionSet *optSets[]
)

ParseArgsFromEnvVar-Element

bool ParseArgsFromEnvVar(
  const char *progName,
  const char *varName,
  OptionSet *optSets[],
  NonOptionArgHandlerFunct nonOptArgHandler
)

ParsingArgsFromString

bool ParseArgsFromString(
  const char *progName,
  const char *argStr,
  OptionSet *optSets[],
  NonOptionArgHandlerFunct nonOptArgHandler,
  bool ignoreUnknown
)

Parsen Sie eine Reihe von Argumenten aus einem bestimmten String.

ParseArgsFromString() teilt einen bestimmten String (argStr) in eine Reihe von Argumenten auf und parst die Argumente mithilfe der Funktion „ParseArgs()“.

Details
Parameter
[in] progName
Der Name des Programms oder des Kontexts, in dem die Argumente geparst werden. Mit diesem String werden Fehlermeldungen und Warnungen vorangestellt.
[in] argStr
Ein String mit Optionen und Argumenten, die geparst werden sollen.
[in] optSets
Eine Liste mit Verweisen auf OptionSet-Strukturen, mit denen die rechtlichen Optionen definiert werden. Die angegebene Liste muss mit NULL beendet werden.
[in] nonOptArgHandler
Ein Zeiger auf eine Funktion, die aufgerufen wird, wenn das Parsen von Optionen abgeschlossen ist, mit allen übrigen Argumenten, die keine Optionen sind . Die Funktion wird unabhängig davon aufgerufen, ob Argumente erhalten bleiben. Wenn ein NULL-Wert übergeben wird, meldet ParseArgs() einen Fehler, wenn Argumente, die keine Optionen sind, vorhanden sind.
[in] ignoreUnknown
Bei „true“ werden unbekannte Optionen ignoriert.
Rückgabe
true, wenn alle Optionen und Nicht-Argumente erfolgreich geparst wurden; false, wenn eine Option nicht erkannt wurde, wenn eine der Handler-Funktionen fehlgeschlagen sind (z.B. False zurückgegeben wurde) oder ein interner Fehler aufgetreten ist.

Die Syntax der Eingabestrings ähnelt der Unix-Shell-Befehlssyntax, sie ist jedoch Teil eines vereinfachten Zitationsschemas. Insbesondere:

  • Argumente werden durch Leerzeichen getrennt, wenn sie nicht in Anführungszeichen gesetzt oder mit Escapezeichen versehen werden.
  • Ein umgekehrter Schrägstrich maskiert das folgende Zeichen, sodass es wie ein normales Zeichen behandelt wird. Der umgekehrte Schrägstrich wird entfernt.
  • Teilstrings in Form von einfachen oder doppelten Anführungszeichen beginnen oder beenden. Innerhalb eines Teilstrings sind die einzigen Sonderzeichen ein umgekehrter Schrägstrich, der ein Escapezeichen für das nächste Zeichen enthält, und ein entsprechendes Anführungszeichen. Anführungszeichen am Anfang und Ende werden entfernt.

z.B.:

--listen --count 10 --sw-version '1.0 (DEVELOPMENT)' "--hostname=nest.com"

ParsingArgsFromString

bool ParseArgsFromString(
  const char *progName,
  const char *argStr,
  OptionSet *optSets[],
  NonOptionArgHandlerFunct nonOptArgHandler
)

ParsingArgsFromString

bool ParseArgsFromString(
  const char *progName,
  const char *argStr,
  OptionSet *optSets[]
)

Booleschen Wert analysieren

bool ParseBoolean(
  const char *str,
  bool & output
)

String als booleschen Wert parsen

Diese Funktion akzeptiert die folgenden Eingabewerte (Groß-/Kleinschreibung wird nicht beachtet): "true", "yes "1 "false &falsch; &"n&"n&&t;n

Details
Parameter
[in] str
Ein Zeiger auf einen mit NULL beendeten C-String, der den zu parsenden Wert darstellt.
[out] output
Ein Verweis auf den Speicher für einen booleschen Wert, in dem der geparste Wert bei Erfolg gespeichert wird.
Rückgabe
True bei Erfolg, andernfalls False bei Fehler.

ParseFabricId

bool ParseFabricId(
  const char *str,
  uint64_t & fabricId,
  bool allowReserved
)

Parsen Sie eine Weave-Stoff-ID in Textform.

Die ParseFabricId()-Funktion akzeptiert eine 64-Bit-Stoff-ID im Hexadezimalformat mit oder ohne führendes '0x'.

Details
Parameter
[in] str
Ein Zeiger auf einen mit NULL beendeten C-String, der die zu parsende Textil-ID enthält.
[out] output
Ein Verweis auf einen uint64_t-Lvalue, in dem der geparste Wert bei Erfolg gespeichert wird.
[in] allowReserved
Wenn „true“, wird das Parsen der Fabric-IDs im reservierten Bereich erlaubt.
Rückgabe
„true“, wenn der Wert erfolgreich geparst wurde; „false“, wenn nicht.

ParseHexString

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

Parsen eines als Hexadezimalwert angegebenen Strings in Byte.

Für den ParseHexString()-Befehl wird davon ausgegangen, dass die Eingabe in Form von Hexadezimalzeichen (Groß- oder Kleinbuchstaben) erfolgt. Hexadezimalpaare können optional durch eines der folgenden Zeichen getrennt werden: Doppelpunkt, Semikolon, Komma, Punkt oder Bindestrich. Außerdem werden Leerzeichen im Eingabestring ignoriert.

Details
Parameter
[in] hexStr
Ein Mauszeiger auf den String, der geparst werden soll.
[in] strLen
Die Anzahl der Zeichen, die geparst werden sollen, in hexStr.
[in] outBuf
Ein Zeiger auf einen Puffer, in dem die Parsing-Byte gespeichert werden.
[in] outBufSize
Die Größe des Puffers, auf den outBuf verweist.
[out] outDataLen
Ein Verweis auf eine Ganzzahl, die die Gesamtzahl der geparsten Byte erhält. Für den Fall, dass outBuf nicht groß ist, um die angegebene Anzahl von Byte zu halten, wird outDataLen auf UINT32_MAX festgelegt.
Rückgabe
„true“, wenn der Wert erfolgreich geparst wurde; „false“, wenn die Eingabedaten fehlerhaft sind oder outBuf zu klein ist.

ParseIPAddress

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

IP-Adresse im Text parsen

Details
Parameter
[in] str
Ein Zeiger auf einen mit NULL beendeten C-String, der die zu parsende Adresse enthält.
[out] output
Ein Verweis auf ein IPAddress-Objekt, in dem der geparste Wert bei Erfolg gespeichert wird.
Rückgabe
„true“, wenn der Wert erfolgreich geparst wurde; „false“, wenn nicht.

ParseInt

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

Parsen und Umwandeln eines Strings in eine nicht signierte 64-Bit-Ganzzahl mit der entsprechenden Interpretation auf der Grundlage des Basisparameters

Details
Parameter
[in] str
Ein Zeiger auf einen mit NULL beendeten C-String, der die zu parsende Ganzzahl darstellt.
[out] output
Ein Verweis auf den Speicher für eine 64-Bit-Ganzzahl ohne Vorzeichen, in der der geparste Wert erfolgreich gespeichert wird.
[in] base
Die Basis, auf der der String interpretiert und geparst werden soll Wenn 0 oder 16 ist, kann der String hexadezimal sein und das Präfix &ot;0x" enthalten. Andernfalls wird eine 0 als 10 interpretiert, es sei denn, eine führende 0 wird gefunden, in der 8 impliziert ist.
Rückgabe
True bei Erfolg, andernfalls False bei Fehler.

ParseInt

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

Parsen und Konvertieren eines Strings in eine nicht signierte 32-Bit-Ganzzahl mit der entsprechenden Interpretation auf der Grundlage des Basisparameters

Details
Parameter
[in] str
Ein Zeiger auf einen mit NULL beendeten C-String, der die zu parsende Ganzzahl darstellt.
[out] output
Ein Verweis auf den Speicher für eine 32-Bit-Ganzzahl ohne Vorzeichen, in der der geparste Wert erfolgreich gespeichert wird.
[in] base
Die Basis, auf der der String interpretiert und geparst werden soll Wenn 0 oder 16 ist, kann der String hexadezimal sein und das Präfix &ot;0x" enthalten. Andernfalls wird eine 0 als 10 interpretiert, es sei denn, eine führende 0 wird gefunden, in der 8 impliziert ist.
Rückgabe
True bei Erfolg, andernfalls False bei Fehler.

ParseInt

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

Parsen und Konvertieren eines Strings in eine 32-Bit-Vorzeichen-Ganzzahl unter Anwendung der entsprechenden Interpretation auf der Grundlage des Basisparameters

Details
Parameter
[in] str
Ein Zeiger auf einen mit NULL beendeten C-String, der die zu parsende Ganzzahl darstellt.
[out] output
Ein Verweis auf den Speicher für eine vorzeichenbehaftete 32-Bit-Ganzzahl, in der der geparste Wert erfolgreich gespeichert wird.
[in] base
Die Basis, auf der der String interpretiert und geparst werden soll Wenn 0 oder 16 ist, kann der String hexadezimal sein und das Präfix &ot;0x" enthalten. Andernfalls wird eine 0 als 10 interpretiert, es sei denn, eine führende 0 wird gefunden, in der 8 impliziert ist.
Rückgabe
True bei Erfolg, andernfalls False bei Fehler.

ParseInt

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

Parsen eines als Dezimalwert interpretierten Strings in eine 64-Bit-Ganzzahl ohne Vorzeichen, wobei die passende Interpretation auf Grundlage des Basisparameters angewendet wird.

Details
Parameter
[in] str
Ein Zeiger auf einen mit NULL beendeten C-String, der die zu parsende Ganzzahl darstellt.
[out] output
Ein Verweis auf den Speicher für eine 64-Bit-Ganzzahl ohne Vorzeichen, in der der geparste Wert erfolgreich gespeichert wird.
Rückgabe
True bei Erfolg, andernfalls False bei Fehler.

ParseInt

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

Parsen eines als Dezimalwert interpretierten Strings in eine 32-Bit-Ganzzahl ohne Vorzeichen, wobei die passende Interpretation auf Grundlage des Basisparameters angewendet wird.

Details
Parameter
[in] str
Ein Zeiger auf einen mit NULL beendeten C-String, der die zu parsende Ganzzahl darstellt.
[out] output
Ein Verweis auf den Speicher für eine 32-Bit-Ganzzahl ohne Vorzeichen, in der der geparste Wert erfolgreich gespeichert wird.
Rückgabe
True bei Erfolg, andernfalls False bei Fehler.

ParseInt

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

String, der als Dezimalwert interpretiert wird, parsen und in eine vorzeichenbehaftete 32-Bit-Ganzzahl umwandeln, wobei die Interpretation auf Grundlage des Basisparameters angewendet wird

Details
Parameter
[in] str
Ein Zeiger auf einen mit NULL beendeten C-String, der die zu parsende Ganzzahl darstellt.
[out] output
Ein Verweis auf den Speicher für eine vorzeichenbehaftete 32-Bit-Ganzzahl, in der der geparste Wert erfolgreich gespeichert wird.
Rückgabe
True bei Erfolg, andernfalls False bei Fehler.

ParseInt

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

Parsen Sie einen als Dezimalwert interpretierten String in eine 16-Bit-Ganzzahl ohne Vorzeichen. Dabei wird die Interpretation auf Grundlage des Basisparameters angewendet.

Details
Parameter
[in] str
Ein Zeiger auf einen mit NULL beendeten C-String, der die zu parsende Ganzzahl darstellt.
[out] output
Ein Verweis auf den Speicher für eine 16-Bit-Ganzzahl ohne Vorzeichen, in der der geparste Wert erfolgreich gespeichert wird.
Rückgabe
True bei Erfolg, andernfalls False bei Fehler.

ParseInt

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

Parsen eines als Dezimalwert interpretierten Strings in eine 16-Bit-Ganzzahl mit Ganzzahl, wobei die passende Interpretation auf Grundlage des Basisparameters angewendet wird.

Details
Parameter
[in] str
Ein Zeiger auf einen mit NULL beendeten C-String, der die zu parsende Ganzzahl darstellt.
[out] output
Ein Verweis auf den Speicher für eine 16-Bit-Ganzzahl, bei der der geparste Wert erfolgreich gespeichert wird.
Rückgabe
True bei Erfolg, andernfalls False bei Fehler.

ParseInt

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

String, der als Dezimalwert ausgewertet wird, muss in eine 8-Bit-Ganzzahl ohne Vorzeichen konvertiert werden. Dabei wird die geeignete Interpretation auf Grundlage des Basisparameters angewendet.

Details
Parameter
[in] str
Ein Zeiger auf einen mit NULL beendeten C-String, der die zu parsende Ganzzahl darstellt.
[out] output
Ein Verweis auf den Speicher für eine 8-Bit-Ganzzahl ohne Vorzeichen, in der der geparste Wert erfolgreich gespeichert wird.
Rückgabe
True bei Erfolg, andernfalls False bei Fehler.

ParseNodeId

bool ParseNodeId(
  const char *str,
  uint64_t & nodeId
)

Parsen Sie eine Weave-Knoten-ID in Textform.

Die ParseNodeId()-Funktion akzeptiert entweder eine 64-Bit-Knoten-ID im Hexadezimalformat (mit oder ohne vorangestelltes '0x') und die Wörter 'any' oder 'all', die als beliebige Knoten-ID (0xFFFFFFFFFFFFFF) interpretiert werden.

Details
Parameter
[in] str
Ein Zeiger auf einen mit NULL beendeten C-String, der die zu analysierende Knoten-ID enthält.
[out] output
Ein Verweis auf einen uint64_t-Lvalue, in dem der geparste Wert bei Erfolg gespeichert wird.
Rückgabe
„true“, wenn der Wert erfolgreich geparst wurde; „false“, wenn nicht.

ParseSubnetzID

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

Parsen und Konvertieren eines Strings in eine 16-Bit-Subnetz-ID ohne Vorzeichen. Dabei wird der String als Hexadezimalwert interpretiert.

Details
Parameter
[in] str
Ein Zeiger auf einen mit NULL abgeschlossenen C-String, der die Subnetz-ID darstellt, die als Hexadezimal formatiert ist und zum Parsen verwendet werden soll.
[in,out] subnetId
Ein Verweis auf den Speicher für eine 16-Bit-Ganzzahl ohne Vorzeichen, in der der geparste Subnetz-ID-Wert erfolgreich gespeichert wird.
Rückgabe
True bei Erfolg, andernfalls False bei Fehler.

Hilfe zur Druckoption

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

Drucken Sie den Hilfetext für eine bestimmte Liste von Optionen zu einem Stream.

Details
Parameter
[in] optSets
Eine Liste mit Verweisen auf OptionSet-Strukturen, die den Hilfetext zum Drucken enthalten.
[in] s
Der FILE-Stream, in den der Hilfetext gedruckt werden soll.

PutStringWithLeereLine

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
)