nl:: Weave:: TLV:: TLVWriter
#include <src/lib/core/WeaveTLV.h>
Stellt einen speichereffizienten Encoder zum Schreiben von Daten im Weave-TLV-Format bereit.
Fazit
TLVWriter implementiert einen ausschließlich für den Stream vorgesehenen Encoder für Weave-TLV-Daten. In Anwendungen werden Daten in eine Codierung geschrieben. Dazu wird eine der PUT()-Methoden des Writers aufgerufen und die zugehörigen Tag- und Wertinformationen werden bei Bedarf übergeben. Außerdem können Anwendungen TLV-Containertypen (Strukturen, Arrays oder Pfade) codieren, indem die OpenContainer()- oder EnterContainer()-Methoden des Autors aufgerufen werden.
Ein TLVWriter-Objekt kann Daten direkt in einen festen Ausgabezwischenspeicher oder in eine Kette eines oder mehrerer PacketBuffer-Objekte schreiben. Außerdem können die Anwendungen ihre eigenen GetNewBuffer
- und FinalizeBuffer
-Funktionen bereitstellen, um die Ausgabe an ein beliebiges Ziel zu weiterleiten, z.B. eine Socket oder eine Ereigniswarteschlange.
Übernahme
Direkt bekannte untergeordnete Klassen: nl::Weave::TLV::CircularTLVWriter
Geschützte Typen |
|
---|---|
@72{
|
enum |
Öffentliche Typen |
|
---|---|
FinalizeBufferFunct)(TLVWriter &writer, uintptr_t bufHandle, uint8_t *bufStart, uint32_t bufLen)
|
WEAVE_ERROR(* Eine Funktion zum Beenden der Ausgabe eines TLVWriter-Objekts. |
GetNewBufferFunct)(TLVWriter &writer, uintptr_t &bufHandle, uint8_t *&bufStart, uint32_t &bufLen)
|
WEAVE_ERROR(* Eine Funktion, die einen neuen Ausgabezwischenspeicher für einen TLVWriter bereitstellt. |
Öffentliche Attribute |
|
---|---|
AppData
|
void *
Ein Zeigerfeld, das für anwendungsspezifische Daten verwendet werden kann.
|
FinalizeBuffer
|
Ein Zeiger auf eine Funktion, die aufgerufen wird, wenn TLVWriter fertig ist.
|
GetNewBuffer
|
Ein Zeiger auf eine Funktion, die einem TLVWriter neuen Pufferraum für die Ausgabe bereitstellt.
|
ImplicitProfileId
|
uint32_t
Die Profil-ID der Tags, die implizit codiert werden sollen.
|
Geschützte Attribute |
|
---|---|
mBufHandle
|
uintptr_t
|
mBufStart
|
uint8_t *
|
mContainerType
|
|
mLenWritten
|
uint32_t
|
mMaxLen
|
uint32_t
|
mRemainingLen
|
uint32_t
|
mWritePoint
|
uint8_t *
|
Öffentliche Funktionen |
|
---|---|
CloseContainer(TLVWriter & containerWriter)
|
Stellt den Schreibvorgang eines TLV-Containers nach einem Aufruf von OpenContainer() abgeschlossen.
|
ContinuePutBytes(const uint8_t *buf, uint32_t len)
|
Codiert einen TLV-Byte-Stringwert.
|
CopyContainer(TLVReader & container)
|
|
CopyContainer(uint64_t tag, TLVReader & container)
|
Codiert ein TLV-Containerelement aus einem vordefinierten Satz von Mitgliedselementen.
|
CopyContainer(uint64_t tag, const uint8_t *encodedContainer, uint16_t encodedContainerLen)
|
Codiert ein TLV-Containerelement, das Mitgliedselemente aus einem vorcodierten Container enthält.
|
CopyElement(TLVReader & reader)
|
Kopiert ein TLV-Element aus einem Reader-Objekt in den Autor.
|
CopyElement(uint64_t tag, TLVReader & reader)
|
|
EndContainer(TLVType outerContainerType)
|
Schließt die Codierung eines TLV-Containerelements ab.
|
Finalize(void)
|
Beenden Sie den Schreibvorgang einer TLV-Codierung.
|
GetContainerType(void) const
|
Gibt den Containertyp zurück, in den TLVWriter derzeit schreibt.
|
GetLengthWritten(void)
|
uint32_t
Gibt die Gesamtzahl der Byte zurück, die seit der Initialisierung des Autors geschrieben wurden.
|
Init(uint8_t *buf, uint32_t maxLen)
|
void
Initialisiert ein TLVWriter-Objekt, das in einen einzelnen Ausgabezwischenspeicher schreibt.
|
Init(PacketBuffer *buf, uint32_t maxLen)
|
void
Initialisiert ein TLVWriter-Objekt, das in einen einzelnen PacketBuffer schreibt.
|
Init(PacketBuffer *buf, uint32_t maxLen, bool allowDiscontiguousBuffers)
|
void
Initialisiert ein TLVWriter-Objekt, um es in einen oder mehrere PacketBuffers zu schreiben.
|
InitMalloced(uint8_t *& outBuf, uint32_t initialBufSize, uint32_t maxLen)
|
void
Initialisiert ein TLVWriter-Objekt, das in einen dynamischen Puffer geschrieben wird.
|
OpenContainer(uint64_t tag, TLVType containerType, TLVWriter & containerWriter)
|
|
Put(uint64_t tag, int8_t v)
|
Codiert einen mit TLV signierten ganzzahligen Wert.
|
Put(uint64_t tag, int8_t v, bool preserveSize)
|
Codiert einen mit TLV signierten ganzzahligen Wert.
|
Put(uint64_t tag, int16_t v)
|
|
Put(uint64_t tag, int16_t v, bool preserveSize)
|
|
Put(uint64_t tag, int32_t v)
|
|
Put(uint64_t tag, int32_t v, bool preserveSize)
|
|
Put(uint64_t tag, int64_t v)
|
|
Put(uint64_t tag, int64_t v, bool preserveSize)
|
|
Put(uint64_t tag, uint8_t v)
|
Codiert einen TLV-Wert ohne Vorzeichen.
|
Put(uint64_t tag, uint8_t v, bool preserveSize)
|
Codiert einen TLV-Wert ohne Vorzeichen.
|
Put(uint64_t tag, uint16_t v)
|
|
Put(uint64_t tag, uint16_t v, bool preserveSize)
|
|
Put(uint64_t tag, uint32_t v)
|
|
Put(uint64_t tag, uint32_t v, bool preserveSize)
|
|
Put(uint64_t tag, uint64_t v)
|
|
Put(uint64_t tag, uint64_t v, bool preserveSize)
|
|
Put(uint64_t tag, float v)
|
|
Put(uint64_t tag, double v)
|
Codiert einen TLV-Gleitkommawert.
|
PutBoolean(uint64_t tag, bool v)
|
Codiert einen booleschen Wert im TLV.
|
PutBytes(uint64_t tag, const uint8_t *buf, uint32_t len)
|
Codiert einen TLV-Byte-Stringwert.
|
PutNull(uint64_t tag)
|
Codiert einen TLV-Nullwert
|
PutPreEncodedContainer(uint64_t tag, TLVType containerType, const uint8_t *data, uint32_t dataLen)
|
Codiert ein TLV-Containerelement aus einem vordefinierten Satz von Mitgliedselementen.
|
PutString(uint64_t tag, const char *buf)
|
Codiert einen TL8-String-Wert vom Typ TLV
|
PutString(uint64_t tag, const char *buf, uint32_t len)
|
Codiert einen TL8-String-Wert vom Typ TLV
|
PutStringF(uint64_t tag, const char *fmt, ...)
|
Codieren Sie die Stringausgabe im Format im TLV-Element.
|
StartContainer(uint64_t tag, TLVType containerType, TLVType & outerContainerType)
|
Startet die Codierung eines neuen TLV-Containerelements.
|
StartPutBytes(uint64_t tag, uint32_t totalLen)
|
Codiert einen TLV-Byte-String in mehreren Blöcken.
|
VPutStringF(uint64_t tag, const char *fmt, va_list ap)
|
Codieren Sie die Stringausgabe im Format im TLV-Element.
|
Öffentliche statische Funktionen |
|
---|---|
FinalizePacketBuffer(TLVWriter & writer, uintptr_t bufHandle, uint8_t *bufStart, uint32_t dataLen)
|
Implementierung eines TLVWriter FinalizeBuffers zum Schreiben in PacketBuffers
|
GetNewBuffer_Malloced(TLVWriter & writer, uintptr_t & bufHandle, uint8_t *& bufStart, uint32_t & bufLen)
|
Implementierung von GetNewBuffer TLVWriter zum Schreiben in einen dynamischen Puffer
|
GetNewPacketBuffer(TLVWriter & writer, uintptr_t & bufHandle, uint8_t *& bufStart, uint32_t & bufLen)
|
Implementierung von TLVWriter GetNewBuffer für das Schreiben in eine PacketBuffers.
|
Geschützte Funktionen |
|
---|---|
IsCloseContainerReserved(void) const
|
bool
Legen Sie fest, ob der Container Platz für das CloseContainer-Symbol beim Starten / Öffnen des Containers reservieren soll.
|
IsContainerOpen(void) const
|
bool
|
SetCloseContainerReserved(bool aCloseContainerReserved)
|
void
Legen Sie fest, ob der Container den Bereich für das CloseContainer-Symbol zum Starten oder Öffnen des Containers reservieren soll.
|
SetContainerOpen(bool aContainerOpen)
|
void
|
WriteData(const uint8_t *p, uint32_t len)
|
|
WriteElementHead(TLVElementType elemType, uint64_t tag, uint64_t lenOrVal)
|
|
WriteElementWithData(TLVType type, uint64_t tag, const uint8_t *data, uint32_t dataLen)
|
Geschützte Typen
@72
@72
Öffentliche Typen
FinalizeBufferFunct
WEAVE_ERROR(* FinalizeBufferFunct)(TLVWriter &writer, uintptr_t bufHandle, uint8_t *bufStart, uint32_t bufLen)
Eine Funktion zum Beenden der Ausgabe eines TLVWriter-Objekts.
Funktionen dieses Typs werden aufgerufen, wenn eine TLVWriter-Methode Finalize() aufgerufen wird. Es wird erwartet, dass die Funktion alle erforderlichen Bereinigungs- oder Abschlussvorgänge ausführt, die mit der Ausgabe des Ausgabeobjekts zusammenhängen. Beispiele hierfür sind die Aufzeichnung der endgültigen Länge der Codierung oder das Schließen einer Dateibeschreibung.
Details | |||||||||
---|---|---|---|---|---|---|---|---|---|
Parameter |
|
||||||||
Rückgabewerte |
|
GetNewBufferFunct
WEAVE_ERROR(* GetNewBufferFunct)(TLVWriter &writer, uintptr_t &bufHandle, uint8_t *&bufStart, uint32_t &bufLen)
Eine Funktion, die einen neuen Ausgabezwischenspeicher für einen TLVWriter bereitstellt.
Funktionen dieses Typs werden verwendet, um einen neuen Pufferbereich für das Schreiben in einen TLVWriter vorzubereiten. Beim Aufrufen der Funktion wird erwartet, dass ein Zeiger zusammen mit einer zugehörigen maximalen Länge an einen Speicherspeicherort zurückgegeben wird, an den neue Daten geschrieben werden sollen. Die Funktion kann Speicherplatz bereitstellen, indem sie entweder einen neuen Puffer für die Daten zuweist oder zuvor geschriebene Daten aus einem vorhandenen Puffer gelöscht werden.
Details | |||||||||
---|---|---|---|---|---|---|---|---|---|
Parameter |
|
||||||||
Rückgabewerte |
|
Öffentliche Attribute
App-Daten
void * AppData
Ein Zeigerfeld, das für anwendungsspezifische Daten verwendet werden kann.
FinalizeBuffer
FinalizeBufferFunct FinalizeBuffer
Ein Zeiger auf eine Funktion, die aufgerufen wird, wenn TLVWriter fertig ist.
Ein TLVWriter-Objekt ruft die Funktion „FinalizeBuffer“ jedes Mal auf, wenn die Methode Finalize() aufgerufen wird. Vor dem Aufruf von Finalize() kann in Apps der Funktionszeiger festgelegt werden. Standardmäßig ist der Zeiger auf NULL gesetzt. Dadurch wird die Funktion Finalize() entfernt.
Weitere Informationen zur Implementierung der FinalizeBuffer-Funktion finden Sie in der Definition des FinalizeBufferFunct-Typs.
GetNewBuffer
GetNewBufferFunct GetNewBuffer
Ein Zeiger auf eine Funktion, die einem TLVWriter neuen Pufferraum für die Ausgabe bereitstellt.
Ein TLVWriter-Objekt ruft die GetNewBuffer-Funktion auf, wenn versucht wird, Daten zu schreiben, die die Größe des aktuellen Ausgabezwischenspeichers überschreiten. Wenn dieser Wert auf NULL (Standardwert) festgelegt ist, gibt der Autor den Fehler WEAVE_ERROR_NO_MEMORY zurück, wenn die Ausgabedaten den aktuellen Puffer überlaufen.
GetNewBuffer kann von einer Anwendung jederzeit festgelegt werden, wird aber normalerweise festgelegt, wenn der Autor initialisiert wird.
Weitere Informationen zur Implementierung einer GetNewBuffer-Funktion finden Sie in der Definition des GetNewBufferFunct-Typs.
Implizite Profil-ID
uint32_t ImplicitProfileId
Die Profil-ID der Tags, die implizit codiert werden sollen.
Wenn ein Autor aufgefordert wird, ein neues Element zu codieren, und wenn die Profil-ID des mit dem neuen Element verknüpften Tags mit dem Wert des Mitglieds ImplicitProfileId
übereinstimmt, codiert der Autor den Tag implizit. Die Profil-ID wird dabei dabei weggelassen.
Standardmäßig wird die Property ImplicitProfileId
auf „kProfileIdNotspecified“ gesetzt. Dadurch wird der Autor angewiesen, implizit codierte Tags nicht auszugeben. Für Anwendungen kann jederzeit ImplicitProfileId
festgelegt werden, um Codierungs-Tags implizit in der Codierung zu aktivieren. Die entsprechende Profil-ID hängt in der Regel vom Kontext der gesprochenen Anwendung oder des Protokolls ab.
Geschützte Attribute
Mobiler Griff
uintptr_t mBufHandle
mBufStart
uint8_t * mBufStart
mContainerType
TLVType mContainerType
mLenWriter
uint32_t mLenWritten
mMaxLen [mMaxLen]
uint32_t mMaxLen
mÜlendeLens
uint32_t mRemainingLen
mWritePoint
uint8_t * mWritePoint
Öffentliche Funktionen
Schließen-Container
WEAVE_ERROR CloseContainer( TLVWriter & containerWriter )
Stellt den Schreibvorgang eines TLV-Containers nach einem Aufruf von OpenContainer() abgeschlossen.
Die Methode CloseContainer() stellt den Status eines übergeordneten TLVWriter-Objekts nach einem Aufruf von OpenContainer() wieder her. Für jeden Aufruf von OpenContainer()-Anwendungen muss ein entsprechender Aufruf an CloseContainer() erfolgen und ein Verweis auf denselben Container-Writer an beide Methoden übergeben werden.
Wenn CloseContainer() zurückgegeben wird, können Anwendungen weiterhin den übergeordneten Autor verwenden, um zusätzliche TLV-Elemente zu schreiben, die nach dem Container-Element erscheinen. An diesem Punkt sollte der bereitgestellte Container-Writer als 'de-initiald' betrachtet werden und darf nicht ohne erneute Initialisierung verwendet werden.
Details | |||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Parameter |
|
||||||||||||
Rückgabewerte |
|
Setzt Bytes
WEAVE_ERROR ContinuePutBytes( const uint8_t *buf, uint32_t len )
Codiert einen TLV-Byte-Stringwert.
Sollte mit Start PutBytes verwendet werden.
Details | |||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Parameter |
|
||||||||||||
Rückgabewerte |
|
Container kopieren
WEAVE_ERROR CopyContainer( TLVReader & container )
Kopiert ein TLV-Containerelement aus dem TLVReader-Objekt.
Mit CopyContainer() wird ein neues TLV-Containerelement codiert. Dazu wird ein vorcodiertes Containerelement an der aktuellen Position eines TLVReader-Objekts kopiert. Mit der Methode wird das gesamte neue Containerelement in einem Aufruf geschrieben. Dabei werden der Typ, das Tag und die Elemente des Containers aus der Quellcodierung kopiert. Bei der Rückgabe der Methode kann das Autor-Objekt verwendet werden, um zusätzliche TLV-Elemente nach dem Container-Element zu schreiben.
Details | |||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Parameter |
|
||||||||||||||||||
Rückgabewerte |
|
Container kopieren
WEAVE_ERROR CopyContainer( uint64_t tag, TLVReader & container )
Codiert ein TLV-Containerelement aus einem vordefinierten Satz von Mitgliedselementen.
Mit der Methode CopyContainer() wird ein neues TLV-Containerelement (eine Struktur, ein Array oder ein Pfad) mit einem Satz von Mitgliedselementen codiert, die aus einem TLVReader-Objekt stammen. Wenn die Methode aufgerufen wird, wird das bereitgestellte Reader-Objekt voraussichtlich in einem TLV-Containerelement positioniert. Der codierte Container hat denselben Typ und dieselben Mitglieder wie der Eingabecontainer. Das Tag für den neuen Container wird als Eingabeparameter angegeben.
Bei der Rückgabe der Methode kann das Autor-Objekt verwendet werden, um zusätzliche TLV-Elemente nach dem Container-Element zu schreiben.
Details | |||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Parameter |
|
||||||||||||||||||
Rückgabewerte |
|
Container kopieren
WEAVE_ERROR CopyContainer( uint64_t tag, const uint8_t *encodedContainer, uint16_t encodedContainerLen )
Codiert ein TLV-Containerelement, das Mitgliedselemente aus einem vorcodierten Container enthält.
Mit der Methode CopyContainer() wird ein neues TLV-Containerelement (eine Struktur, ein Array oder ein Pfad) mit einem Satz von Mitgliedselementen codiert, die aus den Inhalten eines bereitgestellten vorcodierten Containers stammen. Beim Aufrufen der Methode werden Daten im bereitgestellten Eingabezwischenspeicher als TLV-Containerelement geparst, ein neuer Container mit demselben Typ und denselben Mitgliedern wie der Eingabecontainer. Das Tag für den neuen Container wird als Eingabeparameter angegeben.
Bei der Rückgabe der Methode kann das Autor-Objekt verwendet werden, um zusätzliche TLV-Elemente nach dem Container-Element zu schreiben.
Details | |||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Parameter |
|
||||||||||||||||
Rückgabewerte |
|
Kopieren
WEAVE_ERROR CopyElement( TLVReader & reader )
Kopiert ein TLV-Element aus einem Reader-Objekt in den Autor.
Mit der Methode CopyElement() wird ein neues TLV-Element codiert, dessen Typ, Tag und Wert von einem TLVReader-Objekt stammen. Wenn die Methode aufgerufen wird, wird das bereitgestellte Reader-Objekt voraussichtlich im TLV-Quellelement positioniert. Das codierte Element hat denselben Typ, dasselbe Tag und denselben Inhalt wie der Eingabecontainer. Wenn das bereitgestellte Element ein TLV-Container (Struktur, Array oder Pfad) ist, wird der gesamte Inhalt des Containers kopiert.
Details | |||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Parameter |
|
||||||||||||||||||
Rückgabewerte |
|
Kopieren
WEAVE_ERROR CopyElement( uint64_t tag, TLVReader & reader )
Endcontainer
WEAVE_ERROR EndContainer( TLVType outerContainerType )
Schließt die Codierung eines TLV-Containerelements ab.
Die Methode EndContainer() schließt die Codierung eines TLV-Containerelements ab und stellt den Status eines TLVWrite-Objekts nach einem früheren Aufruf von StartContainer() wieder her. Für jeden Aufruf von StartContainer()-Anwendungen muss ein entsprechender Aufruf an EndContainer() erfolgen, indem der TLVType-Wert übergeben wird, der vom StartContainer()-Aufruf zurückgegeben wurde. Wenn EndContainer() zurückgegeben wird, kann das Schreibobjekt verwendet werden, um zusätzliche TLV-Elemente zu schreiben, die dem Containerelement folgen.
Details | |||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Parameter |
|
||||||||||||
Rückgabewerte |
|
Abschließen
WEAVE_ERROR Finalize( void )
Beenden Sie den Schreibvorgang einer TLV-Codierung.
Mit der Methode Finalize() wird der Schreibvorgang einer TLV-Codierung in den zugrunde liegenden Ausgabezwischenspeicher abgeschlossen. Die Methode muss von der Anwendung aufgerufen werden, bevor der Inhalt des Zwischenspeichers verwendet wird. Finalize() kann nur aufgerufen werden, wenn kein Container-Writer für den aktuellen Autor geöffnet ist. (Siehe OpenContainer()
).
Details | |||||||
---|---|---|---|---|---|---|---|
Rückgabewerte |
|
Containertyp abrufen
TLVType GetContainerType( void ) const
Gibt den Containertyp zurück, in den TLVWriter derzeit schreibt.
Die Methode GetContainerType() gibt den Typ des TLV-Containers zurück, in den der TLVWriter gerade schreibt. Wenn der TLVWriter keine Elemente in einen Container schreibt, d.h. auf die oberste Ebene einer Codierung schreibt, gibt die Methode "kTLVType_Notspecified" zurück.
Details | |
---|---|
Rückgabe |
Der TLVType des aktuellen Containers oder „kTLVType_Notspecified“, wenn der TLVWriter keine Elemente in einem Container schreibt.
|
GetLengthWrite
uint32_t GetLengthWritten( void )
Gibt die Gesamtzahl der Byte zurück, die seit der Initialisierung des Autors geschrieben wurden.
Details | |
---|---|
Rückgabe |
Gesamtzahl der Byte, die seit der Initialisierung des Autors geschrieben wurden.
|
Init
void Init( uint8_t *buf, uint32_t maxLen )
Init
void Init( PacketBuffer *buf, uint32_t maxLen )
Initialisiert ein TLVWriter-Objekt, das in einen einzelnen PacketBuffer schreibt.
Das Schreiben beginnt sofort nach dem letzten Byte der vorhandenen Daten im bereitgestellten Puffer.
Details | |||||
---|---|---|---|---|---|
Parameter |
|
Init
void Init( PacketBuffer *buf, uint32_t maxLen, bool allowDiscontiguousBuffers )
Initialisiert ein TLVWriter-Objekt, um es in einen oder mehrere PacketBuffers zu schreiben.
Das Schreiben beginnt sofort nach dem letzten Byte der vorhandenen Daten im angegebenen Puffer. Wenn allowDiscontiguousBuffers
„true“ ist, werden zusätzliche PacketBuffers bereitgestellt und mit dem bereitgestellten Zwischenspeicher verkettet, um die Menge der geschriebenen Daten zu berücksichtigen. Wenn der angegebene Ausgabezwischenspeicher bereits der Kopf einer Zwischenspeicherkette ist, wird die Ausgabe in die nachfolgenden Zwischenspeicher in der Kette geschrieben, bevor neue Zwischenspeicher zugewiesen werden.
Details | |||||||
---|---|---|---|---|---|---|---|
Parameter |
|
InitMalloced
void InitMalloced( uint8_t *& outBuf, uint32_t initialBufSize, uint32_t maxLen )
Initialisiert ein TLVWriter-Objekt, das in einen dynamischen Puffer geschrieben wird.
Details | |||||||
---|---|---|---|---|---|---|---|
Parameter |
|
OpenContainer
WEAVE_ERROR OpenContainer( uint64_t tag, TLVType containerType, TLVWriter & containerWriter )
Initialisiert ein neues TLVWriter-Objekt zum Schreiben der Mitglieder eines TLVWriter-Containers.
Mit der Methode OpenContainer() wird TLV-Container-Elemente (Struktur, Arrays oder Pfade) in eine Codierung geschrieben. Bei dieser Methode werden der Typ und das Tag des neuen Containers (sofern vorhanden) sowie ein Verweis auf ein neues Schreibobjekt (der Container-Autor) verwendet, das initialisiert wird, um die Container-Elemente zu schreiben. In Anwendungen werden die Mitglieder des neuen Containers mit dem Container-Writer geschrieben und dann CloseContainer() aufgerufen, um die Container-Codierung abzuschließen.
Wenn der Container-Autor geöffnet ist, dürfen Anwendungen diesen nicht aufrufen oder den Status des übergeordneten Autors ändern.
Der Container-Autor übernimmt verschiedene Konfigurationseigenschaften vom übergeordneten Autor. Dabei handelt es sich um folgende Platzhalter:
- Implizite Profil-ID (ImplicitProfileId)
- Der Anwendungsdatenzeiger (AppData)
- Die Funktionszeiger „GetNewBuffer“ und „FinalizeBuffer“
Details | |||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Parameter |
|
||||||||||||||
Rückgabewerte |
|
Put
WEAVE_ERROR Put( uint64_t tag, int8_t v )
Codiert einen mit TLV signierten ganzzahligen Wert.
Dies ist eine Überlastung der Mitgliederfunktion. Er unterscheidet sich von der oben genannten Funktion nur in den akzeptierten Argumenten.
Details | |||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Parameter |
|
||||||||||||
Rückgabewerte |
|
Put
WEAVE_ERROR Put( uint64_t tag, int8_t v, bool preserveSize )
Codiert einen mit TLV signierten ganzzahligen Wert.
Dies ist eine Überlastung der Mitgliederfunktion. Er unterscheidet sich von der oben genannten Funktion nur in den akzeptierten Argumenten.
Details | |||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Parameter |
|
||||||||||||
Rückgabewerte |
|
Put
WEAVE_ERROR Put( uint64_t tag, int16_t v )
Put
WEAVE_ERROR Put( uint64_t tag, int16_t v, bool preserveSize )
Put
WEAVE_ERROR Put( uint64_t tag, int32_t v )
Put
WEAVE_ERROR Put( uint64_t tag, int32_t v, bool preserveSize )
Put
WEAVE_ERROR Put( uint64_t tag, int64_t v )
Put
WEAVE_ERROR Put( uint64_t tag, int64_t v, bool preserveSize )
Put
WEAVE_ERROR Put( uint64_t tag, uint8_t v )
Codiert einen TLV-Wert ohne Vorzeichen.
Dies ist eine Überlastung der Mitgliederfunktion. Er unterscheidet sich von der oben genannten Funktion nur in den akzeptierten Argumenten.
Details | |||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Parameter |
|
||||||||||||
Rückgabewerte |
|
Put
WEAVE_ERROR Put( uint64_t tag, uint8_t v, bool preserveSize )
Codiert einen TLV-Wert ohne Vorzeichen.
Dies ist eine Überlastung der Mitgliederfunktion. Er unterscheidet sich von der oben genannten Funktion nur in den akzeptierten Argumenten.
Details | |||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Parameter |
|
||||||||||||
Rückgabewerte |
|
Put
WEAVE_ERROR Put( uint64_t tag, uint16_t v )
Put
WEAVE_ERROR Put( uint64_t tag, uint16_t v, bool preserveSize )
Put
WEAVE_ERROR Put( uint64_t tag, uint32_t v )
Put
WEAVE_ERROR Put( uint64_t tag, uint32_t v, bool preserveSize )
Put
WEAVE_ERROR Put( uint64_t tag, uint64_t v )
Put
WEAVE_ERROR Put( uint64_t tag, uint64_t v, bool preserveSize )
Put
WEAVE_ERROR Put( uint64_t tag, float v )
Put
WEAVE_ERROR Put( uint64_t tag, double v )
Codiert einen TLV-Gleitkommawert.
Dies ist eine Überlastung der Mitgliederfunktion. Er unterscheidet sich von der oben genannten Funktion nur in den akzeptierten Argumenten.
Details | |||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Parameter |
|
||||||||||||
Rückgabewerte |
|
PutBoolean
WEAVE_ERROR PutBoolean( uint64_t tag, bool v )
Codiert einen booleschen Wert im TLV.
Details | |||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Parameter |
|
||||||||||||
Rückgabewerte |
|
PutBytes
WEAVE_ERROR PutBytes( uint64_t tag, const uint8_t *buf, uint32_t len )
Codiert einen TLV-Byte-Stringwert.
Details | |||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Parameter |
|
||||||||||||
Rückgabewerte |
|
PutNull
WEAVE_ERROR PutNull( uint64_t tag )
Codiert einen TLV-Nullwert
Details | |||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Parameter |
|
||||||||||||
Rückgabewerte |
|
PutPredcodierterContainer
WEAVE_ERROR PutPreEncodedContainer( uint64_t tag, TLVType containerType, const uint8_t *data, uint32_t dataLen )
Codiert ein TLV-Containerelement aus einem vordefinierten Satz von Mitgliedselementen.
Mit der Methode PutPreEncodingdContainer() wird ein neues TLV-Containerelement (eine Struktur, ein Array oder ein Pfad) codiert, das eine Reihe von Mitgliedselementen enthält, die aus einem vorcodierten Zwischenspeicher stammen. Der Eingabezwischenspeicher enthält voraussichtlich null oder mehr vollständig codierte TLV-Elemente mit Tags, die den Regeln entsprechen, die mit dem angegebenen Containertyp verknüpft sind. Beispiel: Strukturmitglieder müssen Tags haben, Array-Mitglieder nicht.
Mit dieser Methode wird das gesamte Containerelement in einem Aufruf codiert. Wenn PUTPreEncodingdContainer() zurückgegeben wird, kann das Schreibobjekt verwendet werden, um zusätzliche TLV-Elemente nach dem Container-Element zu schreiben.
Details | |||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Parameter |
|
||||||||||||||
Rückgabewerte |
|
PutString
WEAVE_ERROR PutString( uint64_t tag, const char *buf )
Codiert einen TL8-String-Wert vom Typ TLV
Details | |||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Parameter |
|
||||||||||||
Rückgabewerte |
|
PutString
WEAVE_ERROR PutString( uint64_t tag, const char *buf, uint32_t len )
Codiert einen TL8-String-Wert vom Typ TLV
Details | |||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Parameter |
|
||||||||||||
Rückgabewerte |
|
PutStringF
WEAVE_ERROR PutStringF( uint64_t tag, const char *fmt, ... )
Codieren Sie die Stringausgabe im Format im TLV-Element.
PutStringF ist ein Analog eines Sprints, bei dem die Ausgabe im Gegensatz zu einem Zeichenzwischenspeicher in einem TLV-Element gespeichert wird. Wenn erweiterte Printf-Funktionen verfügbar sind, kann die Funktion den Ergebnisstring in einem nicht vorhandenen zugrunde liegenden Speicher ausgeben. Die Implementierung unterstützt die folgenden Printf-Verbesserungen:
Die Plattform stellt eine Callback-basierte vcbprintf
bereit, die die Möglichkeit bietet, einen benutzerdefinierten Callback anstelle von Putchar zu verwenden.
Die Plattform stellt eine Variante von vsnprintf
mit dem Namen vsnprintf_ex
bereit, die genau wie vsnprintf funktioniert, jedoch mit der Ausnahme, dass die ersten n
Zeichen der Ausgabe weggelassen werden.
Beachten Sie, dass die Callback-basierte Funktion die einfachste sein kann und am wenigsten Code verwendet. Die vsprintf_ex
-Funktionen verbrauchen jedoch weniger Stack.
Wenn keine der oben genannten Lösungen verfügbar ist, die Plattform aber malloc
bereitstellt, weist die Funktion einen temporären Puffer zu, um die Ausgabe zu speichern. Wenn die Plattform weder die Printf-Familie noch Malloc unterstützt, wird die Ausgabe so gekürzt, dass sie in den Kontinuitätsstatus des aktuellen TLV-Speichers passt.
Details | |||||||
---|---|---|---|---|---|---|---|
Parameter |
|
||||||
Rückgabewerte |
|
Startcontainer
WEAVE_ERROR StartContainer( uint64_t tag, TLVType containerType, TLVType & outerContainerType )
Startet die Codierung eines neuen TLV-Containerelements.
Mit der Methode StartContainer() wird TLV-Container-Elemente (Struktur, Arrays oder Pfade) in eine Codierung geschrieben. Mit der Methode werden Typ und Tag des neuen Containers (sofern vorhanden) und ein Verweis auf einen TLVType-Wert angegeben. Damit wird der aktuelle Kontext des Autors gespeichert, während er zum Schreiben des Containers verwendet wird.
Sobald die StartContainer()-Methode zurückgegeben wird, sollte die Anwendung das aktuelle TLVWriter-Objekt verwenden, um die Elemente des Containers zu schreiben. Danach muss die Anwendung die Methode EndContainer() aufrufen, um die Codierung des Containers abzuschließen.
Details | |||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Parameter |
|
||||||||||||||
Rückgabewerte |
|
StartPutBytes
WEAVE_ERROR StartPutBytes( uint64_t tag, uint32_t totalLen )
Codiert einen TLV-Byte-String in mehreren Blöcken.
Sollte mit „WeiterputBytes“ verwendet werden.
Details | |||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Parameter |
|
||||||||||||
Rückgabewerte |
|
Fing StringString
WEAVE_ERROR VPutStringF( uint64_t tag, const char *fmt, va_list ap )
Codieren Sie die Stringausgabe im Format im TLV-Element.
PutStringF ist ein Analog eines Sprints, bei dem die Ausgabe im Gegensatz zu einem Zeichenzwischenspeicher in einem TLV-Element gespeichert wird. Wenn erweiterte Printf-Funktionen verfügbar sind, kann die Funktion den Ergebnisstring in einem nicht vorhandenen zugrunde liegenden Speicher ausgeben. Die Implementierung unterstützt die folgenden Printf-Verbesserungen:
Die Plattform stellt eine Callback-basierte vcbprintf
bereit, die die Möglichkeit bietet, einen benutzerdefinierten Callback anstelle von Putchar zu verwenden.
Die Plattform stellt eine Variante von vsnprintf
mit dem Namen vsnprintf_ex
bereit, die genau wie vsnprintf funktioniert, jedoch mit der Ausnahme, dass die ersten n
Zeichen der Ausgabe weggelassen werden.
Beachten Sie, dass die Callback-basierte Funktion die einfachste sein kann und am wenigsten Code verwendet. Die vsprintf_ex
-Funktionen verbrauchen jedoch weniger Stack.
Wenn keine der oben genannten Lösungen verfügbar ist, die Plattform aber malloc
bereitstellt, weist die Funktion einen temporären Puffer zu, um die Ausgabe zu speichern. Wenn die Plattform weder die Printf-Familie noch Malloc unterstützt, wird die Ausgabe so gekürzt, dass sie in den Kontinuitätsstatus des aktuellen TLV-Speichers passt.
Details | |||||||
---|---|---|---|---|---|---|---|
Parameter |
|
||||||
Rückgabewerte |
|
Öffentliche statische Funktionen
FinalizePacketBuffer
WEAVE_ERROR FinalizePacketBuffer( TLVWriter & writer, uintptr_t bufHandle, uint8_t *bufStart, uint32_t dataLen )
Implementierung eines TLVWriter FinalizeBuffers zum Schreiben in PacketBuffers
Die Funktion FinalizePacketBuffer() führt die erforderliche Finalisierung aus, die erforderlich ist, wenn ein TLVWriter verwendet wird, um in eine PacketBuffers zu schreiben. Die Funktion ist zur Verwendung in Verbindung mit der Funktion GetNewPacketBuffer() vorgesehen.
Weitere Informationen zur API der Funktion FinalizePacketBuffer() finden Sie in der Definition des FinalizeBufferFunct-Typs.
GetNewBuffer_Malloced
WEAVE_ERROR GetNewBuffer_Malloced( TLVWriter & writer, uintptr_t & bufHandle, uint8_t *& bufStart, uint32_t & bufLen )
Implementierung von GetNewBuffer TLVWriter zum Schreiben in einen dynamischen Puffer
Mit der Funktion GetNewBuffer_Malloced() wird einem TLVWriter ein neuer Ausgaberaum zur Verfügung gestellt. Damit wird die Größe des zugrunde liegenden dynamischen Zwischenspeichers verdoppelt, mit dem die Codierung gespeichert wird. Die Funktion ist so konzipiert, dass sie dem GetNewBuffer-Funktionspointer TLVWriter zugewiesen wird.
Weitere Informationen zur API der Funktion GetNewBuffer_Malloced() finden Sie in der Definition des GetNewBufferFunct-Typs.
GetNewPacketBuffer
WEAVE_ERROR GetNewPacketBuffer( TLVWriter & writer, uintptr_t & bufHandle, uint8_t *& bufStart, uint32_t & bufLen )
Implementierung von TLVWriter GetNewBuffer für das Schreiben in eine PacketBuffers.
Die Funktion GetNewPacketBuffer() stellt einem TLVWriter neuen Ausgabebereich bereit. Dafür wird eine Kette aus einem oder mehreren PacketBuffers nach Bedarf zugewiesen, um die Codierung zu speichern. Die Funktion ist so konzipiert, dass sie dem GetNewBuffer-Funktionspointer TLVWriter zugewiesen wird.
Wenn Sie „GetNewPacketBuffer“ mit einem TLVWriter verwenden, sollte die entsprechende FinalizePacketBuffer()-Funktion (oder eine Entsprechung) verwendet werden, um die Pufferkette abzuschließen.
Weitere Informationen zur API der Funktion GetNewPacketBuffer() finden Sie in der Definition des GetNewBufferFunct-Typs.
Geschützte Funktionen
IsCloseContainerReserviert
bool IsCloseContainerReserved( void ) const
Legen Sie fest, ob der Container Platz für das CloseContainer-Symbol beim Starten / Öffnen des Containers reservieren soll.
Ist ContainerOpen
bool IsContainerOpen( void ) const
SetCloseContainerReserviert
void SetCloseContainerReserved( bool aCloseContainerReserved )
Legen Sie fest, ob der Container den Bereich für das CloseContainer-Symbol zum Starten oder Öffnen des Containers reservieren soll.
SetContainerOpen
void SetContainerOpen( bool aContainerOpen )
Daten schreiben
WEAVE_ERROR WriteData( const uint8_t *p, uint32_t len )
SchreibenElementHead
WEAVE_ERROR WriteElementHead( TLVElementType elemType, uint64_t tag, uint64_t lenOrVal )
SchreibelementMitDaten
WEAVE_ERROR WriteElementWithData( TLVType type, uint64_t tag, const uint8_t *data, uint32_t dataLen )