nl::ArgParser

खास जानकारी

गिनती

OptionArgumentType enum
कमांड लाइन विकल्प के लिए आर्ग्युमेंट की ज़रूरी शर्तों के बारे में बताता है.

टाइपडेफ़

NonOptionArgHandlerFunct)(const char *progName, int argc, char *argv[]) टाइपडेफ़
bool(*
एक ऐसा फ़ंक्शन जिसे किसी भी बाकी, नॉन-विकल्प वाले कमांड लाइन आर्ग्युमेंट को मैनेज करने के लिए कहा जा सकता है.
OptionHandlerFunct)(const char *progName, OptionSet *optSet, int id, const char *name, const char *arg) टाइपडेफ़
bool(*
ऐसा फ़ंक्शन जिसे कमांड लाइन के विकल्पों के सेट को मैनेज करने के लिए कहा जा सकता है.

वैरिएबल

PrintArgError = DefaultPrintArgError)(const char *msg,...)
void(*
फ़ंक्शन को पॉइंट करने वाला टूल, जिसका इस्तेमाल तर्क पार्स करने के दौरान होने वाली गड़बड़ियों को प्रिंट करने के लिए किया जाता है.
gActiveOptionSets = NULL
OptionSets की सूची जिसे फ़िलहाल ParseArgs() कॉल में शामिल किया गया है.

फ़ंक्शन

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
आर्ग्युमेंट पार्सिंग से जुड़ा गड़बड़ी का मैसेज प्रिंट करें.
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
कमांड-लाइन स्टाइल वाले आर्ग्युमेंट के सेट को पार्स करें. हर विकल्प और विकल्प के आर्ग्युमेंट को प्रोसेस करने के लिए, हैंडलिंग फ़ंक्शन को कॉल करें.
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
नाम वाले एनवायरमेंट वैरिएबल से आर्ग्युमेंट का कोई सेट पार्स करें.
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
दी गई स्ट्रिंग से आर्ग्युमेंट का कोई सेट पार्स करें.
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
स्ट्रिंग को बूलियन वैल्यू के तौर पर पार्स करें.
ParseFabricId(const char *str, uint64_t & fabricId, bool allowReserved)
bool
टेक्स्ट के रूप में Weave कपड़े आईडी को पार्स करें.
ParseHexString(const char *hexStr, uint32_t strLen, uint8_t *outBuf, uint32_t outBufSize, uint32_t & outDataLen)
bool
हेक्स फ़ॉर्म में दी गई बाइट की स्ट्रिंग को पार्स करें.
ParseIPAddress(const char *str, IPAddress & output)
bool
किसी आईपी पते को टेक्स्ट फ़ॉर्म में पार्स करें.
ParseInt(const char *str, uint64_t & output, int base)
bool
पार्स करें और स्ट्रिंग को 64-बिट साइन न किए गए इंटिजर में बदलने की कोशिश करें. बेस पैरामीटर के आधार पर सही परिभाषा लागू करें.
ParseInt(const char *str, uint32_t & output, int base)
bool
पार्स करें और स्ट्रिंग को 32-बिट साइन न किए गए पूर्णांक में बदलने की कोशिश करें, जिसमें बेस पैरामीटर के आधार पर सही जानकारी दी जाए.
ParseInt(const char *str, int32_t & output, int base)
bool
पार्स करें और स्ट्रिंग के 32-बिट वाले इंटिजर में बदलने की कोशिश करें. बेस पैरामीटर के आधार पर सही परिभाषा लागू करें.
ParseInt(const char *str, uint64_t & output)
bool
बेस पैरामीटर के आधार पर सही व्याख्या लागू करते हुए, दशमलव मान के रूप में पहचानी गई स्ट्रिंग को 64-बिट इंटिजर में बदलें और पार्स करें.
ParseInt(const char *str, uint32_t & output)
bool
बेस पैरामीटर के आधार पर सही व्याख्या लागू करते हुए, दशमलव मान के रूप में पहचानी गई स्ट्रिंग को 32-बिट इंटिजर में बदलें और पार्स करें.
ParseInt(const char *str, int32_t & output)
bool
आधार पैरामीटर के आधार पर सही व्याख्या लागू करते हुए, दशमलव मान के रूप में पहचानी गई स्ट्रिंग को 32-बिट इंटिजर में बदलें और पार्स करें.
ParseInt(const char *str, uint16_t & output)
bool
बेस पैरामीटर के आधार पर सही व्याख्या लागू करते हुए, दशमलव मान के रूप में पहचानी गई स्ट्रिंग को 16-बिट इंटिजर में बदलें और पार्स करें.
ParseInt(const char *str, int16_t & output)
bool
पार्स करें और दशमलव मान के रूप में पहचानी गई स्ट्रिंग को 16-बिट इंटिजर में बदलें. बेस पैरामीटर के आधार पर सही व्याख्या लागू करें.
ParseInt(const char *str, uint8_t & output)
bool
पार्स करें और दशमलव मान के रूप में पहचानी गई स्ट्रिंग को 8-बिट इंटिजर में बदलें. बेस पैरामीटर के आधार पर सही व्याख्या लागू करें.
ParseNodeId(const char *str, uint64_t & nodeId)
bool
टेक्स्ट फ़ॉर्म में Weave नोड आईडी पार्स करें.
ParseSubnetId(const char *str, uint16_t & subnetId)
bool
पार्स की गई स्ट्रिंग को 16-बिट सबनेट आईडी में बदलने की कोशिश करें.
PrintOptionHelp(OptionSet *optSets[], FILE *s)
void
स्ट्रीम के विकल्पों की खास सूची के लिए सहायता टेक्स्ट प्रिंट करें.
PutStringWithBlankLine(FILE *s, const char *str)
void
PutStringWithNewLine(FILE *s, const char *str)
void
SplitArgs(char *argStr, char **& argList, char *initialArg)
int32_t

क्लास

nl::ArgParser::HelpOptions

जानकारी के विकल्पों (सहायता, वर्शन) को मैनेज करने के लिए आम OptionSet.

nl::ArgParser::OptionSetBase

एक OptionSet जहां हैंडलर एक वर्चुअल फ़ंक्शन है.

स्ट्रक्चर

nl::ArgParser::OptionDef

कमांड लाइन का विकल्प बताता है.

nl::ArgParser::OptionSet

तार्किक रूप से जुड़े और फिर से इस्तेमाल किए जा सकने वाले कमांड लाइन विकल्पों के ग्रुप के बारे में बताता है.

गिनती

विकल्प का प्रकार

 OptionArgumentType

कमांड लाइन विकल्प के लिए आर्ग्युमेंट की ज़रूरी शर्तों के बारे में बताता है.

टाइपडेफ़

गैर-विकल्पArgHandlerFunct

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

एक ऐसा फ़ंक्शन जिसे किसी भी बाकी, नॉन-विकल्प वाले कमांड लाइन आर्ग्युमेंट को मैनेज करने के लिए कहा जा सकता है.

OptionHandlerFunct

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

ऐसा फ़ंक्शन जिसे कमांड लाइन के विकल्पों के सेट को मैनेज करने के लिए कहा जा सकता है.

वैरिएबल

PrintArgगड़बड़ी

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

फ़ंक्शन को पॉइंट करने वाला टूल, जिसका इस्तेमाल तर्क पार्स करने के दौरान होने वाली गड़बड़ियों को प्रिंट करने के लिए किया जाता है.

ऐप्लिकेशन को सीधे stdout/stderr पर प्रिंट करने के बजाय, PrintArgError() को अपने विकल्प और गैर-विकल्प वाले आर्ग्युमेंट हैंडलिंग फ़ंक्शन में गड़बड़ियों की रिपोर्ट करने के लिए कॉल करना चाहिए.

DefaultPrintArgError() फ़ंक्शन के लिए डिफ़ॉल्ट पॉइंटर.

gActiveOptionSets

OptionSet ** gActiveOptionSets = NULL

OptionSets की सूची जिसे फ़िलहाल ParseArgs() कॉल में शामिल किया गया है.

जब ParseArgs() को कॉल नहीं किया जाता, तो यह वैल्यू शून्य होगी.

फ़ंक्शन

CountAllOptions

size_t CountAllOptions(
  OptionSet *optSets[]
)

CountAllOptions

size_t CountAllOptions(
  OptionSet **optSets
)

CountOptionSets

size_t CountOptionSets(
  OptionSet *optSets[]
)

CountOptionSets

size_t CountOptionSets(
  OptionSet **optSets
)

डिफ़ॉल्ट PrintArgगड़बड़ी

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

आर्ग्युमेंट पार्सिंग से जुड़ा गड़बड़ी का मैसेज प्रिंट करें.

डिफ़ॉल्ट फ़ंक्शन का इस्तेमाल, आर्ग्युमेंट को पार्स करने की वजह से होने वाले गड़बड़ी के मैसेज को प्रिंट करने के लिए किया जाता है.

ब्यौरा
पैरामीटर
[in] msg
प्रिंट किया जाने वाला मैसेज.

ऐप्लिकेशन को सीधे इस फ़ंक्शन को कॉल करने के बजाय, PrintArgError फ़ंक्शन पॉइंटर के ज़रिए कॉल करना चाहिए.

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
)

Makeचुनेंविकल्प

struct option * MakeLongOptions(
  OptionSet **optSets
)

MakeShortOptions

char * MakeShortOptions(
  OptionSet **optSets
)

MakeयूनीकHelpGroupNamesList

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

पार्सी आर्ग्स

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

कमांड-लाइन स्टाइल वाले आर्ग्युमेंट के सेट को पार्स करें. हर विकल्प और विकल्प के आर्ग्युमेंट को प्रोसेस करने के लिए, हैंडलिंग फ़ंक्शन को कॉल करें.

ParseArgs(), आर्ग्युमेंट की सूची और argv को सप्लाई किए गए विकल्प की परिभाषाओं के सेट के मुताबिक पार्स करता है. फ़ंक्शन, लंबे (ऑप्ट) और छोटे (-o) विकल्पों के साथ काम करता है. साथ ही, यह GNU getopt_long(3) फ़ंक्शन के समान विकल्प सिंटैक्स लागू करता है.

ब्यौरा
पैरामीटर
[in] progName
उस प्रोग्राम या कॉन्टेक्स्ट का नाम जिसमें आर्ग्युमेंट पार्स किए जा रहे हैं. इस स्ट्रिंग का इस्तेमाल गड़बड़ी के मैसेज और चेतावनियों से पहले किया जाएगा.
[in] argc
पार्स किए जाने वाले तर्कों की संख्या, साथ ही 1.
[in] argv
पार्स की जाने वाली आर्ग्युमेंट स्ट्रिंग की श्रेणी. श्रेणी की लंबाई argc के लिए बताई गई वैल्यू से एक ज़्यादा होनी चाहिए और argv[argc] को NULL पर सेट कर दिया जाना चाहिए. आर्ग्युमेंट पार्सिंग दूसरा अरे एलिमेंट (argv[1]) से शुरू होता है; एलिमेंट 0 को अनदेखा किया जाता है.
[in] optSets
OptionSet स्ट्रक्चर के लिए पॉइंटर की सूची, जो कानूनी विकल्पों के बारे में बताती हैं. दी गई सूची का शून्य से खत्म होना ज़रूरी है.
[in] nonOptArgHandler
किसी फ़ंक्शन का सूचक, जिसे विकल्प पार्स करने के बाद किसी भी बचे हुए विकल्प के आर्ग्युमेंट के साथ कॉल किया जाएगा . फ़ंक्शन को कॉल किया जाता है, भले ही कोई भी आर्ग्युमेंट बना रहे. अगर कोई NULL पास किया जाता है, तो कोई भी विकल्प नहीं होने पर कोई ParseArgs() गड़बड़ी की रिपोर्ट करेगा.
[in] ignoreUnknown
अगर सही है, तो बिना आवाज़ के किसी भी विकल्प को अनदेखा करें.
लौटाए गए सामान
अगर true सभी विकल्प और बिना विकल्प वाले आर्ग्युमेंट पार्स किए गए थे, तो false अगर किसी विकल्प को पहचाना नहीं जा सका या किसी एक हैंडलर फ़ंक्शन ने काम करना बंद कर दिया (यानी, 'false' दिखाया गया).

विकल्प की परिभाषाओं को OptionSet स्ट्रक्चर (optSets) के अरे के रूप में ParseArgs() को पास किया जाता है. हर OptionSet में विकल्प की परिभाषाएं और हैंडलर फ़ंक्शन होता है. ParseArgs() किसी खास विकल्प के लिए आर्ग्युमेंट के आर्ग्युमेंट को प्रोसेस करती है. साथ ही, हर मान्य विकल्प के लिए हैंडलर हैंडलर को कॉल किया जाता है. सभी विकल्पों को पार्स करने के बाद, किसी भी बचे हुए आर्ग्युमेंट को प्रोसेस करने के लिए, नॉन-विकल्प हैंडलर (nonOptArgHandler) के अलग-अलग फ़ंक्शन को एक बार कॉल किया जाता है.

विकल्प के सेट

OptionSet में किसी हैंडलर फ़ंक्शन के लिए पॉइंटर के साथ विकल्प की परिभाषाओं का एक सेट होता है. कॉल करने पर, उससे जुड़े किसी विकल्प के मिलने पर इसे कॉल किया जाता है. विकल्प सेट में सहायता के लिए, हर विकल्प के सिंटैक्स और मकसद की जानकारी देने वाला टेक्स्ट भी शामिल होता है (नीचे विकल्प चुनने में मदद करें). विकल्प सेट इस तरह डिज़ाइन किए गए हैं कि वे मिलते-जुलते विकल्पों के दोबारा इस्तेमाल किए जा सकने वाले कलेक्शन बनाने में मदद कर सकें. यह एक से ज़्यादा ऐप्लिकेशन को बनाए रखने के लिए ज़रूरी कोशिश को आसान बनाता है, जो मिलते-जुलते विकल्पों को स्वीकार करते हैं (जैसे, टेस्ट ऐप्लिकेशन).

OptionSetsone तय करने के दो पैटर्न हैं, जो OptionSet स्ट्रक्चर के इंस्टेंस को शुरू कर सकते हैं. उदाहरण के लिए, एक स्टैटिक ग्लोबल या सब-क्लास OptionSetBase के तौर पर और एक कंस्ट्रक्टर उपलब्ध करा सकता है. बाद वाले विकल्प में सब-क्लास को मैनेज करने के लिए, शुद्ध वर्चुअल HandleOption() फ़ंक्शन का इस्तेमाल किया जाता है.

OptionSets की सूचियां, ParseArgs() फ़ंक्शन को पॉइंटर की NULL-टर्मिनेटेड रेंज के तौर पर पास करती हैं. उदाहरण:

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

विकल्प की परिभाषाएं

विकल्पों को OptionDef स्ट्रक्चर का इस्तेमाल करके तय किया जाता है. विकल्प की परिभाषाओं को OptionDef एलिमेंट की श्रेणी के तौर पर व्यवस्थित किया जाता है, जहां हर एलिमेंट में शामिल होता है: विकल्प का नाम, एक इंटेजर आईडी जिसका इस्तेमाल विकल्प की पहचान करने के लिए किया जाता है, और क्या विकल्प किसी तर्क की उम्मीद करता है/अनुमति देता है. विकल्प श्रेणी के आखिर में NULL Name फ़ील्ड है. उदाहरण:

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

विकल्प आईडी

Option आईडी, उस कोड के विकल्पों की पहचान करते हैं जो उन्हें मैनेज करता है (OptionHandler फ़ंक्शन). विकल्प आईडी, उन OptionSet के आधार पर होते हैं जिनमें ये दिखते हैं. इनका अलग-अलग OptionSet में फिर से इस्तेमाल किया जा सकता है. हालांकि, नीचे दिए गए विकल्प देखें. आम तौर पर, 1,000 पर नंबर देने के विकल्प आईडी को शुरू किया जाता है. हालांकि, किसी भी संख्या में &g2 का इस्तेमाल किया जा सकता है. उपनाम विकल्प अलग-अलग विकल्प नामों के साथ एक ही विकल्प आईडी का इस्तेमाल करके बनाए जा सकते हैं.

शॉर्ट विकल्प

getopt_long(3) के उलट, ParseArgs() छोटे विकल्प वाले वर्णों की सूची के लिए, अलग से स्ट्रिंग नहीं लेती है. इसके बजाय, ऐसा आईडी विकल्प जिसके आईडी का मान ग्राफ़िकल ASCII वर्णों की श्रेणी में आता है, उस वर्ण को एक छोटे विकल्प के रूप में इस्तेमाल करने की अनुमति मिलेगी.

ParseArgs() के लिए यह ज़रूरी है कि सभी OptionSets में छोटे विकल्प वाले वर्ण यूनीक हों. इस वजह से, कई विकल्पों के लिए छोटे विकल्पों के इस्तेमाल की सलाह नहीं दी जाती. उपनाम विकल्पों के लंबे नाम बनाने के लिए, छोटे विकल्पों के वर्णों को एक OptionSet में फिर से इस्तेमाल किया जा सकता है.

विकल्प सहायता

हर OptionSet में एक OptionHelp स्ट्रिंग होती है, जो असोसिएट विकल्पों के मकसद और सिंटैक्स के बारे में बताती है. PrintOptionHelp() स्ट्रिंग इन विकल्पों का इस्तेमाल, इस्तेमाल के बारे में जानकारी जनरेट करने के लिए करती है.

विकल्प के तौर पर, विकल्प सहायता स्ट्रिंग में सिंटैक्स का एक उदाहरण होता है. इसके बाद विकल्प के बारे में टेक्स्ट के तौर पर दी गई जानकारी होती है. अगर विकल्प का कोई छोटा वर्शन या कोई उपनाम है, तो उसे मुख्य लंबे नाम से पहले दिया जाता है. एक जैसा बनाने के लिए, सिंटैक्स लाइनों को दो स्पेस से इंडेंट किया जाता है, जबकि ब्यौरे की लाइनों को सात स्पेस से इंडेंट किया जाता है. एक खाली लाइन के लिए हर विकल्प के ब्यौरे के साथ-साथ आखिरी लाइन भी शामिल होती है.

उदाहरण:

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

विकल्प के तौर पर दिए गए सहायता ग्रुप

विकल्प सेट में एक HelpGroupName स्ट्रिंग होती है. इसका इस्तेमाल सहायता आउटपुट में विकल्पों को एक साथ ग्रुप करने के लिए किया जाता है. PrintOptionHelp() फ़ंक्शन, जनरेट किए गए इस्तेमाल के आउटपुट में सेक्शन के शीर्षक के तौर पर HelpGroupName का इस्तेमाल करता है. अगर एक से ज़्यादा OptionSets का एक हीHelpGroupName एक ही है, तो PrintOptionHelp() अलग-अलग OptionSets के लिए विकल्प सहायता को एक ही सेक्शन के शीर्षक में प्रिंट करेगा.

पार्सी आर्ग्स

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

पार्सी आर्ग्स

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
)

नाम वाले एनवायरमेंट वैरिएबल से आर्ग्युमेंट का कोई सेट पार्स करें.

ParseArgsFromEnvVar() नाम वाले एनवायरमेंट वैरिएबल को पढ़ता है और पार्स करने के लिए वैल्यू को ParseArgsFromString() में पास कर देता है. अगर एनवायरमेंट वैरिएबल सेट नहीं है, तो फ़ंक्शन कुछ नहीं करता है.

ब्यौरा
पैरामीटर
[in] progName
उस प्रोग्राम या कॉन्टेक्स्ट का नाम जिसमें आर्ग्युमेंट पार्स किए जा रहे हैं. इस स्ट्रिंग का इस्तेमाल गड़बड़ी के मैसेज और चेतावनियों से पहले किया जाएगा.
[in] varName
एनवायरमेंट वैरिएबल का नाम.
[in] optSets
OptionSet स्ट्रक्चर के लिए पॉइंटर की सूची, जो कानूनी विकल्पों के बारे में बताती हैं. दी गई सूची का शून्य से खत्म होना ज़रूरी है.
[in] nonOptArgHandler
किसी फ़ंक्शन का सूचक, जिसे विकल्प पार्स करने के बाद किसी भी बचे हुए विकल्प के आर्ग्युमेंट के साथ कॉल किया जाएगा . फ़ंक्शन को कॉल किया जाता है, भले ही कोई भी आर्ग्युमेंट बना रहे. अगर कोई NULL पास किया जाता है, तो कोई भी विकल्प नहीं होने पर कोई ParseArgs() गड़बड़ी की रिपोर्ट करेगा.
[in] ignoreUnknown
अगर सही है, तो बिना आवाज़ के किसी भी विकल्प को अनदेखा करें.
लौटाए गए सामान
अगर true सभी विकल्प और बिना विकल्प वाले आर्ग्युमेंट सही तरीके से पार्स किए गए थे या कोई तय एनवायरमेंट वैरिएबल सेट नहीं है, तो false अगर किसी विकल्प की पहचान नहीं हो पाती थी, तो कोई एक हैंडलर फ़ंक्शन फ़ेल हो गया था (जैसे, गलत मिला था). इसके अलावा, यह भी हो सकता है कि कोई अंदरूनी गड़बड़ी हुई हो.

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
)

दी गई स्ट्रिंग से आर्ग्युमेंट का कोई सेट पार्स करें.

ParseArgsFromString(), दिए गए स्ट्रिंग (argStr) को आर्ग्युमेंट के सेट में बांट देता है. साथ ही, ParseArgs() फ़ंक्शन का इस्तेमाल करके, आर्ग्युमेंट को पार्स करता है.

ब्यौरा
पैरामीटर
[in] progName
उस प्रोग्राम या कॉन्टेक्स्ट का नाम जिसमें आर्ग्युमेंट पार्स किए जा रहे हैं. इस स्ट्रिंग का इस्तेमाल गड़बड़ी के मैसेज और चेतावनियों से पहले किया जाएगा.
[in] argStr
पार्स की जाने वाली विकल्पों और तर्कों वाली एक स्ट्रिंग.
[in] optSets
OptionSet स्ट्रक्चर के लिए पॉइंटर की सूची, जो कानूनी विकल्पों के बारे में बताती हैं. दी गई सूची का शून्य से खत्म होना ज़रूरी है.
[in] nonOptArgHandler
किसी फ़ंक्शन का सूचक, जिसे विकल्प पार्स करने के बाद किसी भी बचे हुए विकल्प के आर्ग्युमेंट के साथ कॉल किया जाएगा . फ़ंक्शन को कॉल किया जाता है, भले ही कोई भी आर्ग्युमेंट बना रहे. अगर कोई NULL पास किया जाता है, तो कोई भी विकल्प नहीं होने पर कोई ParseArgs() गड़बड़ी की रिपोर्ट करेगा.
[in] ignoreUnknown
अगर सही है, तो बिना आवाज़ के किसी भी विकल्प को अनदेखा करें.
लौटाए गए सामान
true अगर सभी विकल्प और बिना विकल्प वाले आर्ग्युमेंट सही तरीके से पार्स किए गए हों, तो false का इस्तेमाल करें. अगर किसी विकल्प की पहचान नहीं हो पाई, तो कोई हैंडलर गलत काम कर रहा था (जैसे, कोई गड़बड़ी होने पर) या कोई अंदरूनी गड़बड़ी हुई.

इनपुट स्ट्रिंग का सिंटैक्स, यूनिक्स शेल कमांड के सिंटैक्स से मिलता-जुलता है. हालांकि, इसमें कोटेशन की आसान स्कीम शामिल है. खास तौर पर:

  • तर्कों को खाली सफ़ेद जगह से तब तक डीलिमिटेड किया जाता है, जब तक कि खाली सफ़ेद जगह को कोट या एस्केप न किया गया हो.
  • बैकस्लैश नीचे दिए गए वर्ण को एस्केप करता है, जिससे इसे सामान्य वर्ण माना जाता है. बैकस्लैश को अलग किया गया.
  • सिंगल कोट या डबल कोट, कोट की गई सबस्ट्रिंग शुरू/खत्म करते हैं. सबस्ट्रिंग में, सिर्फ़ विशेष वर्ण ही बैकस्लैश होते हैं जो अगले वर्ण और उससे जुड़े कोट को एस्केप करते हैं. कोटेशन को शुरुआती/खत्म करने के लिए इस्तेमाल नहीं किया जाता.

उदाहरण:

--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[]
)

पार्सबूलियन

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

स्ट्रिंग को बूलियन वैल्यू के तौर पर पार्स करें.

;

ब्यौरा
पैरामीटर
[in] str
NULL-टर्मिनेटेड C स्ट्रिंग का पॉइंटर, जो पार्स करने के मान को दिखाता है.
[out] output
बूल के लिए स्टोरेज का रेफ़रंस, जिस पर पार्स किया गया मान सफलता पर स्टोर किया जाएगा.
लौटाए गए सामान
अगर यह सही है, तो यह सही नहीं है.

पार्स्सफ़ैब्रिक आईडी

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

टेक्स्ट के रूप में Weave कपड़े आईडी को पार्स करें.

ParseFabricId() फ़ंक्शन, हेक्स फ़ॉर्मैट में दिया गया 64-बिट का कपड़े का आईडी स्वीकार करता है. इसके लिए, शुरू में '0x' के साथ लगाना ज़रूरी है.

ब्यौरा
पैरामीटर
[in] str
NULL-टर्मिनेटेड C स्ट्रिंग का पॉइंटर, जिसमें पार्स करने के लिए फ़ैब्रिक आईडी है.
[out] output
uint64_t lvalue का रेफ़रंस, जिसमें पार्स की गई वैल्यू सही तरीके से सेव होगी.
[in] allowReserved
सही होने पर, रिज़र्व की गई रेंज में फ़ैब्रिक आईडी पार्स करने की अनुमति दें.
लौटाए गए सामान
अगर वैल्यू सही तरीके से पार्स हो गई थी, तो 'सही'; अगर नहीं है, तो 'गलत' है.

पार्स्सहेक्सस्ट्रिंग

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

हेक्स फ़ॉर्म में दी गई बाइट की स्ट्रिंग को पार्स करें.

ParseHexString() इनपुट को हेक्स अंकों (अपर या लोअर केस) के जोड़े के रूप में होना चाहिए. हेक्स जोड़े को इनमें से किसी भी वर्ण से अलग-अलग किया जा सकता है: कोलन, सेमीकॉलन, कॉमा, पीरियड या डैश. इसके अलावा, इनपुट स्ट्रिंग में कहीं भी खाली सफ़ेद जगह वाले वर्णों को अनदेखा कर दिया जाता है.

ब्यौरा
पैरामीटर
[in] hexStr
पार्स करने के लिए स्ट्रिंग का पॉइंटर.
[in] strLen
पार्स करने के लिए हेक्स हेक्स में वर्ण की संख्या.
[in] outBuf
बफ़र के लिए एक पॉइंटर जिसमें पार्स बाइट स्टोर किए जाएंगे.
[in] outBufSize
बफ़र का साइज़ outBuf से बताया गया है.
[out] outDataLen
उस पूर्णांक का रेफ़रंस जिसे पार्स किए गए बाइट की कुल संख्या मिलेगी. इवेंट आउटBuf में बाइट की दी गई संख्या को रोकने के लिए काफ़ी बड़ा नहीं है, outDataLen को UINT32_MAX पर सेट किया जाएगा.
लौटाए गए सामान
अगर वैल्यू सही तरीके से पार्स हो गई थी, तो सही है; अगर इनपुट डेटा गलत है, तो गलत है या अगर outBuf बहुत छोटा है.

ParseIPAddress

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

किसी आईपी पते को टेक्स्ट फ़ॉर्म में पार्स करें.

ब्यौरा
पैरामीटर
[in] str
NULL-टर्मिनेटेड C स्ट्रिंग का पॉइंटर, जिसमें पार्स करने का पता है.
[out] output
किसी ऐसे IPAddress ऑब्जेक्ट का संदर्भ जिसमें पार्स किया गया मान सफलता पर संग्रहित किया जाएगा.
लौटाए गए सामान
अगर वैल्यू सही तरीके से पार्स हो गई थी, तो 'सही'; अगर नहीं है, तो 'गलत' है.

पार्सिट

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

पार्स करें और स्ट्रिंग को 64-बिट साइन न किए गए इंटिजर में बदलने की कोशिश करें. बेस पैरामीटर के आधार पर सही परिभाषा लागू करें.

ब्यौरा
पैरामीटर
[in] str
पार्स करने के लिए इंटीजर दिखाने वाला NULL-टर्मिनेटेड C स्ट्रिंग का पॉइंटर.
[out] output
बिना साइन वाले उस 64-बिट इंटिजर के लिए स्टोरेज का रेफ़रंस जिसमें पार्स किया गया मान सेव होने के बाद सेव होगा.
[in] base
वह आधार जिसके मुताबिक स्ट्रिंग को समझना और पार्स करना ज़रूरी है. अगर 0 या 16 है, तो स्ट्रिंग हेक्ज़ाडेसिमल हो सकती है और इसकी शुरुआत में &kot;0x&kot; हो सकता है. ऐसा न करने पर, 0 को 10 के रूप में माना जाता है और 0 को तब तक नहीं दिखाया जाता, जब तक कि इसकी शुरुआत 0 न हो.
लौटाए गए सामान
अगर यह सही है, तो यह सही नहीं है.

पार्सिट

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

पार्स करें और स्ट्रिंग को 32-बिट साइन न किए गए पूर्णांक में बदलने की कोशिश करें, जिसमें बेस पैरामीटर के आधार पर सही जानकारी दी जाए.

ब्यौरा
पैरामीटर
[in] str
पार्स करने के लिए इंटीजर दिखाने वाला NULL-टर्मिनेटेड C स्ट्रिंग का पॉइंटर.
[out] output
बिना इंटेजर वाले 32-बिट इंटिजर के लिए स्टोरेज का रेफ़रंस, जिसे पार्स किया जाने पर वह वैल्यू सेव हो जाएगी.
[in] base
वह आधार जिसके मुताबिक स्ट्रिंग को समझना और पार्स करना ज़रूरी है. अगर 0 या 16 है, तो स्ट्रिंग हेक्ज़ाडेसिमल हो सकती है और इसकी शुरुआत में &kot;0x&kot; हो सकता है. ऐसा न करने पर, 0 को 10 के रूप में माना जाता है और 0 को तब तक नहीं दिखाया जाता, जब तक कि इसकी शुरुआत 0 न हो.
लौटाए गए सामान
अगर यह सही है, तो यह सही नहीं है.

पार्सिट

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

पार्स करें और स्ट्रिंग के 32-बिट वाले इंटिजर में बदलने की कोशिश करें. बेस पैरामीटर के आधार पर सही परिभाषा लागू करें.

ब्यौरा
पैरामीटर
[in] str
पार्स करने के लिए इंटीजर दिखाने वाला NULL-टर्मिनेटेड C स्ट्रिंग का पॉइंटर.
[out] output
पॉज़िटिव/नेगेटिव रेंज वाले 32-बिट इंटिजर के लिए, स्टोरेज का रेफ़रंस. इसके बाद, पार्स होने वाली वैल्यू को सेव कर लिया जाएगा.
[in] base
वह आधार जिसके मुताबिक स्ट्रिंग को समझना और पार्स करना ज़रूरी है. अगर 0 या 16 है, तो स्ट्रिंग हेक्ज़ाडेसिमल हो सकती है और इसकी शुरुआत में &kot;0x&kot; हो सकता है. ऐसा न करने पर, 0 को 10 के रूप में माना जाता है और 0 को तब तक नहीं दिखाया जाता, जब तक कि इसकी शुरुआत 0 न हो.
लौटाए गए सामान
अगर यह सही है, तो यह सही नहीं है.

पार्सिट

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

बेस पैरामीटर के आधार पर सही व्याख्या लागू करते हुए, दशमलव मान के रूप में पहचानी गई स्ट्रिंग को 64-बिट इंटिजर में बदलें और पार्स करें.

ब्यौरा
पैरामीटर
[in] str
पार्स करने के लिए इंटीजर दिखाने वाला NULL-टर्मिनेटेड C स्ट्रिंग का पॉइंटर.
[out] output
बिना साइन वाले उस 64-बिट इंटिजर के लिए स्टोरेज का रेफ़रंस जिसमें पार्स किया गया मान सेव होने के बाद सेव होगा.
लौटाए गए सामान
अगर यह सही है, तो यह सही नहीं है.

पार्सिट

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

बेस पैरामीटर के आधार पर सही व्याख्या लागू करते हुए, दशमलव मान के रूप में पहचानी गई स्ट्रिंग को 32-बिट इंटिजर में बदलें और पार्स करें.

ब्यौरा
पैरामीटर
[in] str
पार्स करने के लिए इंटीजर दिखाने वाला NULL-टर्मिनेटेड C स्ट्रिंग का पॉइंटर.
[out] output
बिना इंटेजर वाले 32-बिट इंटिजर के लिए स्टोरेज का रेफ़रंस, जिसे पार्स किया जाने पर वह वैल्यू सेव हो जाएगी.
लौटाए गए सामान
अगर यह सही है, तो यह सही नहीं है.

पार्सिट

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

आधार पैरामीटर के आधार पर सही व्याख्या लागू करते हुए, दशमलव मान के रूप में पहचानी गई स्ट्रिंग को 32-बिट इंटिजर में बदलें और पार्स करें.

ब्यौरा
पैरामीटर
[in] str
पार्स करने के लिए इंटीजर दिखाने वाला NULL-टर्मिनेटेड C स्ट्रिंग का पॉइंटर.
[out] output
पॉज़िटिव/नेगेटिव रेंज वाले 32-बिट इंटिजर के लिए, स्टोरेज का रेफ़रंस. इसके बाद, पार्स होने वाली वैल्यू को सेव कर लिया जाएगा.
लौटाए गए सामान
अगर यह सही है, तो यह सही नहीं है.

पार्सिट

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

बेस पैरामीटर के आधार पर सही व्याख्या लागू करते हुए, दशमलव मान के रूप में पहचानी गई स्ट्रिंग को 16-बिट इंटिजर में बदलें और पार्स करें.

ब्यौरा
पैरामीटर
[in] str
पार्स करने के लिए इंटीजर दिखाने वाला NULL-टर्मिनेटेड C स्ट्रिंग का पॉइंटर.
[out] output
स्टोरेज के तौर पर, 16-बिट के ऐसे इंटिजर के बारे में जानकारी दी जाती है जिसमें साइन न किया गया इंटेजर, सक्सेस होने पर सेव होगा.
लौटाए गए सामान
अगर यह सही है, तो यह सही नहीं है.

पार्सिट

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

पार्स करें और दशमलव मान के रूप में पहचानी गई स्ट्रिंग को 16-बिट इंटिजर में बदलें. बेस पैरामीटर के आधार पर सही व्याख्या लागू करें.

ब्यौरा
पैरामीटर
[in] str
पार्स करने के लिए इंटीजर दिखाने वाला NULL-टर्मिनेटेड C स्ट्रिंग का पॉइंटर.
[out] output
16-बिट के लिए साइन किए गए इंटेजर के लिए स्टोरेज की जानकारी, जिसे पार्स होने के बाद पार्स किया गया मान सेव होगा.
लौटाए गए सामान
अगर यह सही है, तो यह सही नहीं है.

पार्सिट

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

पार्स करें और दशमलव मान के रूप में पहचानी गई स्ट्रिंग को 8-बिट इंटिजर में बदलें. बेस पैरामीटर के आधार पर सही व्याख्या लागू करें.

ब्यौरा
पैरामीटर
[in] str
पार्स करने के लिए इंटीजर दिखाने वाला NULL-टर्मिनेटेड C स्ट्रिंग का पॉइंटर.
[out] output
सही न होने पर 8-बिट इंटिजर के लिए स्टोरेज की जानकारी, जिसे पार्स किया गया है.
लौटाए गए सामान
अगर यह सही है, तो यह सही नहीं है.

पार्स नोड

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

टेक्स्ट फ़ॉर्म में Weave नोड आईडी पार्स करें.

ParseNodeId() में या तो लीडिंग ##39;0x' के साथ या उसके बिना एक 64-बिट नोड आईडी स्वीकार की जाती है. साथ ही, इसमें 'any' या 'all' भी शामिल होते हैं, जिन्हें किसी भी नोड आईडी (0xFFFFFFFFFF) से समझा जाता है.

ब्यौरा
पैरामीटर
[in] str
पार्स करने के लिए नोड आईडी वाले NULL-टर्मिनेटेड C स्ट्रिंग का पॉइंटर.
[out] output
uint64_t lvalue का रेफ़रंस, जिसमें पार्स की गई वैल्यू सही तरीके से सेव होगी.
लौटाए गए सामान
अगर वैल्यू सही तरीके से पार्स हो गई थी, तो 'सही'; अगर नहीं है, तो 'गलत' है.

ParseSubnetId

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

पार्स की गई स्ट्रिंग को 16-बिट सबनेट आईडी में बदलने की कोशिश करें.

ब्यौरा
पैरामीटर
[in] str
पार्स करने के लिए, NULL-टर्मिनेटेड C स्ट्रिंग का पॉइंटर, जो सबनेट आईडी, हेक्साडेसिमल के तौर पर फ़ॉर्मैट किया गया है.
[in,out] subnetId
स्टोरेज के लिए रेफ़रंस, जो 16-बिट के ऐसे इंटिजर के तौर पर सेव किया जाता है जो पार्स नहीं हुआ है. सफल होने पर, पार्स किया गया सबनेट आईडी की वैल्यू सेव हो जाएगी.
लौटाए गए सामान
अगर यह सही है, तो यह सही नहीं है.

प्रिंट विकल्प सहायता

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

स्ट्रीम के विकल्पों की खास सूची के लिए सहायता टेक्स्ट प्रिंट करें.

ब्यौरा
पैरामीटर
[in] optSets
OptionSet स्ट्रक्चर के लिए पॉइंटर की सूची, जिसमें प्रिंट करने के लिए सहायता टेक्स्ट है.
[in] s
FILE स्ट्रीम जिस पर सहायता टेक्स्ट प्रिंट किया जाना चाहिए.

PuStringWithब्लैंकलाइन

void PutStringWithBlankLine(
  FILE *s,
  const char *str
)

PuStringWithNewLine

void PutStringWithNewLine(
  FILE *s,
  const char *str
)

स्प्लिट-आर्ग्स

int32_t SplitArgs(
  char *argStr,
  char **& argList,
  char *initialArg
)