इस पेज का अनुवाद Cloud Translation API से किया गया है.

nl::Weave::System::PacketBuffer

#include <src/system/SystemPacketBuffer.h>

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

खास जानकारी

LwIP पर आधारित एनवायरमेंट में, इस क्लास को उस लाइब्रेरी में तय किए गए pbuf स्ट्रक्चर पर बनाया जाता है. LwIP के न होने पर, Weave मैलक-आधारित या पूल-आधारित लागू करने की सुविधा देता है, जो बहुत ज़्यादा एम्बेड किए गए डिवाइसों की मेमोरी से जुड़ी चुनौतियों का करीब से अनुमान लगाता है.

लेयर वाले नेटवर्क स्टैक में इस्तेमाल होने वाले मिलते-जुलते स्ट्रक्चर की तरह, PacketBuffer क्लास, कॉन्फ़िगर किए जा सकने वाले कम्यूनिकेशन स्टैक की हर लेयर पर, प्रोटोकॉल हेडर के लिए जगह बुक करने का तरीका उपलब्ध कराती है. ज़्यादा जानकारी के लिए, PacketBuffer::New() और LwIP दस्तावेज़ देखें.

PacketBuffer ऑब्जेक्ट को रेफ़रंस के तौर पर गिना जाता है और Weave में "फ़ायर-ऐंड-फ़ॉर्ज" इस्तेमाल करने का मौजूदा मोड इस्तेमाल होता है. पैकेट (और इसके मौजूदा PacketBuffer ऑब्जेक्ट) को अलग-अलग प्रोटोकॉल लेयर की मदद से भेजा जाता है, इसलिए लेयर के बीच अपकॉल या डाउनकॉल होने पर, मालिकाना हक ट्रांसफ़र किया जाता है. साथ ही, बफ़र को खाली करने की ज़िम्मेदारी कॉल पाने वाले (कॉलर) की होती है. क्रॉस-लेयर कॉल पूरे न हो पाने पर, बफ़र खाली करने की ज़िम्मेदारी कॉलर की होती है.

PacketBuffer क्लास के नए ऑब्जेक्ट, मौजूदा एनवायरमेंट से मिली मेमोरी के बंटवारे की शुरुआत में शुरू होते हैं, जैसे कि इंटरनल बफ़र पूल की स्टैंडर्ड C लाइब्रेरी हीप से, LwIP pbuf टारगेट पूल से लिया गया. आसान मामले में, डेटा बफ़र का साइज़ WEAVE_SYSTEM_PACKETBUFFER_SIZE है. एक कंपोज़र दिया जाता है, जो अन्य साइज़ के डेटा बफ़र के इस्तेमाल की अनुमति देता है.

बड़े पेलोड को साथ रखने के लिए PacketBuffer ऑब्जेक्ट को चेन में जोड़ा जा सकता है. चेन बनाना, हालांकि, पारदर्शी नहीं है और क्लास के उपयोगकर्ताओं को साफ़ तौर पर चेनिंग का समर्थन करने का फ़ैसला लेना होगा. चेनिंग सपोर्ट के साथ लिखी गई क्लास के उदाहरण यहां दिए गए हैं:

@ref nl::Weave::WeaveTLVReader
@ref nl::Weave::WeaveTLVWriter

इनहेरिटेंस

इससे इनहेरिट किया जाता है: pbuf

सार्वजनिक फ़ंक्शन
`AddRef(void)`	`void` मौजूदा बफ़र की रेफ़रंस संख्या बढ़ाएं.
`AddToEnd(PacketBuffer *aPacket)`	`void` दिए गए पैकेट बफ़र को बफ़र चेन के आखिर में जोड़ें. इसके बाद, चेन में हर बफ़र की कुल लंबाई को उसके हिसाब से अडजस्ट करें.
`AlignPayload(uint16_t aAlignBytes)`	`bool` बफ़र पेलोड को दी गई बाइट सीमा पर अलाइन करें.
`AllocSize(void) const`	`size_t` असाइन किए गए डेटा का साइज़ दिखाएं. इसमें, रिज़र्व और पेलोड डेटा स्पेस शामिल हैं. हालांकि, PacketBuffer के लिए तय की गई जगह के साइज़ को शामिल न करना.
`AvailableDataLength(void) const`	`uint16_t` शुरू होने की मौजूदा जगह और डेटा की लंबाई के आधार पर, मौजूदा बफ़र में जोड़े जा सकने वाले डेटा के बाइट पाएं.
`CompactHead(void)`	`void` चेन में बाद के बफ़र में मौजूद डेटा को तब तक मौजूदा बफ़र में ले जाएं, जब तक वह भर न जाए.
`Consume(uint16_t aConsumeLength)`	`PacketBuffer *` बफ़र की चेन में डेटा का इस्तेमाल करता है.
`ConsumeHead(uint16_t aConsumeLength)`	`void` इस्तेमाल किए गए डेटा की मात्रा दिखाने के लिए, मौजूदा बफ़र को अडजस्ट करें.
`DataLength(void) const`	`uint16_t` पैकेट बफ़र में डेटा की लंबाई, बाइट में पाएं.
`DetachTail(void)`	`PacketBuffer *` मौजूदा बफ़र को उसकी चेन से अलग करें और बचे हुए बफ़र पर पॉइंटर दिखाएं.
`EnsureReservedSize(uint16_t aReservedSize)`	`bool` पक्का करें कि बफ़र में कम से कम तय की गई जगह हो.
`MaxDataLength(void) const`	`uint16_t` शुरू होने की मौजूदा जगह और बफ़र साइज़ के आधार पर, बफ़र में फ़िट होने वाले डेटा की ज़्यादा से ज़्यादा संख्या बाइट में पाएं.
`Next(void) const`	`PacketBuffer *` चेन में अगले बफ़र के लिए पॉइंटर पाएं.
`ReservedSize(void) const`	`uint16_t` बफ़र की शुरुआत और डेटा के शुरू होने की मौजूदा स्थिति के बीच, मौजूदा बफ़र में बाइट की संख्या पाएं.
`SetDataLength(uint16_t aNewLen, PacketBuffer *aChainHead)`	`void` बफ़र में डेटा की लंबाई, बाइट में सेट करें और उसके हिसाब से कुल लंबाई को अडजस्ट करें.
`SetStart(uint8_t *aNewStart)`	`void` इसके अनुसार लंबाई और कुल लंबाई को अडजस्ट करके, शुरुआती डेटा को बफ़र में सेट करें.
`Start(void) const`	`uint8_t *` बफ़र में डेटा की शुरुआत के लिए पॉइंटर पाएं.
`TotalLength(void) const`	`uint16_t` बफ़र चेन में पैकेट डेटा की कुल लंबाई पाएं.

सार्वजनिक स्टैटिक फ़ंक्शन
`Free(PacketBuffer *aPacket)`	`void` एक चेन में सभी पैकेट बफ़र को खाली करें.
`FreeHead(PacketBuffer *aPacket)`	`PacketBuffer *` चेन में पहला बफ़र खाली करें और बाकी बफ़र के लिए पॉइंटर दिखाएं.
`New(void)`	`PacketBuffer *` यह पेलोड में, रिज़र्व किए गए डिफ़ॉल्ट साइज़ (WEAVE_SYSTEM_CONFIG_HEADER_RESERVE_SIZE) के साथ डिफ़ॉल्ट साइज़ (WEAVE_SYSTEM_CONFIG_PACKETBUFFER_CAPACITY_MAX) का एक PacketBuffer असाइन करता है.
`New(uint16_t aReservedSize)`	`PacketBuffer *` यह तय किए गए हेडर रिज़र्व साइज़ के साथ, ज़्यादा से ज़्यादा साइज़ वाला एक PacketBuffer असाइन करता है.
`NewWithAvailableSize(size_t aAvailableSize)`	`PacketBuffer *` हेडर के पेलोड में डिफ़ॉल्ट रिज़र्व साइज़ (WEAVE_SYSTEM_CONFIG_HEADER_RESERVE_SIZE) के साथ PacketBuffer को तय करता है और अतिरिक्त कर्सर के लिए शुरुआती डेटा के लिए कम से कम `aAllocSize` बाइट के बाद खाली जगह देता है.
`NewWithAvailableSize(uint16_t aReservedSize, size_t aAvailableSize)`	`PacketBuffer *` यह ऐसे PacketBuffer ऑब्जेक्ट को असाइन करता है जिसमें हेडर के लिए पेलोड में कम से कम `aReservedSize` बाइट रिज़र्व किए गए हों. साथ ही, शुरुआती कर्सर पॉइंटर के बाद, अतिरिक्त डेटा के लिए कम से कम `aAllocSize` बाइट की जगह असाइन करता है.
`RightSize(PacketBuffer *aPacket)`	`PacketBuffer *` अगर लागू हो, तो दिए गए बफ़र को सही साइज़ के बफ़र में कॉपी करें.

सार्वजनिक फ़ंक्शन

AddRef

void AddRef(
  void
)

मौजूदा बफ़र की रेफ़रंस संख्या बढ़ाएं.

AddToEnd

void AddToEnd(
  PacketBuffer *aPacket
)

दिए गए पैकेट बफ़र को बफ़र चेन के आखिर में जोड़ें. इसके बाद, चेन में हर बफ़र की कुल लंबाई को उसके हिसाब से अडजस्ट करें.

ब्यौरा

पैरामीटर

[in] aPacket

- मौजूदा चेन के आखिर में पैकेट बफ़र को जोड़ना है.

AlignPayload

bool AlignPayload(
  uint16_t aAlignBytes
)

बफ़र पेलोड को दी गई बाइट सीमा पर अलाइन करें.

अगर ज़रूरी हो, तो बफ़र में पेलोड को आगे ले जाएं.

ब्यौरा

पैरामीटर

[in] aAlignBytes

- पेलोड स्टार्ट पॉइंटर के लिए, बाइट अलाइनमेंट की संख्या तय करता है.

लौटाए जाने वाले प्रॉडक्ट

अलाइनमेंट पूरा होने पर true, अगर बफ़र में ज़रूरत के मुताबिक जगह नहीं है, तो false.

AllocSize

size_t AllocSize(
  void
) const

असाइन किए गए डेटा का साइज़ दिखाएं. इसमें, रिज़र्व और पेलोड डेटा स्पेस शामिल हैं. हालांकि, PacketBuffer के लिए तय की गई जगह के साइज़ को शामिल न करना.

ध्यान दें: ऐलोकेशन का साइज़, aAllocSize पैरामीटर और Create तरीके के पैरामीटर के बराबर या उनसे ज़्यादा है.

ब्यौरा
लौटाए जाने वाले प्रॉडक्ट	असाइन किए गए बजट का साइज़

AvailableDataLength

uint16_t AvailableDataLength(
  void
) const

शुरू होने की मौजूदा जगह और डेटा की लंबाई के आधार पर, मौजूदा बफ़र में जोड़े जा सकने वाले डेटा के बाइट पाएं.

ब्यौरा
लौटाए जाने वाले प्रॉडक्ट	डेटा की लंबाई (बाइट में), जो मौजूदा बफ़र में फ़िट होगी. यह बफ़र, शुरू होने की मौजूदा जगह और डेटा की लंबाई के आधार पर तय किया जाएगा.

CompactHead

void CompactHead(
  void
)

चेन के बाद के बफ़र से डेटा को तब तक मौजूदा बफ़र में ले जाएं, जब तक कि डेटा पूरा भर न जाए.

सिर्फ़ मौजूदा बफ़र को छोटा किया जाता है: मौजूदा बफ़र में मौजूद डेटा को बफ़र के सामने ले जाया जाता है, ताकि कोई खाली जगह न हो. बची हुई जगह को बाद के बफ़र में भेजे गए डेटा से भरा जाता है. ऐसा तब तक होता है, जब तक मौजूदा बफ़र पूरा नहीं हो जाता. अगर चेन में इसके बाद के बफ़र को पूरी तरह से मौजूदा बफ़र में ले जाया जाता है, तो इसे चेन से हटाकर खाली कर दिया जाता है. यह तरीका कोई पैरामीटर नहीं लेता, न कोई नतीजा दिखाता है, और न ही उसे पूरा करता है.

उपभोग करें

PacketBuffer * Consume(
  uint16_t aConsumeLength
)

बफ़र की चेन में डेटा का इस्तेमाल करता है.

बफ़र की चेन में डेटा का इस्तेमाल करें, जो मौजूदा बफ़र से शुरू होता है और चेन में बाकी बफ़र में आगे बढ़ता है. पूरी तरह से इस्तेमाल किया गया हर बफ़र खाली कर दिया जाता है. साथ ही, फ़ंक्शन पहला बफ़र (अगर कोई हो) दिखाता है, जिसमें बचा हुआ डेटा होता है. मौजूदा बफ़र, बफ़र चेन का हिस्सा होना चाहिए.

ब्यौरा

पैरामीटर

[in] aConsumeLength

- मौजूदा चेन से ली जाने वाली बाइट की संख्या.

लौटाए जाने वाले प्रॉडक्ट

मौजूदा चेन का पहला बफ़र, जिसमें बचा हुआ डेटा मौजूद होता है. अगर कोई डेटा नहीं बचा, तो शून्य दिखाया जाता है.

ConsumeHead

void ConsumeHead(
  uint16_t aConsumeLength
)

इस्तेमाल किए गए डेटा की मात्रा दिखाने के लिए, मौजूदा बफ़र को अडजस्ट करें.

मौजूदा बफ़र में डेटा शुरू होने की जगह को तय की गई रकम के हिसाब से, बाइट में आगे बढ़ाएं. उसे बफ़र में डेटा की अवधि के हिसाब से तय करना होगा. वीडियो की लंबाई और कुल लंबाई को, वीडियो में इस्तेमाल की गई मात्रा के हिसाब से घटाएं.

ब्यौरा

पैरामीटर

[in] aConsumeLen

- मौजूदा बफ़र से खर्च किए जाने वाले बाइट की संख्या.

DataLength

uint16_t DataLength(
  void
) const

पैकेट बफ़र में डेटा की लंबाई, बाइट में पाएं.

ब्यौरा
लौटाए जाने वाले प्रॉडक्ट	लंबाई, बाइट में (मौजूदा पेलोड की लंबाई).

DetachTail

PacketBuffer * DetachTail(
  void
)

मौजूदा बफ़र को उसकी चेन से अलग करें और बचे हुए बफ़र पर पॉइंटर दिखाएं.

मौजूदा बफ़र, चेन का सबसे ऊपर होना चाहिए.

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

EnsureReservedSize

bool EnsureReservedSize(
  uint16_t aReservedSize
)

पक्का करें कि बफ़र में कम से कम तय की गई जगह हो.

पक्का करें कि बफ़र में कम से कम तय की गई जगह हो, ताकि बफ़र में डेटा को ज़रूरत के मुताबिक जगह दी जा सके.

ब्यौरा

पैरामीटर

[in] aReservedSize

- हेडर के लिए ज़रूरी बाइट की संख्या.

लौटाए जाने वाले प्रॉडक्ट

true, अगर अनुरोध किया गया रिज़र्व साइज़ उपलब्ध है, तो बफ़र में ज़रूरत के मुताबिक जगह न होने पर false.

MaxDataLength

uint16_t MaxDataLength(
  void
) const

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

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

अगला

PacketBuffer * Next(
  void
) const

चेन में अगले बफ़र के लिए पॉइंटर पाएं.

ब्यौरा
लौटाए जाने वाले प्रॉडक्ट	चेन में अगले बफ़र का पॉइंटर. चेन में कोई बफ़र न होने पर `NULL` लौटाया जाता है.

ReservedSize

uint16_t ReservedSize(
  void
) const

बफ़र की शुरुआत और डेटा के शुरू होने की मौजूदा स्थिति के बीच, मौजूदा बफ़र में बाइट की संख्या पाएं.

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

SetDataLength

void SetDataLength(
  uint16_t aNewLen,
  PacketBuffer *aChainHead
)

बफ़र में डेटा की लंबाई, बाइट में सेट करें और उसके हिसाब से कुल लंबाई को अडजस्ट करें.

फ़ंक्शन, बफ़र में डेटा की लंबाई बाइट में सेट करता है और कुल लंबाई को सही तरीके से अडजस्ट करता है. जब बफ़र, बफ़र चेन का हेड नहीं होता है (सामान्य मामले: कॉलर, ऊंची लेयर को कॉल करने से पहले, PacketBuffer चेन में आखिरी बफ़र में डेटा जोड़ता है), तो मौजूदा बफ़र से पहले हर बफ़र की कुल लंबाई को ठीक से अडजस्ट करने के लिए, aChainकिन को पास करना ज़रूरी है.

ब्यौरा

पैरामीटर

`[in] aNewLen`	- इस बफ़र की नई लंबाई बाइट में.
`[in,out] aChainHead`	- उस बफ़र चेन का हेडर जिससे मौजूदा बफ़र जुड़ा है. अगर मौजूदा बफ़र, बफ़र चेन की हेड है, तो वैल्यू शून्य हो सकती है.

SetStart

void SetStart(
  uint8_t *aNewStart
)

इसके अनुसार लंबाई और कुल लंबाई को अडजस्ट करके, शुरुआती डेटा को बफ़र में सेट करें.

ब्यौरा

पैरामीटर

[in] aNewStart

- वह पॉइंटर जहां से नया पेलोड शुरू होना चाहिए. newStart को PacketBuffer चेन में पहले बफ़र की सीमाओं में आने के लिए, अंदरूनी तौर पर अडजस्ट किया जाएगा.

शुरू करें

uint8_t * Start(
  void
) const

बफ़र में डेटा की शुरुआत के लिए पॉइंटर पाएं.

ब्यौरा
लौटाए जाने वाले प्रॉडक्ट	पॉइंटर को डेटा की शुरुआत में ले जाएं.

TotalLength

uint16_t TotalLength(
  void
) const

बफ़र चेन में पैकेट डेटा की कुल लंबाई पाएं.

ब्यौरा
लौटाए जाने वाले प्रॉडक्ट	कुल लंबाई, ऑक्टेट में.

सार्वजनिक स्टैटिक फ़ंक्शन

मुफ़्त

void Free(
  PacketBuffer *aPacket
)

एक चेन में सभी पैकेट बफ़र को खाली करें.

मौजूदा चेन में सभी बफ़र के लिए रेफ़रंस की संख्या कम करें. अगर पहचान फ़ाइलों की संख्या 0 हो जाती है, तो बफ़र को खाली कर दिया जाता है या ऐलोकेशन पूल में लौटा दिया जाता है. नियम के मुताबिक, उपयोगकर्ताओं को इस तरीके को free() फ़ंक्शन के बराबर मानना चाहिए और कॉल के बाद तर्क का इस्तेमाल नहीं करना चाहिए.

ब्यौरा

पैरामीटर

[in] aPacket

- पैकेट बफ़र को खाली किया जाना है.

FreeHead

PacketBuffer * FreeHead(
  PacketBuffer *aPacket
)

चेन में पहला बफ़र खाली करें और बाकी बफ़र के लिए पॉइंटर दिखाएं.

* @note When the buffer chain is referenced by multiple callers,FreeHead()` से हेड को अलग किया जाएगा, लेकिन हेड बफ़र को जबरन हटाया नहीं जाएगा.

ब्यौरा

पैरामीटर

[in] aPacket

- बफ़र चेन.

लौटाए जाने वाले प्रॉडक्ट

इनपुट बफ़र की टेल वाली पैकेट बफ़र चेन (यह NULL हो सकती है).

नए दर्शक

PacketBuffer * New(
  void
)

यह पेलोड में, रिज़र्व किए गए डिफ़ॉल्ट साइज़ (WEAVE_SYSTEM_CONFIG_HEADER_RESERVE_SIZE) के साथ डिफ़ॉल्ट साइज़ (WEAVE_SYSTEM_CONFIG_PACKETBUFFER_CAPACITY_MAX) का एक PacketBuffer असाइन करता है.

रिज़र्व किया गया साइज़ (WEAVE_SYSTEM_CONFIG_HEADER_RESERVE_SIZE) इतना बड़ा है कि इसमें ट्रांसपोर्ट लेयर हेडर के साथ-साथ, WeaveMessageLayer और WeaveExchangeLayer के लिए ज़रूरी हेडर भी शामिल किए जा सकते हैं.

नए दर्शक

PacketBuffer * New(
  uint16_t aReservedSize
)

यह तय किए गए हेडर रिज़र्व साइज़ के साथ, ज़्यादा से ज़्यादा साइज़ वाला एक PacketBuffer असाइन करता है.

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

PacketBuffer::New(0) : इस तरह कॉल करने पर, बिना किसी तय हेडर के बफ़र कर दिया जाएगा. इसके बाद, पूरा पेलोड कॉलर के पास इस्तेमाल करने के लिए उपलब्ध हो जाएगा. यह पैटर्न खास तौर पर नेटवर्किंग स्टैक की निचली लेयर के लिए काम का है. ऐसा उन मामलों में होता है जहां उपयोगकर्ता को पता हो कि पेलोड को सही हेडर रिज़र्व के साथ फ़ाइनल मैसेज में कॉपी किया जाएगा या PacketBuffer::AddToEnd() के ज़रिए PacketBuffer की चेन में PacketBuffer बनाने के लिए यह पैटर्न कॉपी किया जाएगा. पैरामीटर

[in] aReservedSize

हेडर के लिए खाली जगह है.

लौटाए जाने वाले प्रॉडक्ट

सफल होने पर, PacketBuffer की ओर पॉइंटर, गड़बड़ी NULL पर.

NewWithAvailableSize

PacketBuffer * NewWithAvailableSize(
  size_t aAvailableSize
)

हेडर के पेलोड में डिफ़ॉल्ट रिज़र्व साइज़ (WEAVE_SYSTEM_CONFIG_HEADER_RESERVE_SIZE) के साथ PacketBuffer को तय करता है और अतिरिक्त कर्सर के लिए शुरुआती डेटा के लिए कम से कम aAllocSize बाइट के बाद खाली जगह देता है.

किसी ऐप्लिकेशन-लेयर मैसेज के लिए PacketBuffer असाइन करते समय, इसका इस्तेमाल सबसे सही होता है.

ब्यौरा

पैरामीटर

[in] aAvailableSize

कर्सर के बाद आवंटित करने के लिए ऑक्टेट की संख्या.

लौटाए जाने वाले प्रॉडक्ट

सफलता मिलने पर, असाइन किए गए ब्लॉक में PacketBuffer के लिए पॉइंटर. विफल होने पर, NULL. *

NewWithAvailableSize

PacketBuffer * NewWithAvailableSize(
  uint16_t aReservedSize,
  size_t aAvailableSize
)

यह ऐसे PacketBuffer ऑब्जेक्ट को असाइन करता है जिसमें हेडर के लिए पेलोड में कम से कम aReservedSize बाइट रिज़र्व किए गए हों. साथ ही, शुरुआती कर्सर पॉइंटर के बाद, अतिरिक्त डेटा के लिए कम से कम aAllocSize बाइट की जगह असाइन करता है.

ब्यौरा

पैरामीटर

`[in] aReservedSize`	कर्सर के पीछे रिज़र्व करने के लिए ऑक्टेट की संख्या.
`[in] aAvailableSize`	कर्सर के बाद आवंटित करने के लिए ऑक्टेट की संख्या.

लौटाए जाने वाले प्रॉडक्ट

सफलता मिलने पर, असाइन किए गए ब्लॉक में PacketBuffer के लिए पॉइंटर. विफल होने पर, NULL.

RightSize

PacketBuffer * RightSize(
  PacketBuffer *aPacket
)

अगर लागू हो, तो दिए गए बफ़र को सही साइज़ के बफ़र में कॉपी करें.

यह फ़ंक्शन सॉकेट के लिए नो-ऑप है.

ब्यौरा

पैरामीटर

[in] aPacket

- बफ़र या बफ़र चेन.

लौटाए जाने वाले प्रॉडक्ट

नया पैकेट बफ़र या ओरिजनल बफ़र