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 extraction avant uniquement pour les données TLV Weave. L'objet TLVReader fonctionne comme un curseur qui peut être utilisé pour itérer une séquence d'éléments TLV et 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 le tag 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 objet TLVReader est positionné immédiatement avant le premier élément de l'encodage. Pour commencer la lecture, une application doit appeler la méthode Next() pour positionner le lecteur sur le premier élément. Lorsqu'un élément de conteneur est rencontré, qu'il s'agisse d'une structure, d'un tableau ou d'un chemin d'accès, les méthodes OpenContainer() ou EnterContainer() peuvent être utilisées 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 en renvoyant une erreur WEAVE_END_OF_TLV à partir de la méthode Next(). Le lecteur continuera de renvoyer WEAVE_END_OF_TLV jusqu'à ce qu'il soit réinitialisé ou 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 de plusieurs PacketBuffers. En outre, les applications peuvent fournir une fonction GetNextBuffer
pour alimenter le lecteur en données provenant 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 des données spécifiques à une application.
|
GetNextBuffer
|
Pointeur vers une fonction qui produira des données d'entrée pour l'objet TLVReader.
|
ImplicitProfileId
|
uint32_t
ID de profil à utiliser pour les tags de profil codé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)
|
Complète 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 terminée par la 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 bool.
|
Get(int8_t & v)
|
Récupère la valeur de l'élément actuel sous la forme d'un entier signé de 8 bits.
|
Get(int16_t & v)
|
Récupère la valeur de l'élément actuel sous la forme d'un entier signé de 16 bits.
|
Get(int32_t & v)
|
Récupère la valeur de l'élément actuel sous la forme d'un entier signé de 32 bits.
|
Get(int64_t & v)
|
Récupère la valeur de l'élément actuel sous la forme d'un entier signé de 64 bits.
|
Get(uint8_t & v)
|
Récupère la valeur de l'élément actuel sous la forme d'un entier non signé de 8 bits.
|
Get(uint16_t & v)
|
Récupère la valeur de l'élément actuel sous la forme d'un entier non signé de 16 bits.
|
Get(uint32_t & v)
|
Récupère la valeur de l'élément actuel sous la forme d'un entier non signé de 32 bits.
|
Get(uint64_t & v)
|
Récupère la valeur de l'élément actuel sous la forme d'un entier non signé de 64 bits.
|
Get(float & v)
|
|
Get(double & v)
|
Récupère la valeur de l'élément actuel sous forme de 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 octet ou de chaîne UTF8 actuel.
|
GetContainerType(void) const
|
Renvoie le type de conteneur dans lequel le lecteur TLVReader lit actuellement.
|
GetControlByte(void) const
|
uint16_t
Renvoie l'octet de contrôle associé à l'élément TLV actuel.
|
GetDataPtr(const uint8_t *& data)
|
Obtenez 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 du tampon d'entrée sous-jacent qui correspond à la position actuelle du lecteur.
|
GetRemainingLength(void) const
|
uint32_t
Renvoie le nombre total d'octets pouvant être lus jusqu'à ce que la longueur de lecture maximale soit atteinte.
|
GetString(char *buf, uint32_t bufSize)
|
Récupère la valeur de l'élément octet ou de chaîne 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
Elle initialise un objet TLVReader à lire à partir d'un seul tampon d'entrée.
|
Init(PacketBuffer *buf, uint32_t maxLen)
|
void
Elle initialise un objet TLVReader à lire à partir d'un seul PacketBuffer.
|
Init(PacketBuffer *buf, uint32_t maxLen, bool allowDiscontiguousBuffers)
|
void
Elle initialise un objet TLVReader à lire à partir d'un ou de 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
|
Il s'agit d'une méthode privée utilisée pour calculer la longueur de la tête d'un é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 la TLV actuelle en la 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 permettent de transmettre des données d'entrée à un lecteur TLVReader. Lorsqu'elle est appelée, la fonction doit produire des données supplémentaires que le lecteur peut analyser ou lui signaler qu'il n'y a plus de données disponibles.
Détails | |||||||||
---|---|---|---|---|---|---|---|---|---|
Paramètres |
|
||||||||
Valeurs renvoyées |
|
Attributs publics
AppData
void * AppData
Champ de pointeur pouvant être utilisé pour des données spécifiques à une application.
GetNextBuffer
GetNextBufferFunct GetNextBuffer
Pointeur vers une fonction qui produira des données d'entrée pour l'objet TLVReader.
S'il est défini 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 codé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 TLV contenant des balises implicitement encodées, les applications doivent définir ImplicitProfileId
avant de lire tout élément TLV contenant de telles balises. L'ID de profil approprié dépend généralement du contexte de l'application ou du protocole parlé.
Si une balise implicitement encodée 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 )
Complète la lecture d'un conteneur TLV après un appel à OpenContainer().
La méthode CloseContainer() restaure l'état d'un objet parent TLVReader 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 conteneur aux deux méthodes.
Lorsque CloseContainer() est renvoyé, le lecteur parent est positionné immédiatement avant le premier élément qui suit le conteneur. À ce stade, une application peut utiliser la méthode Next() pour parcourir tous les éléments restants.
Les applications peuvent appeler la méthode 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ésinitialisé". et ne doit pas l'utiliser davantage sans la réinitialiser.
Détails | |||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Paramètres |
|
||||||||||||
Valeurs renvoyées |
|
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 pour et renvoie une copie des données associées à l'élément de chaîne UTF-8 ou byte à 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 renvoyées |
|
DupString
WEAVE_ERROR DupString( char *& buf )
Alloue et renvoie un tampon contenant la valeur terminée par la valeur nulle de l'octet actuel ou de la chaîne UTF8.
Cette méthode crée un tampon pour et renvoie une copie se terminant par une valeur nulle des données associées à l'élément de chaîne UTF-8 ou byte à 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 renvoyées |
|
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 (structure, tableau ou chemin d'accès). Pour chaque appel à EnterContainer(), les applications doivent effectuer un appel correspondant à ExitContainer().
Lorsque EnterContainer() est appelé, l'objet TLVReader doit être positionné sur l'élément de 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. L'appel répété de Next() fait avancer le lecteur parmi les membres de la collection jusqu'à la fin, auquel cas le lecteur renvoie WEAVE_END_OF_TLV.
Une fois que l'application a fini de lire un conteneur, elle peut continuer à lire les éléments situés après le conteneur en appelant la méthode ExitContainer().
Détails | |||||
---|---|---|---|---|---|
Paramètres |
|
||||
Valeurs renvoyées |
|
ExitContainer
WEAVE_ERROR ExitContainer( TLVType outerContainerType )
Effectue 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 à 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. À ce stade, une application peut utiliser la méthode Next() pour parcourir tous les éléments restants.
Une fois la méthode EnterContainer() appelée, 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 renvoyées |
|
Télécharger
WEAVE_ERROR Get( bool & v )
Récupère la valeur de l'élément actuel en tant que type bool.
Détails | |||||
---|---|---|---|---|---|
Paramètres |
|
||||
Valeurs renvoyées |
|
Télécharger
WEAVE_ERROR Get( int8_t & v )
Récupère la valeur de l'élément actuel sous la forme d'un entier signé de 8 bits.
Si le nombre entier encodé est supérieur au type de données de sortie, la valeur résultante sera tronquée.
Détails | |||||
---|---|---|---|---|---|
Paramètres |
|
||||
Valeurs renvoyées |
|
Télécharger
WEAVE_ERROR Get( int16_t & v )
Récupère la valeur de l'élément actuel sous la forme d'un entier signé de 16 bits.
Si le nombre entier encodé est supérieur au type de données de sortie, la valeur résultante sera tronquée.
Détails | |||||
---|---|---|---|---|---|
Paramètres |
|
||||
Valeurs renvoyées |
|
Télécharger
WEAVE_ERROR Get( int32_t & v )
Récupère la valeur de l'élément actuel sous la forme d'un entier signé de 32 bits.
Si le nombre entier encodé est supérieur au type de données de sortie, la valeur résultante sera tronquée.
Détails | |||||
---|---|---|---|---|---|
Paramètres |
|
||||
Valeurs renvoyées |
|
Télécharger
WEAVE_ERROR Get( int64_t & v )
Récupère la valeur de l'élément actuel sous la forme d'un entier signé de 64 bits.
Si le nombre entier encodé est supérieur au type de données de sortie, la valeur résultante sera tronquée.
Détails | |||||
---|---|---|---|---|---|
Paramètres |
|
||||
Valeurs renvoyées |
|
Télécharger
WEAVE_ERROR Get( uint8_t & v )
Récupère la valeur de l'élément actuel sous la forme d'un entier non signé de 8 bits.
Si le nombre entier encodé est supérieur au type de données de sortie, la valeur résultante sera tronquée. De même, si la valeur du nombre entier encodé est négative, la valeur est convertie en valeur non signée.
Détails | |||||
---|---|---|---|---|---|
Paramètres |
|
||||
Valeurs renvoyées |
|
Télécharger
WEAVE_ERROR Get( uint16_t & v )
Récupère la valeur de l'élément actuel sous la forme d'un entier non signé de 16 bits.
Si le nombre entier encodé est supérieur au type de données de sortie, la valeur résultante sera tronquée. De même, si la valeur du nombre entier encodé est négative, la valeur est convertie en valeur non signée.
Détails | |||||
---|---|---|---|---|---|
Paramètres |
|
||||
Valeurs renvoyées |
|
Télécharger
WEAVE_ERROR Get( uint32_t & v )
Récupère la valeur de l'élément actuel sous la forme d'un entier non signé de 32 bits.
Si le nombre entier encodé est supérieur au type de données de sortie, la valeur résultante sera tronquée. De même, si la valeur du nombre entier encodé est négative, la valeur est convertie en valeur non signée.
Détails | |||||
---|---|---|---|---|---|
Paramètres |
|
||||
Valeurs renvoyées |
|
Télécharger
WEAVE_ERROR Get( uint64_t & v )
Récupère la valeur de l'élément actuel sous la forme d'un entier non signé de 64 bits.
Si la valeur du nombre entier encodé est négative, la valeur est convertie en valeur non signée.
Détails | |||||
---|---|---|---|---|---|
Paramètres |
|
||||
Valeurs renvoyées |
|
Télécharger
WEAVE_ERROR Get( float & v )
Télécharger
WEAVE_ERROR Get( double & v )
Récupère la valeur de l'élément actuel sous forme de nombre à virgule flottante à double précision.
Détails | |||||
---|---|---|---|---|---|
Paramètres |
|
||||
Valeurs renvoyées |
|
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 octet ou de chaîne 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 renvoyées |
|
GetContainerType
TLVType GetContainerType( void ) const
Renvoie le type de conteneur dans lequel le lecteur TLVReader lit actuellement.
La méthode GetContainerType() renvoie le type de conteneur TLV dans lequel TLVReader lit. 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 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 à des fins de débogage par les TLVde débogage TLV (qui tentent de décoder l'octet de contrôle des balises lors de l'impression élégante 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 positionné sur un élément.
|
GetDataPtr
WEAVE_ERROR GetDataPtr( const uint8_t *& data )
Obtenez 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 vers la valeur de la chaîne encodée dans le tampon d'entrée sous-jacent. Pour que la méthode fonctionne, l'intégralité de la valeur de la chaîne doit être présente dans un seul tampon. Sinon, la méthode renvoie WEAVE_ERROR_TLV_UNDERRUN. Cette méthode limite son utilisation lors de la lecture de données provenant de plusieurs tampons non contigus.
Détails | |||||||||
---|---|---|---|---|---|---|---|---|---|
Paramètres |
|
||||||||
Valeurs renvoyées |
|
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 correspond au nombre d'octets de la chaîne, et non au nombre de caractères.
Détails | |
---|---|
Renvoie |
Longueur (en octets) des données associées à l'élément TLV actuel, ou 0 si l'élément actuel n'est pas une chaîne ou une chaîne d'octets UTF8, 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 du tampon d'entrée sous-jacent qui correspond à la position actuelle du lecteur.
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 de lecture maximale soit atteinte.
Détails | |
---|---|
Renvoie |
Nombre total d'octets pouvant être lus jusqu'à ce que la longueur de lecture maximale soit atteinte.
|
GetString
WEAVE_ERROR GetString( char *buf, uint32_t bufSize )
Récupère la valeur de l'élément octet ou de chaîne 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 faire au moins un octet de plus que la longueur de la chaîne pour pouvoir contenir le caractère nul.
Détails | |||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|
Paramètres |
|
||||||||||
Valeurs renvoyées |
|
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 balises (IsProfileTag(), IsContextTag(), ProfileIdFromTag(), etc.) pour déterminer le type de balise et extraire diverses valeurs de champs de balise.
Détails | |
---|---|
Renvoie |
Entier non signé contenant des informations sur le tag associé à 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 )
Elle initialise un objet TLVReader à lire à partir 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 du tampon (comme indiqué par buf->Datalen()) ou jusqu'à l'analyse des octets maxLen.
Détails | |||||
---|---|---|---|---|---|
Paramètres |
|
Init
void Init( PacketBuffer *buf, uint32_t maxLen, bool allowDiscontiguousBuffers )
Elle initialise un objet TLVReader à lire à partir d'un ou de plusieurs PacketBuffers.
L'analyse commence à la position de début du tampon initial (buf->DataStart()). Si allowDiscontiguousBuffers est défini sur "true", le lecteur progresse dans la chaîne de tampons liés par ses pointeurs Next(). L'analyse se poursuit jusqu'à ce que toutes les données de la chaîne de tampon aient été utilisées (comme indiqué par buf->Datalen()) ou jusqu'à ce que maxLen octets ait été analysés.
Détails | |||||||
---|---|---|---|---|---|---|---|
Paramètres |
|
Suivant
WEAVE_ERROR Next( void )
Avance l'objet TLVReader jusqu'à l'élément TLV suivant à lire.
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 structuration. En particulier, si le lecteur est placé au niveau le plus externe d'un encodage TLV, l'appel de Next() fait passer le lecteur à l'élément suivant, en tête de liste. Si le lecteur est placé dans un élément de conteneur TLV (structure, tableau ou chemin d'accès), l'appel de Next() le fait passer à l'élément de membre suivant du conteneur.
Étant donné que Next() contraint les mouvements du lecteur au contexte actuel de structuration, l'appel de Next() lorsque le lecteur est placé sur un élément de conteneur avance au-dessus du conteneur, en ignorant ses éléments membres (et ceux des conteneurs imbriqués) jusqu'à ce qu'il atteigne le premier élément après le conteneur.
En l'absence d'autres éléments dans un contexte de structuration particulier, la méthode Next() renvoie une erreur WEAVE_END_OF_TLV et la position du lecteur reste inchangée.
Détails | |||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Valeurs renvoyées |
|
Suivant
WEAVE_ERROR Next( TLVType expectedType, uint64_t expectedTag )
Avance l'objet TLVReader jusqu'à l'élément TLV suivant à lire, en revendiquant le type et le tag du nouvel élément.
La méthode Next(TLVTypeexpectedType, uint64_texpectedTag) est une méthode pratique qui a le même comportement que Next(), mais qui vérifie également que le type et la balise du nouvel élément TLV correspondent aux arguments fournis.
Détails | |||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Paramètres |
|
||||||||||||||||
Valeurs renvoyées |
|
OpenContainer
WEAVE_ERROR OpenContainer( TLVReader & containerReader )
Elle 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 positionné sur l'élément de conteneur pour être lu. La méthode utilise comme seul argument une référence à un nouveau lecteur qui sera initialisé pour lire le conteneur. Ce lecteur est appelé lecteur de conteneur, tandis que celui sur lequel OpenContainer() est appelé est appelé lecteur parent.
Lorsque la méthode OpenContainer() est renvoyée, le lecteur de conteneur est positionné immédiatement avant le premier membre du conteneur. L'appel de Next() sur le lecteur de conteneur fera défiler les membres de la collection jusqu'à la fin, auquel cas le lecteur renverra WEAVE_END_OF_TLV.
Lorsque le lecteur de conteneur est ouvert, les applications ne doivent pas effectuer d'appels sur le lecteur parent ni modifier son état. Une fois qu'une application a fini d'utiliser le lecteur de conteneur, elle doit la fermer en appelant CloseContainer() sur le lecteur parent, en transmettant le lecteur de conteneur en tant qu'argument. Les applications peuvent fermer le lecteur de conteneurs à tout moment, avec ou sans lecture de tous les éléments du conteneur sous-jacent. Une fois le lecteur de conteneur fermé, les applications peuvent continuer à utiliser le lecteur parent.
Le lecteur de conteneur hérite de diverses propriétés de configuration du lecteur parent. Les voici :
- ID de profil implicite (ImplicitProfileId)
- Pointeur de données d'application (AppData)
- Pointeur de la fonction GetNextBuffer
Détails | |||||
---|---|---|---|---|---|
Paramètres |
|
||||
Valeurs renvoyées |
|
Ignorer
WEAVE_ERROR Skip( void )
Avance l'objet TLVReader juste après l'élément TLV actuel.
La méthode Skip() positionne l'objet lecteur 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 de conteneur au moment de l'appel, les membres du conteneur sont ignorés. Si le lecteur n'est positionné sur aucun élément, sa position reste inchangée.
Détails | |||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Valeurs renvoyées |
|
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 à rechercher une valeur renvoyée par WEAVE_END_OF_TLV.
Détails | |||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Valeurs renvoyées |
|
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
Il s'agit d'une méthode privée utilisée pour calculer la longueur de la tête d'un é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 la TLV actuelle en la lisant sans tampon de destination.
Détails | |||||
---|---|---|---|---|---|
Valeurs renvoyées |
|
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 )