nl:: बुनाई::सिस्टम::पैकबफ़र

#include <src/system/SystemPacketBuffer.h>

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

खास जानकारी

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

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

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

PacketBuffer क्लास के नए ऑब्जेक्ट, मुख्य वातावरण से मिली मेमोरी की शुरुआत से शुरू होते हैं. उदाहरण के लिए, WwIP pbuf टारगेट पूल, स्टैंडर्ड सी लाइब्रेरी हीप से, इंटरनल बफ़र पूल से. आसान मामले में, डेटा बफ़र का साइज़ WEAVE_सिस्टम_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)
बफ़र की चेन में डेटा का उपयोग करें.
ConsumeHead(uint16_t aConsumeLength)
void
इस्तेमाल किए गए डेटा की मात्रा दिखाने के लिए मौजूदा बफ़र को अडजस्ट करें.
DataLength(void) const
uint16_t
पैकेट बफ़र में डेटा की लंबाई, बाइट में पाएं.
DetachTail(void)
मौजूदा बफ़र को इसकी चेन से अलग करें और बाकी बफ़र पर पॉइंटर दें.
EnsureReservedSize(uint16_t aReservedSize)
bool
पक्का करें कि बफ़र में कम से कम उतनी जगह बची है जितनी रिज़र्व की गई है.
MaxDataLength(void) const
uint16_t
उस डेटा की ज़्यादा से ज़्यादा रकम पाएं जो मौजूदा शुरू की स्थिति और बफ़र के हिसाब से, बफ़र में फ़िट हो जाएगा.
Next(void) const
चेन में अगले बफ़र के लिए पॉइंटर पाएं.
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)
किसी चेन में पहला बफ़र खाली रखें, ताकि बाकी बचे बफ़र पर वापस पहुंचा जा सके.
New(void)
पेलोड में डिफ़ॉल्ट रूप से रिज़र्व किए गए साइज़ (WEAVE_सिस्टम_CONFIG_HEADER_RESERVE_SIZE) के साथ, डिफ़ॉल्ट साइज़ (WEAVE_सिस्टम_CONFIG_PACKETBUFFER_CAPACITY_MAX) का एक सिंगल PacketBuffer तय करता है.
New(uint16_t aReservedSize)
किसी खास हेडर रिज़र्व के साइज़ के साथ, ज़्यादा से ज़्यादा कुल साइज़ का एक PacketBuffer असाइन किया जाता है.
NewWithAvailableSize(size_t aAvailableSize)
डिफ़ॉल्ट तौर पर, रिज़र्व किए गए साइज़ (WEAVE_सिस्टम_CONFIG_HEADER_RESERVE_SIZE) के साथ PacketBuffer तय करता है. यह हेडर के पेलोड में मिलता-जुलता है, लेकिन शुरुआती कर्सर पॉइंटर के बाद ज़्यादा से ज़्यादा डेटा के लिए, कम से कम aAllocSize बाइट का स्पेस होना चाहिए.
NewWithAvailableSize(uint16_t aReservedSize, size_t aAvailableSize)
PacketBuffer ऑब्जेक्ट असाइन करता है. इसमें हेडर के लिए पेलोड में कम से कम aReservedSize बाइट रिज़र्व होते हैं. साथ ही, शुरुआती कर्सर पॉइंटर के बाद ज़्यादा डेटा के लिए कम से कम aAllocSize बाइट स्पेस मिलता है.
RightSize(PacketBuffer *aPacket)
लागू होने पर, दिए गए बफ़र को सही साइज़ वाले बफ़र में कॉपी करें.

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

AddRef

void AddRef(
  void
)

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

AddToEnd

void AddToEnd(
  PacketBuffer *aPacket
)

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

ब्यौरा
पैरामीटर
[in] aPacket
- पैकेट चेन को मौजूदा चेन के आखिर में जोड़ने के लिए.

अलाइनलोड

bool AlignPayload(
  uint16_t aAlignBytes
)

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

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

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

ऐलोकेशन

size_t AllocSize(
  void
) const

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

ब्यौरा
लौटाए गए सामान
ऐलोकेशन का साइज़

उपलब्ध डेटा लेंथ

uint16_t AvailableDataLength(
  void
) const

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

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

कॉम्पैक्ट हेड

void CompactHead(
  void
)

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

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

इस्तेमाल करें

PacketBuffer * Consume(
  uint16_t aConsumeLength
)

बफ़र की चेन में डेटा का उपयोग करें.

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

ब्यौरा
पैरामीटर
[in] aConsumeLength
- मौजूदा चेन से ली जाने वाली बाइट की संख्या.
लौटाए गए सामान
मौजूदा चेन का पहला बफ़र जिसमें बचा हुआ डेटा है. अगर कोई डेटा नहीं बचता है, तो NULL मिलता है.

उपभोक्ता हेड

void ConsumeHead(
  uint16_t aConsumeLength
)

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

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

ब्यौरा
पैरामीटर
[in] aConsumeLen
- मौजूदा बफ़र से इस्तेमाल किए जाने वाले बाइट की संख्या.

डेटा लंबाई

uint16_t DataLength(
  void
) const

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

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

डिटैचटेल

PacketBuffer * DetachTail(
  void
)

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

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

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

पक्का करें कि रिज़र्व किया गया साइज़ है

bool EnsureReservedSize(
  uint16_t aReservedSize
)

पक्का करें कि बफ़र में कम से कम उतनी जगह बची है जितनी रिज़र्व की गई है.

पक्का करें कि ज़रूरी होने पर, बफ़र में कम से कम इतनी जगह खाली हो कि वह बफ़र में डेटा ट्रांसफ़र हो सके.

ब्यौरा
पैरामीटर
[in] aReservedSize
- हेडर के लिए ज़रूरी बाइट की संख्या.
लौटाए गए सामान
true अगर अनुरोध किया गया रिज़र्व साइज़ उपलब्ध है, तो बफ़र में कम जगह होने पर false का इस्तेमाल किया जाता है.

ज़्यादा से ज़्यादा डेटा लंबाई

uint16_t MaxDataLength(
  void
) const

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

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

आगे बढ़ें

PacketBuffer * Next(
  void
) const

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

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

रिज़र्व किया गया साइज़

uint16_t ReservedSize(
  void
) const

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

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

डेटा की लंबाई सेट करें

void SetDataLength(
  uint16_t aNewLen,
  PacketBuffer *aChainHead
)

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

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

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

सेटस्टार्ट

void SetStart(
  uint8_t *aNewStart
)

शुरू होने से जुड़े डेटा को बफ़र में सेट करें, ताकि ज़रूरत के मुताबिक लंबाई और कुल अवधि में बदलाव किया जा सके.

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

स्टार्ट

uint8_t * Start(
  void
) const

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

ब्यौरा
लौटाए गए सामान
डेटा की शुरुआत का संकेत.

कुल लंबाई

uint16_t TotalLength(
  void
) const

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

ब्यौरा
लौटाए गए सामान
ऑक्टेट में कुल लंबाई.

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

मुफ़्त

void Free(
  PacketBuffer *aPacket
)

चेन में सभी पैकेट बफ़र को मुफ़्त में आज़माएं.

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

ब्यौरा
पैरामीटर
[in] aPacket
- पैकेट बफ़र को खाली किया जाना है.

फ़्रीहेड

PacketBuffer * FreeHead(
  PacketBuffer *aPacket
)

किसी चेन में पहला बफ़र खाली रखें, ताकि बाकी बचे बफ़र पर वापस पहुंचा जा सके.

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

ब्यौरा
पैरामीटर
[in] aPacket
- बफ़र चेन.
लौटाए गए सामान
पैकेट बफ़र चेन, जिसमें इनपुट बफ़र की पूंछ है (NULL हो सकती है).

नया

PacketBuffer * New(
  void
)

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

आरक्षित आकार (WEAVE_System_CONFIG_HEADER_RESERVE_SIZE), ट्रांसपोर्ट परत के हेडर के साथ-साथ WeaveMessageLayer और WeaveExchangeLayer के लिए ज़रूरी हेडर को होल्ड करने के लिए काफ़ी बड़ा है.

नया

PacketBuffer * New(
  uint16_t aReservedSize
)

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

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

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

NewWithAvailableSize

PacketBuffer * NewWithAvailableSize(
  size_t aAvailableSize
)

डिफ़ॉल्ट तौर पर, रिज़र्व किए गए साइज़ (WEAVE_सिस्टम_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.

दायां साइज़

PacketBuffer * RightSize(
  PacketBuffer *aPacket
)

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

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

ब्यौरा
पैरामीटर
[in] aPacket
- बफ़र या बफ़र चेन.
लौटाए गए सामान
नया पैकेट बफ़र या मूल बफ़र