nl:: Weave:: TLV:: TLVReader
#include <src/lib/core/WeaveTLV.h>
Fournit un analyseur économe en mémoire pour les données encodées au format TLV Weave.
Résumé
TLVReader implémente un analyseur de type "pull" (pull) uniquement vers l'avant pour les données TLV Weave. L'objet TLVReader fonctionne comme un curseur permettant d'itérer une séquence d'éléments TLV et d'interpréter leur contenu. Lorsqu'elles sont positionnées sur un élément, les applications peuvent appeler les méthodes Get() du lecteur pour interroger le type et la balise de l'élément actuel, et pour extraire toute valeur associée. La méthode Next() du lecteur permet de passer d'un élément à l'autre.
Un objet TLVReader est toujours positionné avant, sur ou après un élément TLV. Lors de la première initialisation, un TLVReader est placé immédiatement avant le premier élément de l'encodage. Pour commencer la lecture, une application doit effectuer un appel initial à la méthode Next() pour positionner le lecteur sur le premier élément. Lorsqu'il existe un élément conteneur avec une structure, un tableau ou un chemin d'accès, vous pouvez utiliser les méthodes OpenContainer() ou EnterContainer() pour itérer le contenu du conteneur.
Lorsque le lecteur atteint la fin d'un encodage TLV ou le dernier élément d'un conteneur, il signale à l'application une erreur WEAVE_END_OF_TLV à partir de la méthode Next(). Le lecteur continuera à renvoyer WEAVE_END_OF_TLV jusqu'à ce qu'il soit réinitialisé ou jusqu'à ce que le conteneur actuel soit fermé (via CloseContainer() / ExitContainer()).
Un objet TLVReader peut analyser des données directement à partir d'un tampon d'entrée fixe ou d'une chaîne d'un ou plusieurs PacketBuffers. De plus, les applications peuvent fournir une fonction GetNextBuffer
pour transmettre des données au lecteur à partir d'une source arbitraire, par exemple un socket ou un port série.
Héritage
Sous-classes directes connues:nl::Weave::Profiles::DataManagement_Current::CircularEventReader
nl::Weave::TLV::CircularTLVReader
Types publics |
|
---|---|
GetNextBufferFunct)(TLVReader &reader, uintptr_t &bufHandle, const uint8_t *&bufStart, uint32_t &bufLen)
|
WEAVE_ERROR(* Fonction permettant de récupérer des données TLV supplémentaires à analyser. |
Attributs publics |
|
---|---|
AppData
|
void *
Champ de pointeur pouvant être utilisé pour les données spécifiques à une application.
|
GetNextBuffer
|
Pointeur vers une fonction qui produit des données d'entrée pour l'objet TLVReader.
|
ImplicitProfileId
|
uint32_t
ID de profil à utiliser pour les tags de profil encodés sous forme implicite.
|
Attributs protégés |
|
---|---|
mBufEnd
|
const uint8_t *
|
mBufHandle
|
uintptr_t
|
mContainerType
|
|
mControlByte
|
uint16_t
|
mElemLenOrVal
|
uint64_t
|
mElemTag
|
uint64_t
|
mLenRead
|
uint32_t
|
mMaxLen
|
uint32_t
|
mReadPoint
|
const uint8_t *
|
Fonctions publiques |
|
---|---|
CloseContainer(TLVReader & containerReader)
|
Termine la lecture d'un conteneur TLV après un appel à OpenContainer().
|
DupBytes(uint8_t *& buf, uint32_t & dataLen)
|
Alloue et renvoie un tampon contenant la valeur de l'octet actuel ou de la chaîne UTF8.
|
DupString(char *& buf)
|
Alloue et renvoie un tampon contenant la valeur se terminant par une valeur nulle de l'octet actuel ou de la chaîne UTF8.
|
EnterContainer(TLVType & outerContainerType)
|
|
ExitContainer(TLVType outerContainerType)
|
|
Get(bool & v)
|
Récupère la valeur de l'élément actuel en tant que type de valeur booléenne.
|
Get(int8_t & v)
|
Obtenir la valeur de l'élément actuel sous la forme d'un entier signé de 8 bits
|
Get(int16_t & v)
|
Obtenir la valeur de l'élément actuel sous la forme d'un entier signé de 16 bits
|
Get(int32_t & v)
|
Obtenir la valeur de l'élément actuel sous la forme d'un entier signé de 32 bits
|
Get(int64_t & v)
|
Obtenir la valeur de l'élément actuel sous la forme d'un entier signé de 64 bits
|
Get(uint8_t & v)
|
Obtenir la valeur de l'élément actuel sous la forme d'un entier non signé de 8 bits
|
Get(uint16_t & v)
|
Obtenir la valeur de l'élément actuel sous la forme d'un entier non signé de 16 bits
|
Get(uint32_t & v)
|
Obtenir la valeur de l'élément actuel sous la forme d'un entier non signé de 32 bits
|
Get(uint64_t & v)
|
Obtenir la valeur de l'élément actuel sous la forme d'un entier non signé de 64 bits
|
Get(float & v)
|
|
Get(double & v)
|
Obtenir la valeur de l'élément actuel sous la forme d'un nombre à virgule flottante à double précision
|
GetBufHandle(void) const
|
uintptr_t
|
GetBytes(uint8_t *buf, uint32_t bufSize)
|
Récupère la valeur de l'élément de chaîne byte ou UTF8 actuel.
|
GetContainerType(void) const
|
Renvoie le type de conteneur dans lequel TLVReader est en cours de lecture.
|
GetControlByte(void) const
|
uint16_t
Renvoie l'octet de contrôle associé à l'élément TLV actuel.
|
GetDataPtr(const uint8_t *& data)
|
Renvoie un pointeur vers l'octet encodé initial d'un octet TLV ou d'un élément de chaîne UTF8.
|
GetLength(void) const
|
uint32_t
Renvoie la longueur des données associées à l'élément TLV actuel.
|
GetLengthRead(void) const
|
uint32_t
Renvoie le nombre total d'octets lus depuis l'initialisation du lecteur.
|
GetReadPoint(void) const
|
const uint8_t *
Récupère le point correspondant à la position actuelle du lecteur dans le tampon d'entrée sous-jacent.
|
GetRemainingLength(void) const
|
uint32_t
Renvoie le nombre total d'octets pouvant être lus jusqu'à ce que la longueur maximale en lecture soit atteinte.
|
GetString(char *buf, uint32_t bufSize)
|
Récupère la valeur de l'élément de chaîne byte ou UTF8 actuel en tant que chaîne se terminant par une valeur nulle.
|
GetTag(void) const
|
uint64_t
Renvoie la balise associée à l'élément TLV actuel.
|
GetType(void) const
|
Renvoie le type de l'élément TLV actuel.
|
Init(const TLVReader & aReader)
|
void
|
Init(const uint8_t *data, uint32_t dataLen)
|
void
Initialise un objet TLVReader pour qu'il puisse lire un tampon d'entrée unique.
|
Init(PacketBuffer *buf, uint32_t maxLen)
|
void
Initialise un objet TLVReader pour la lecture d'un seul PacketBuffer.
|
Init(PacketBuffer *buf, uint32_t maxLen, bool allowDiscontiguousBuffers)
|
void
Initialise un objet TLVReader pour lire un ou plusieurs PacketBuffers.
|
Next(void)
|
|
Next(TLVType expectedType, uint64_t expectedTag)
|
|
OpenContainer(TLVReader & containerReader)
|
|
Skip(void)
|
|
VerifyEndOfContainer(void)
|
Vérifie que l'objet TVLReader se trouve à la fin d'un conteneur TLV.
|
Fonctions protégées |
|
---|---|
ClearElementState(void)
|
void
Effacez l'état de TLVReader.
|
ElementType(void) const
|
TLVElementType
Il s'agit d'une méthode privée qui renvoie le TLVElementType à partir de mControlByte.
|
EnsureData(WEAVE_ERROR noDataErr)
|
|
GetElementHeadLength(uint8_t & elemHeadBytes) const
|
Cette méthode privée permet de calculer la longueur d'une tête d'élément TLV.
|
IsContainerOpen(void) const
|
bool
|
ReadData(uint8_t *buf, uint32_t len)
|
|
ReadElement(void)
|
|
ReadTag(TLVTagControl tagControl, const uint8_t *& p)
|
uint64_t
|
SetContainerOpen(bool aContainerOpen)
|
void
|
SkipData(void)
|
Ignorez toutes les données contenues dans le TLV actuel en les lisant sans tampon de destination.
|
SkipToEndOfContainer(void)
|
|
VerifyElement(void)
|
Fonctions statiques protégées |
|
---|---|
FailGetNextBuffer(TLVReader & reader, uintptr_t & bufHandle, const uint8_t *& bufStart, uint32_t & bufLen)
|
|
GetNextPacketBuffer(TLVReader & reader, uintptr_t & bufHandle, const uint8_t *& bufStart, uint32_t & bufLen)
|
Types publics
GetNextBufferFunct
WEAVE_ERROR(* GetNextBufferFunct)(TLVReader &reader, uintptr_t &bufHandle, const uint8_t *&bufStart, uint32_t &bufLen)
Fonction permettant de récupérer des données TLV supplémentaires à analyser.
Les fonctions de ce type sont utilisées pour transmettre des données d'entrée à un TLVReader. Lorsqu'elle est appelée, la fonction est censée produire des données supplémentaires que le lecteur doit analyser ou lui signaler qu'aucune donnée n'est disponible.
Détails | |||||||||
---|---|---|---|---|---|---|---|---|---|
Paramètres |
|
||||||||
Valeurs de retour |
|
Attributs publics
AppData
void * AppData
Champ de pointeur pouvant être utilisé pour les données spécifiques à une application.
GetNextBuffer
GetNextBufferFunct GetNextBuffer
Pointeur vers une fonction qui produit des données d'entrée pour l'objet TLVReader.
Si elle est définie sur NULL (valeur par défaut), le lecteur suppose qu'aucune autre donnée d'entrée n'est disponible.
GetNextBuffer peut être défini à tout moment par une application, mais il est généralement défini lorsque le lecteur est initialisé.
Consultez la définition du type GetNextBufferFunct pour en savoir plus sur l'implémentation d'une fonction GetNextBuffer.
ImplicitProfileId
uint32_t ImplicitProfileId
ID de profil à utiliser pour les tags de profil encodés sous forme implicite.
Lorsque le lecteur rencontre une balise spécifique au profil encodée sous forme implicite, il utilise la valeur de la propriété ImplicitProfileId
comme ID de profil supposé pour la balise.
Par défaut, la propriété ImplicitProfileId
est définie sur kProfileIdNotSpecified. Lors du décodage de la valeur TLV qui contient des balises implicitement encodées, les applications doivent définir ImplicitProfileId
avant de lire les éléments TLV comportant ces balises. L'ID de profil approprié dépend généralement du contexte de l'application ou du protocole parlé.
Si une balise encodée implicitement est détectée alors que ImplicitProfileId
est défini sur kProfileIdNotSpecified, le lecteur renvoie une erreur WEAVE_ERROR_UNKNOWN_IMPLICIT_TLV_TAG.
Attributs protégés
mBufEnd
const uint8_t * mBufEnd
mBufHandle
uintptr_t mBufHandle
mContainerType
TLVType mContainerType
mControlByte
uint16_t mControlByte
mElemLenOrVal
uint64_t mElemLenOrVal
mElemTag
uint64_t mElemTag
mLenRead
uint32_t mLenRead
mMaxLen
uint32_t mMaxLen
mReadPoint
const uint8_t * mReadPoint
Fonctions publiques
CloseContainer
WEAVE_ERROR CloseContainer( TLVReader & containerReader )
Termine la lecture d'un conteneur TLV après un appel à OpenContainer().
La méthode CloseContainer() restaure l'état d'un objet TLVReader parent après un appel à OpenContainer(). Pour chaque appel à OpenContainer(), les applications doivent effectuer un appel correspondant à CloseContainer(), en transmettant une référence au même lecteur de conteneurs aux deux méthodes.
Lorsque CloseContainer() est renvoyé, le lecteur parent est placé immédiatement avant le premier élément qui suit le conteneur. L'application peut alors utiliser la méthode Next() pour passer d'un élément à l'autre.
Les applications peuvent appeler la fonction Close CloseContainer() sur un lecteur parent à tout moment, que tous les éléments du conteneur sous-jacent aient été lus ou non. Une fois que CloseContainer() a été appelé, l'application doit considérer le lecteur de conteneur comme étant "déinitialisé" et ne doit pas l'utiliser davantage sans le réinitialiser.
Détails | |||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Paramètres |
|
||||||||||||
Valeurs de retour |
|
DupBytes
WEAVE_ERROR DupBytes( uint8_t *& buf, uint32_t & dataLen )
Alloue et renvoie un tampon contenant la valeur de l'octet actuel ou de la chaîne UTF8.
Cette méthode crée un tampon et renvoie une copie des données associées à l'élément de chaîne byte ou UTF-8 à la position actuelle. La mémoire du tampon est obtenue avec malloc() et doit être libérée avec free() par l'appelant lorsqu'elle n'est plus nécessaire.
Détails | |||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Paramètres |
|
||||||||||||
Valeurs de retour |
|
DupString
WEAVE_ERROR DupString( char *& buf )
Alloue et renvoie un tampon contenant la valeur se terminant par une valeur nulle de l'octet actuel ou de la chaîne UTF8.
Cette méthode crée un tampon et renvoie une copie se terminant par une valeur nulle des données associées à l'élément de chaîne byte ou UTF-8 à la position actuelle. La mémoire du tampon est obtenue avec malloc() et doit être libérée avec free() par l'appelant lorsqu'elle n'est plus nécessaire.
Détails | |||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Paramètres |
|
||||||||||||
Valeurs de retour |
|
EnterContainer
WEAVE_ERROR EnterContainer( TLVType & outerContainerType )
Prépare un objet TLVReader pour lire les membres de l'élément de conteneur TLV.
La méthode EnterContainer() prépare l'objet TLVReader actuel pour commencer à lire les éléments membres d'un conteneur TLV (une structure, un tableau ou un chemin d'accès). Pour chaque appel de la méthode EnterContainer(), les applications doivent effectuer un appel correspondant à ExitContainer().
Lorsque EnterContainer() est appelé, l'objet TLVReader doit être placé sur l'élément conteneur pour être lu. La méthode utilise comme argument une référence à une valeur TLVType qui sera utilisée pour enregistrer le contexte du lecteur pendant la lecture du conteneur.
Lorsque la méthode EnterContainer() est renvoyée, le lecteur est positionné immédiatement avant le premier membre du conteneur. Si vous appelez la fonction Next() de façon répétée, le lecteur fera défiler les membres de la collection jusqu'à la fin. Le lecteur renverra alors WEAVE_END_OF_TLV.
Une fois que l'application a terminé la lecture d'un conteneur, elle peut continuer à lire les éléments après celui-ci en appelant la méthode ExitContainer().
Détails | |||||
---|---|---|---|---|---|
Paramètres |
|
||||
Valeurs de retour |
|
ExitContainer
WEAVE_ERROR ExitContainer( TLVType outerContainerType )
Termine la lecture d'un conteneur TLV et prépare un objet TLVReader pour lire les éléments après le conteneur.
La méthode ExitContainer() restaure l'état d'un objet TLVReader après un appel à EnterContainer(). Pour chaque appel de EnterContainer(), les applications doivent effectuer un appel correspondant à ExitContainer(), en transmettant la valeur de contexte renvoyée par la méthode EnterContainer().
Lorsque ExitContainer() est renvoyé, le lecteur est positionné immédiatement avant le premier élément qui suit le conteneur. L'application peut alors utiliser la méthode Next() pour passer d'un élément à l'autre.
Une fois EnterContainer() appelé, les applications peuvent appeler ExitContainer() sur un lecteur à tout moment, que tous les éléments du conteneur sous-jacent aient été lus ou non.
Détails | |||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Paramètres |
|
||||||||||||
Valeurs de retour |
|
Télécharger
WEAVE_ERROR Get( bool & v )
Récupère la valeur de l'élément actuel en tant que type de valeur booléenne.
Détails | |||||
---|---|---|---|---|---|
Paramètres |
|
||||
Valeurs de retour |
|
Télécharger
WEAVE_ERROR Get( int8_t & v )
Obtenir la valeur de l'élément actuel sous la forme d'un entier signé de 8 bits
Si la valeur entière encodée est supérieure au type de données de sortie, la valeur obtenue sera tronquée.
Détails | |||||
---|---|---|---|---|---|
Paramètres |
|
||||
Valeurs de retour |
|
Télécharger
WEAVE_ERROR Get( int16_t & v )
Obtenir la valeur de l'élément actuel sous la forme d'un entier signé de 16 bits
Si la valeur entière encodée est supérieure au type de données de sortie, la valeur obtenue sera tronquée.
Détails | |||||
---|---|---|---|---|---|
Paramètres |
|
||||
Valeurs de retour |
|
Télécharger
WEAVE_ERROR Get( int32_t & v )
Obtenir la valeur de l'élément actuel sous la forme d'un entier signé de 32 bits
Si la valeur entière encodée est supérieure au type de données de sortie, la valeur obtenue sera tronquée.
Détails | |||||
---|---|---|---|---|---|
Paramètres |
|
||||
Valeurs de retour |
|
Télécharger
WEAVE_ERROR Get( int64_t & v )
Obtenir la valeur de l'élément actuel sous la forme d'un entier signé de 64 bits
Si la valeur entière encodée est supérieure au type de données de sortie, la valeur obtenue sera tronquée.
Détails | |||||
---|---|---|---|---|---|
Paramètres |
|
||||
Valeurs de retour |
|
Télécharger
WEAVE_ERROR Get( uint8_t & v )
Obtenir la valeur de l'élément actuel sous la forme d'un entier non signé de 8 bits
Si la valeur entière encodée est supérieure au type de données de sortie, la valeur obtenue sera tronquée. De même, si le nombre entier encodé est négatif, la valeur sera convertie en valeur non signée.
Détails | |||||
---|---|---|---|---|---|
Paramètres |
|
||||
Valeurs de retour |
|
Télécharger
WEAVE_ERROR Get( uint16_t & v )
Obtenir la valeur de l'élément actuel sous la forme d'un entier non signé de 16 bits
Si la valeur entière encodée est supérieure au type de données de sortie, la valeur obtenue sera tronquée. De même, si le nombre entier encodé est négatif, la valeur sera convertie en valeur non signée.
Détails | |||||
---|---|---|---|---|---|
Paramètres |
|
||||
Valeurs de retour |
|
Télécharger
WEAVE_ERROR Get( uint32_t & v )
Obtenir la valeur de l'élément actuel sous la forme d'un entier non signé de 32 bits
Si la valeur entière encodée est supérieure au type de données de sortie, la valeur obtenue sera tronquée. De même, si le nombre entier encodé est négatif, la valeur sera convertie en valeur non signée.
Détails | |||||
---|---|---|---|---|---|
Paramètres |
|
||||
Valeurs de retour |
|
Télécharger
WEAVE_ERROR Get( uint64_t & v )
Obtenir la valeur de l'élément actuel sous la forme d'un entier non signé de 64 bits
Si la valeur entière encodée est négative, la valeur sera convertie en valeur non signée.
Détails | |||||
---|---|---|---|---|---|
Paramètres |
|
||||
Valeurs de retour |
|
Télécharger
WEAVE_ERROR Get( float & v )
Télécharger
WEAVE_ERROR Get( double & v )
Obtenir la valeur de l'élément actuel sous la forme d'un nombre à virgule flottante à double précision
Détails | |||||
---|---|---|---|---|---|
Paramètres |
|
||||
Valeurs de retour |
|
GetBufHandle
uintptr_t GetBufHandle( void ) const
GetBytes
WEAVE_ERROR GetBytes( uint8_t *buf, uint32_t bufSize )
Récupère la valeur de l'élément de chaîne byte ou UTF8 actuel.
Pour déterminer la taille de la mémoire tampon d'entrée requise, appelez la méthode GetLength() avant d'appeler GetBytes().
Détails | |||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|
Paramètres |
|
||||||||||
Valeurs de retour |
|
GetContainerType
TLVType GetContainerType( void ) const
Renvoie le type de conteneur dans lequel TLVReader est en cours de lecture.
La méthode GetContainerType() renvoie le type du conteneur TLV dans lequel le TLVReader lit des données. Si TLVReader est positionné au niveau le plus externe d'un encodage TLV (c'est-à-dire avant, sur ou après l'élément TLV le plus externe), la méthode renvoie kTLVType_NotSpecified.
Détails | |
---|---|
Renvoie |
TLVType du conteneur actuel, ou kTLVType_NotSpecified si le TLVReader n'est pas placé dans un conteneur.
|
GetControlByte
uint16_t GetControlByte( void ) const
Renvoie l'octet de contrôle associé à l'élément TLV actuel.
Dans l'idéal, personne n'a besoin de connaître l'octet de contrôle, et seule l'implémentation interne de TLV doit y avoir accès. Néanmoins, l'accès à l'octet de contrôle est utile pour le débogage par les utilitaires de débogage TLV (qui tentent de décoder l'octet de contrôle des balises lors de l'impression correcte du contenu de la mémoire tampon TLV).
Détails | |
---|---|
Renvoie |
Entier non signé contenant l'octet de contrôle associé à l'élément TLV actuel. kTLVControlByte_NotSpecified est renvoyé si le lecteur n'est pas placé sur un élément.
|
GetDataPtr
WEAVE_ERROR GetDataPtr( const uint8_t *& data )
Renvoie un pointeur vers l'octet encodé initial d'un octet TLV ou d'un élément de chaîne UTF8.
Cette méthode renvoie un pointeur direct sur la valeur de chaîne encodée dans le tampon d'entrée sous-jacent. Pour réussir, la méthode nécessite que l'intégralité de la valeur de la chaîne soit présente dans un seul tampon. Sinon, la méthode renvoie WEAVE_ERROR_TLV_UNDERRUN. Cela permet de limiter l'utilisation de cette méthode lors de la lecture de données provenant de plusieurs tampons non contigus.
Détails | |||||||||
---|---|---|---|---|---|---|---|---|---|
Paramètres |
|
||||||||
Valeurs de retour |
|
GetLength
uint32_t GetLength( void ) const
Renvoie la longueur des données associées à l'élément TLV actuel.
La longueur des données ne s'applique qu'aux éléments de type chaîne UTF8 ou chaîne d'octets. Pour les chaînes UTF8, la valeur renvoyée est le nombre d'octets de la chaîne et non le nombre de caractères.
Détails | |
---|---|
Renvoie |
Longueur (en octets) des données associées à l'élément TLV actuel, ou valeur 0 si l'élément actuel n'est pas une chaîne UTF8 ou une chaîne d'octets, ou si le lecteur n'est pas positionné sur un élément.
|
GetLengthRead
uint32_t GetLengthRead( void ) const
Renvoie le nombre total d'octets lus depuis l'initialisation du lecteur.
Détails | |
---|---|
Renvoie |
Nombre total d'octets lus depuis l'initialisation du lecteur.
|
GetReadPoint
const uint8_t * GetReadPoint( void ) const
Récupère le point correspondant à la position actuelle du lecteur dans le tampon d'entrée sous-jacent.
Détails | |
---|---|
Renvoie |
Pointeur dans le tampon d'entrée sous-jacent qui correspond à la position actuelle du lecteur.
|
GetRemainingLength
uint32_t GetRemainingLength( void ) const
Renvoie le nombre total d'octets pouvant être lus jusqu'à ce que la longueur maximale en lecture soit atteinte.
Détails | |
---|---|
Renvoie |
Nombre total d'octets pouvant être lus jusqu'à ce que la longueur maximale en lecture soit atteinte.
|
GetString
WEAVE_ERROR GetString( char *buf, uint32_t bufSize )
Récupère la valeur de l'élément de chaîne byte ou UTF8 actuel en tant que chaîne se terminant par une valeur nulle.
Pour déterminer la taille de la mémoire tampon d'entrée requise, appelez la méthode GetLength() avant d'appeler GetBytes(). Le tampon d'entrée doit avoir une taille supérieure d'au moins un octet à la longueur de la chaîne pour accueillir le caractère nul.
Détails | |||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|
Paramètres |
|
||||||||||
Valeurs de retour |
|
GetTag
uint64_t GetTag( void ) const
Renvoie la balise associée à l'élément TLV actuel.
La valeur renvoyée par GetTag() peut être utilisée avec les fonctions utilitaires de balise (IsProfileTag(), IsContextTag(), ProfileIdFromTag(), etc.) pour déterminer le type de balise et extraire différentes valeurs de champ de tag.
Détails | |
---|---|
Renvoie |
Entier non signé contenant des informations sur la balise associée à l'élément TLV actuel.
|
GetType
TLVType GetType( void ) const
Init
void Init( const TLVReader & aReader )
Init
void Init( const uint8_t *data, uint32_t dataLen )
Init
void Init( PacketBuffer *buf, uint32_t maxLen )
Initialise un objet TLVReader pour la lecture d'un seul PacketBuffer.
L'analyse commence à la position de départ du tampon (buf->DataStart()) et se poursuit jusqu'à la fin des données dans le tampon (comme indiqué par buf->Datalen()), ou le nombre maxLen octets a été analysé.
Détails | |||||
---|---|---|---|---|---|
Paramètres |
|
Init
void Init( PacketBuffer *buf, uint32_t maxLen, bool allowDiscontiguousBuffers )
Initialise un objet TLVReader pour lire un ou plusieurs PacketBuffers.
L'analyse commence à la position de départ du tampon initial (buf->DataStart()). Si allowDiscontiguousBuffers est défini sur "true", le lecteur avance dans la chaîne de tampons liées par leurs pointeurs Next(). L'analyse se poursuit jusqu'à ce que toutes les données de la chaîne de tampon aient été consommées (comme indiqué par buf->Datalen()) ou que le nombre d'octets maxLen ait été analysé.
Détails | |||||||
---|---|---|---|---|---|---|---|
Paramètres |
|
Suivant
WEAVE_ERROR Next( void )
Passe l'objet TLVReader au niveau de l'élément TLV à lire suivant.
La méthode Next() positionne l'objet lecteur sur l'élément suivant dans un encodage TLV qui se trouve dans le même contexte de confinement. En particulier, si le lecteur est positionné au niveau le plus externe d'un encodage TLV, l'appel de Next() le fera passer à l'élément supérieur le plus proche. Si le lecteur est placé dans un élément de conteneur TLV (une structure, un tableau ou un chemin), l'appel de Next() le fera passer à l'élément membre suivant du conteneur.
Étant donné que Next() limite le mouvement du lecteur au contexte de confinement actuel, appeler Next() lorsque le lecteur est positionné sur un élément conteneur fait avancer sur le conteneur, en ignorant ses éléments membres (et les membres de tout conteneur imbriqué) jusqu'à ce qu'il atteigne le premier élément après le conteneur.
Lorsqu'il n'y a plus d'éléments dans un contexte de confinement particulier, la méthode Next() renvoie une erreur WEAVE_END_OF_TLV et la position du lecteur reste inchangée.
Détails | |||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Valeurs de retour |
|
Suivant
WEAVE_ERROR Next( TLVType expectedType, uint64_t expectedTag )
Passe l'objet TLVReader à l'élément TLV suivant à lire, en revendiquant le type et la balise du nouvel élément.
La méthode Next(TLVTypeexpectedType, uint64_texpectedTag) a le même comportement que Next(), mais vérifie également que le type et la balise du nouvel élément TLV correspondent aux arguments fournis.
Détails | |||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Paramètres |
|
||||||||||||||||
Valeurs de retour |
|
OpenContainer
WEAVE_ERROR OpenContainer( TLVReader & containerReader )
Initialise un nouvel objet TLVReader pour lire les membres d'un élément de conteneur TLV.
La méthode OpenContainer() initialise un nouvel objet TLVReader pour lire les éléments membres d'un conteneur TLV (structure, tableau ou chemin d'accès). Lorsque OpenContainer() est appelé, l'objet TLVReader actuel doit être placé sur l'élément conteneur pour être lu. La méthode utilise comme unique argument une référence à un nouveau lecteur qui sera initialisé pour lire le conteneur. Ce lecteur est appelé lecteur de conteneurs, tandis que le lecteur utilisé pour appeler OpenContainer() est appelé lecteur parent.
Lorsque la méthode OpenContainer() est renvoyée, le lecteur de conteneurs est placé immédiatement avant le premier membre du conteneur. L'appel de Next() sur le lecteur de conteneurs fait défiler les membres de la collection jusqu'à la fin. Le lecteur renvoie alors WEAVE_END_OF_TLV.
Lorsque le lecteur de conteneurs est ouvert, les applications ne doivent pas effectuer d'appels ni modifier l'état du lecteur parent. Une fois qu'une application a fini d'utiliser le lecteur de conteneurs, elle doit la fermer en appelant CloseContainer() sur le lecteur parent et en transmettant le lecteur de conteneurs en tant qu'argument. Les applications peuvent fermer le lecteur de conteneur à tout moment, avec ou sans lecture de tous les éléments contenus dans le conteneur sous-jacent. Une fois le lecteur de conteneurs fermé, les applications peuvent continuer à utiliser le lecteur parent.
Le lecteur de conteneurs hérite des diverses propriétés de configuration du lecteur parent. Les voici :
- ID de profil implicite (ImplicitProfileId)
- Pointeur de données de l'application (AppData)
- Pointeur de la fonction GetNextBuffer
Détails | |||||
---|---|---|---|---|---|
Paramètres |
|
||||
Valeurs de retour |
|
Ignorer
WEAVE_ERROR Skip( void )
fait avancer l'objet TLVReader juste après l'élément TLV actuel.
La méthode Skip() positionne l'objet "Lecteur" immédiatement après l'élément TLV actuel, de sorte qu'un appel ultérieur à Next() fera avancer le lecteur vers l'élément suivant. Comme pour Next(), si le lecteur est placé sur un élément conteneur au moment de l'appel, les membres du conteneur seront ignorés. Si le lecteur n'est positionné sur aucun élément, sa position reste inchangée.
Détails | |||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Valeurs de retour |
|
VerifyEndOfContainer
WEAVE_ERROR VerifyEndOfContainer( void )
Vérifie que l'objet TVLReader se trouve à la fin d'un conteneur TLV.
La méthode VerifyEndOfContainer() vérifie qu'il n'y a plus d'autres éléments TLV à lire dans le conteneur TLV actuel. Cette méthode pratique équivaut à appeler Next() et à vérifier la valeur renvoyée WEAVE_END_OF_TLV.
Détails | |||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Valeurs de retour |
|
Fonctions protégées
ClearElementState
void ClearElementState( void )
ElementType
TLVElementType ElementType( void ) const
Il s'agit d'une méthode privée qui renvoie le TLVElementType à partir de mControlByte.
EnsureData
WEAVE_ERROR EnsureData( WEAVE_ERROR noDataErr )
GetElementHeadLength
WEAVE_ERROR GetElementHeadLength( uint8_t & elemHeadBytes ) const
Cette méthode privée permet de calculer la longueur d'une tête d'élément TLV.
IsContainerOpen
bool IsContainerOpen( void ) const
ReadData
WEAVE_ERROR ReadData( uint8_t *buf, uint32_t len )
ReadElement
WEAVE_ERROR ReadElement( void )
ReadTag
uint64_t ReadTag( TLVTagControl tagControl, const uint8_t *& p )
SetContainerOpen
void SetContainerOpen( bool aContainerOpen )
SkipData
WEAVE_ERROR SkipData( void )
Ignorez toutes les données contenues dans le TLV actuel en les lisant sans tampon de destination.
Détails | |||||
---|---|---|---|---|---|
Valeurs de retour |
|
SkipToEndOfContainer
WEAVE_ERROR SkipToEndOfContainer( void )
VerifyElement
WEAVE_ERROR VerifyElement( void )
Fonctions statiques protégées
FailGetNextBuffer
WEAVE_ERROR FailGetNextBuffer( TLVReader & reader, uintptr_t & bufHandle, const uint8_t *& bufStart, uint32_t & bufLen )
GetNextPacketBuffer
WEAVE_ERROR GetNextPacketBuffer( TLVReader & reader, uintptr_t & bufHandle, const uint8_t *& bufStart, uint32_t & bufLen )