nl :: Tejido:: TLV :: TLVReader
#include <src/lib/core/WeaveTLV.h>
Proporciona un analizador de memoria eficiente para datos codificados en formato Weave TLV .
Resumen
TLVReader implementa un analizador de "estilo pull" de solo avance para los datos de Weave TLV . El objetoTLVReader funciona como un cursor que se puede utilizar para iterar sobre una secuencia de elementos TLV e interpretar su contenido. Cuando se colocan en un elemento, las aplicaciones pueden realizar llamadas a los métodos Get () del lector para consultar el tipo y la etiqueta del elemento actual y extraer cualquier valor asociado. El método Next () del lector se utiliza para avanzar de un elemento a otro.
Un objetoTLVReader siempre se coloca antes, sobre o después de un elemento TLV . Cuando se inicializa por primera vez, unTLVReader se coloca inmediatamente antes del primer elemento de la codificación. Para comenzar a leer, una aplicación debe realizar una llamada inicial al método Next () para posicionar al lector en el primer elemento. Cuando un elemento contenedor se encuentra con una estructura, una matriz o una ruta, los métodos OpenContainer () o EnterContainer () se pueden usar para iterar a través del contenido del contenedor.
Cuando el lector llega al final de una codificación TLV , o al último elemento dentro de un contenedor, envía una señal a la aplicación devolviendo un error WEAVE_END_OF_TLV del método Next () . El lector continuará devolviendo WEAVE_END_OF_TLV hasta que se reinicialice o se salga del contenedor actual (a través de CloseContainer () / ExitContainer () ).
Un objetoTLVReader puede analizar datos directamente desde un búfer de entrada fijo o desde una cadena de uno o más PacketBuffers. Además, las aplicaciones pueden suministrar una función GetNextBuffer
para alimentar datos al lector desde una fuente arbitraria, por ejemplo, un enchufe o un puerto serie.
Herencia
Subclases conocidas directas:nl :: Weave :: Perfiles :: DataManagement_Current :: CircularEventReader
nl :: Weave :: TLV :: CircularTLVReader
Tipos públicos | |
---|---|
GetNextBufferFunct )(TLVReader &reader, uintptr_t &bufHandle, const uint8_t *&bufStart, uint32_t &bufLen) | WEAVE_ERROR (*WEAVE_ERROR (* Una función que se puede utilizar para recuperar datos TLV adicionales que se van a analizar. |
Atributos públicos | |
---|---|
AppData | void * Un campo de puntero que se puede utilizar para datos específicos de la aplicación. |
GetNextBuffer | Un puntero a una función que producirá datos de entrada para el objetoTLVReader . |
ImplicitProfileId | uint32_t El ID de perfil que se utilizará para las etiquetas de perfil codificadas de forma implícita. |
Atributos protegidos | |
---|---|
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 * |
Funciones publicas | |
---|---|
CloseContainer (TLVReader & containerReader) | Completa la lectura de un contenedor TLV después de una llamada a OpenContainer () . |
DupBytes (uint8_t *& buf, uint32_t & dataLen) | Asigna y devuelve un búfer que contiene el valor del byte actual o cadena UTF8. |
DupString (char *& buf) | Asigna y devuelve un búfer que contiene el valor terminado en nulo del byte actual o cadena UTF8. |
EnterContainer ( TLVType & outerContainerType) | |
ExitContainer ( TLVType outerContainerType) | |
Get (bool & v) | Obtiene el valor del elemento actual como un tipo bool. |
Get (int8_t & v) | Obtenga el valor del elemento actual como un entero de 8 bits con signo. |
Get (int16_t & v) | Obtenga el valor del elemento actual como un entero de 16 bits con signo. |
Get (int32_t & v) | Obtiene el valor del elemento actual como un entero de 32 bits con signo. |
Get (int64_t & v) | Obtenga el valor del elemento actual como un entero de 64 bits con signo. |
Get (uint8_t & v) | Obtenga el valor del elemento actual como un entero sin signo de 8 bits. |
Get (uint16_t & v) | Obtiene el valor del elemento actual como un entero sin signo de 16 bits. |
Get (uint32_t & v) | Obtiene el valor del elemento actual como un entero sin signo de 32 bits. |
Get (uint64_t & v) | Obtenga el valor del elemento actual como un entero sin signo de 64 bits. |
Get (float & v) | |
Get (double & v) | Obtenga el valor del elemento actual como un número de punto flotante de doble precisión. |
GetBufHandle (void) const | uintptr_t |
GetBytes (uint8_t *buf, uint32_t bufSize) | Obtiene el valor del byte actual o del elemento de cadena UTF8. |
GetContainerType (void) const | Devuelve el tipo de contenedor dentro del cualTLVReader está leyendo actualmente. |
GetControlByte (void) const | uint16_t Devuelve el byte de control asociado con el elemento TLV actual. |
GetDataPtr (const uint8_t *& data) | Obtenga un puntero al byte codificado inicial de un byte TLV o elemento de cadena UTF8. |
GetLength (void) const | uint32_t Devuelve la longitud de los datos asociados con el elemento TLV actual. |
GetLengthRead (void) const | uint32_t Devuelve el número total de bytes leídos desde que se inicializó el lector. |
GetReadPoint (void) const | const uint8_t * Obtiene el punto en el búfer de entrada subyacente que corresponde a la posición actual del lector. |
GetRemainingLength (void) const | uint32_t Devuelve el número total de bytes que se pueden leer hasta que se alcanza la longitud máxima de lectura. |
GetString (char *buf, uint32_t bufSize) | Obtiene el valor del byte actual o del elemento de cadena UTF8 como una cadena terminada en nulo. |
GetTag (void) const | uint64_t Devuelve la etiqueta asociada con el elemento TLV actual. |
GetType (void) const | Devuelve el tipo del elemento TLV actual. |
Init (constTLVReader & aReader) | void |
Init (const uint8_t *data, uint32_t dataLen) | void Inicializa un objetoTLVReader para leer desde un búfer de entrada único. |
Init ( PacketBuffer *buf, uint32_t maxLen) | void Inicializa un objetoTLVReader para leer desde un solo PacketBuffer. |
Init ( PacketBuffer *buf, uint32_t maxLen, bool allowDiscontiguousBuffers) | void Inicializa un objetoTLVReader para leer de uno o más PacketBuffers. |
Next (void) | |
Next ( TLVType expectedType, uint64_t expectedTag) | |
OpenContainer (TLVReader & containerReader) | |
Skip (void) | |
VerifyEndOfContainer (void) | Verifica que el objeto TVLReader esté al final de un contenedor TLV . |
Funciones protegidas | |
---|---|
ClearElementState (void) | void Borre el estado delTLVReader . |
ElementType (void) const | TLVElementType Este es un método privado que devuelve TLVElementType de mControlByte. |
EnsureData ( WEAVE_ERROR noDataErr) | |
GetElementHeadLength (uint8_t & elemHeadBytes) const | Este es un método privado que se utiliza para calcular la longitud de la cabeza de un elemento 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) | Omita cualquier dato contenido en el TLV actual leyéndolo sin un búfer de destino. |
SkipToEndOfContainer (void) | |
VerifyElement (void) |
Funciones estáticas protegidas | |
---|---|
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) |
Tipos públicos
GetNextBufferFunct
WEAVE_ERROR(* GetNextBufferFunct)(TLVReader &reader, uintptr_t &bufHandle, const uint8_t *&bufStart, uint32_t &bufLen)
Una función que se puede utilizar para recuperar datos TLV adicionales que se van a analizar.
Las funciones de este tipo se utilizan para alimentar datos de entrada a unTLVReader . Cuando se llama, se espera que la función produzca datos adicionales para que el lector los analice o le indique que no hay más datos disponibles.
Detalles | |||||||||
---|---|---|---|---|---|---|---|---|---|
Parámetros |
| ||||||||
Valores devueltos |
|
Atributos públicos
Datos de aplicación
void * AppData
Un campo de puntero que se puede utilizar para datos específicos de la aplicación.
GetNextBuffer
GetNextBufferFunct GetNextBuffer
Un puntero a una función que producirá datos de entrada para el objetoTLVReader .
Si se establece en NULL (el valor predeterminado), el lector asumirá que no hay más datos de entrada disponibles.
GetNextBuffer puede configurarse mediante una aplicación en cualquier momento, pero normalmente se configura cuando se inicializa el lector.
Consulte la definición de tipo GetNextBufferFunct para obtener información adicional sobre la implementación de una función GetNextBuffer.
ImplicitProfileId
uint32_t ImplicitProfileId
El ID de perfil que se utilizará para las etiquetas de perfil codificadas de forma implícita.
Cuando el lector encuentra una etiqueta específica de perfil que se ha codificado de forma implícita, utiliza el valor de la propiedad ImplicitProfileId
como el ID de perfil asumido para la etiqueta.
De forma predeterminada, la propiedad ImplicitProfileId
se establece en kProfileIdNotSpecified. Al decodificar TLV que contiene etiquetas codificadas implícitamente, las aplicaciones deben establecer ImplicitProfileId
antes de leer cualquier elemento TLV que tenga dichas etiquetas. El ID de perfil apropiado generalmente depende del contexto de la aplicación o el protocolo que se está hablando.
Si se encuentra una etiqueta codificada ImplicitProfileId
mientras ImplicitProfileId
está establecido en kProfileIdNotSpecified, el lector devolverá un error WEAVE_ERROR_UNKNOWN_IMPLICIT_TLV_TAG .
Atributos protegidos
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
Funciones publicas
CloseContainer
WEAVE_ERROR CloseContainer( TLVReader & containerReader )
Completa la lectura de un contenedor TLV después de una llamada a OpenContainer () .
El método CloseContainer () restaura el estado de un objetoTLVReader principal después de una llamada a OpenContainer () . Para cada llamada a OpenContainer (), las aplicaciones deben realizar una llamada correspondiente a CloseContainer () , pasando una referencia al mismo lector de contenedores a ambos métodos.
Cuando CloseContainer () regresa, el lector principal se coloca inmediatamente antes del primer elemento que sigue al contenedor. Desde este punto, una aplicación puede usar el método Next () para avanzar a través de los elementos restantes.
Las aplicaciones pueden llamar a close CloseContainer () en un lector principal en cualquier momento, independientemente de si se han leído todos los elementos del contenedor subyacente. Una vez que se ha llamado a CloseContainer () , la aplicación debe considerar que el lector de contenedores está 'desinicializado' y no debe usarlo más sin reinicializarlo.
Detalles | |||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Parámetros |
| ||||||||||||
Valores devueltos |
|
DupBytes
WEAVE_ERROR DupBytes( uint8_t *& buf, uint32_t & dataLen )
Asigna y devuelve un búfer que contiene el valor del byte actual o cadena UTF8.
Este método crea un búfer y devuelve una copia de los datos asociados con el byte o el elemento de cadena UTF-8 en la posición actual. La memoria para el búfer se obtiene con malloc () y la persona que llama debe liberarla con free () cuando ya no se necesite.
Detalles | |||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Parámetros |
| ||||||||||||
Valores devueltos |
|
DupString
WEAVE_ERROR DupString( char *& buf )
Asigna y devuelve un búfer que contiene el valor terminado en nulo del byte actual o cadena UTF8.
Este método crea un búfer y devuelve una copia terminada en nulo de los datos asociados con el byte o el elemento de cadena UTF-8 en la posición actual. La memoria para el búfer se obtiene con malloc () y la persona que llama debe liberarla con free () cuando ya no se necesite.
Detalles | |||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Parámetros |
| ||||||||||||
Valores devueltos |
|
Entrar Contenedor
WEAVE_ERROR EnterContainer( TLVType & outerContainerType )
Prepara un objetoTLVReader para leer los miembros del elemento contenedor TLV .
El método EnterContainer () prepara el objetoTLVReader actual para comenzar a leer los elementos miembros de un contenedor TLV (una estructura, matriz o ruta). Para cada llamada a EnterContainer (), las aplicaciones deben realizar una llamada correspondiente a ExitContainer () .
Cuando se llama a EnterContainer (), el objetoTLVReader debe colocarse en el elemento contenedor para ser leído. El método toma como argumento una referencia a un valor TLVType que se usará para guardar el contexto del lector mientras lee el contenedor.
Cuando regresa el método EnterContainer () , el lector se coloca inmediatamente antes del primer miembro del contenedor. Al llamar repetidamente a Next () , el lector avanzará a través de los miembros de la colección hasta que se alcance el final, momento en el que el lector devolverá WEAVE_END_OF_TLV.
Una vez que la aplicación ha terminado de leer un contenedor, puede continuar leyendo los elementos después del contenedor llamando al método ExitContainer () .
Detalles | |||||
---|---|---|---|---|---|
Parámetros |
| ||||
Valores devueltos |
|
ExitContainer
WEAVE_ERROR ExitContainer( TLVType outerContainerType )
Completa la lectura de un contenedor TLV y prepara un objetoTLVReader para leer elementos después del contenedor.
El método ExitContainer () restaura el estado de un objetoTLVReader después de una llamada a EnterContainer () . Para cada llamada a EnterContainer (), las aplicaciones deben realizar una llamada correspondiente a ExitContainer () , pasando el valor de contexto devuelto por el método EnterContainer () .
Cuando regresa ExitContainer () , el lector se coloca inmediatamente antes del primer elemento que sigue al contenedor. Desde este punto, una aplicación puede usar el método Next () para avanzar a través de los elementos restantes.
Una vez que se ha llamado a EnterContainer () , las aplicaciones pueden llamar a ExitContainer () en un lector en cualquier momento, independientemente de si se han leído todos los elementos del contenedor subyacente.
Detalles | |||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Parámetros |
| ||||||||||||
Valores devueltos |
|
Obtener
WEAVE_ERROR Get( bool & v )
Obtiene el valor del elemento actual como un tipo bool.
Detalles | |||||
---|---|---|---|---|---|
Parámetros |
| ||||
Valores devueltos |
|
Obtener
WEAVE_ERROR Get( int8_t & v )
Obtenga el valor del elemento actual como un entero de 8 bits con signo.
Si el valor entero codificado es mayor que el tipo de datos de salida, el valor resultante se truncará.
Detalles | |||||
---|---|---|---|---|---|
Parámetros |
| ||||
Valores devueltos |
|
Obtener
WEAVE_ERROR Get( int16_t & v )
Obtenga el valor del elemento actual como un entero de 16 bits con signo.
Si el valor entero codificado es mayor que el tipo de datos de salida, el valor resultante se truncará.
Detalles | |||||
---|---|---|---|---|---|
Parámetros |
| ||||
Valores devueltos |
|
Obtener
WEAVE_ERROR Get( int32_t & v )
Obtiene el valor del elemento actual como un entero de 32 bits con signo.
Si el valor entero codificado es mayor que el tipo de datos de salida, el valor resultante se truncará.
Detalles | |||||
---|---|---|---|---|---|
Parámetros |
| ||||
Valores devueltos |
|
Obtener
WEAVE_ERROR Get( int64_t & v )
Obtenga el valor del elemento actual como un entero de 64 bits con signo.
Si el valor entero codificado es mayor que el tipo de datos de salida, el valor resultante se truncará.
Detalles | |||||
---|---|---|---|---|---|
Parámetros |
| ||||
Valores devueltos |
|
Obtener
WEAVE_ERROR Get( uint8_t & v )
Obtenga el valor del elemento actual como un entero sin signo de 8 bits.
Si el valor entero codificado es mayor que el tipo de datos de salida, el valor resultante se truncará. De manera similar, si el valor entero codificado es negativo, el valor se convertirá a sin signo.
Detalles | |||||
---|---|---|---|---|---|
Parámetros |
| ||||
Valores devueltos |
|
Obtener
WEAVE_ERROR Get( uint16_t & v )
Obtenga el valor del elemento actual como un entero sin signo de 16 bits.
Si el valor entero codificado es mayor que el tipo de datos de salida, el valor resultante se truncará. De manera similar, si el valor entero codificado es negativo, el valor se convertirá a unsigned.
Detalles | |||||
---|---|---|---|---|---|
Parámetros |
| ||||
Valores devueltos |
|
Obtener
WEAVE_ERROR Get( uint32_t & v )
Obtiene el valor del elemento actual como un entero sin signo de 32 bits.
Si el valor entero codificado es mayor que el tipo de datos de salida, el valor resultante se truncará. De manera similar, si el valor entero codificado es negativo, el valor se convertirá a sin signo.
Detalles | |||||
---|---|---|---|---|---|
Parámetros |
| ||||
Valores devueltos |
|
Obtener
WEAVE_ERROR Get( uint64_t & v )
Obtenga el valor del elemento actual como un entero sin signo de 64 bits.
Si el valor entero codificado es negativo, el valor se convertirá a sin signo.
Detalles | |||||
---|---|---|---|---|---|
Parámetros |
| ||||
Valores devueltos |
|
Obtener
WEAVE_ERROR Get( float & v )
Obtener
WEAVE_ERROR Get( double & v )
Obtenga el valor del elemento actual como un número de punto flotante de doble precisión.
Detalles | |||||
---|---|---|---|---|---|
Parámetros |
| ||||
Valores devueltos |
|
GetBufHandle
uintptr_t GetBufHandle( void ) const
GetBytes
WEAVE_ERROR GetBytes( uint8_t *buf, uint32_t bufSize )
Obtiene el valor del byte actual o del elemento de cadena UTF8.
Para determinar el tamaño de búfer de entrada requerido, llame al método GetLength () antes de llamar a GetBytes () .
Detalles | |||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|
Parámetros |
| ||||||||||
Valores devueltos |
|
GetContainerType
TLVType GetContainerType( void ) const
Devuelve el tipo de contenedor dentro del cualTLVReader está leyendo actualmente.
El método GetContainerType () devuelve el tipo de contenedor TLV dentro del cualTLVReader está leyendo. Si elTLVReader se coloca en el nivel más externo de una codificación TLV (es decir, antes, en o después del elemento TLV más externo), el método devolverá kTLVType_NotSpecified.
Detalles | |
---|---|
Devoluciones | El TLVType del contenedor actual, o kTLVType_NotSpecified si elTLVReader no está ubicado dentro de un contenedor. |
GetControlByte
uint16_t GetControlByte( void ) const
Devuelve el byte de control asociado con el elemento TLV actual.
Idealmente, nadie necesita saber sobre el byte de control y solo la implementación interna de TLV debería tener acceso a él. Sin embargo, tener acceso al byte de control es útil para fines de depuración por parte de las utilidades de depuración de TLV (que intentan decodificar el byte de control de etiquetas cuando se imprime el contenido del búfer de TLV ).
Detalles | |
---|---|
Devoluciones | Un entero sin signo que contiene el byte de control asociado con el elemento TLV actual. kTLVControlByte_NotSpecified se devuelve si el lector no está posicionado en un elemento. |
GetDataPtr
WEAVE_ERROR GetDataPtr( const uint8_t *& data )
Obtenga un puntero al byte codificado inicial de un byte TLV o elemento de cadena UTF8.
Este método devuelve un puntero directo al valor de cadena codificado dentro del búfer de entrada subyacente. Para tener éxito, el método requiere que la totalidad del valor de la cadena esté presente en un solo búfer. De lo contrario, el método devuelve WEAVE_ERROR_TLV_UNDERRUN . Esto hace que el método sea de uso limitado al leer datos de múltiples búferes no contiguos.
Detalles | |||||||||
---|---|---|---|---|---|---|---|---|---|
Parámetros |
| ||||||||
Valores devueltos |
|
GetLength
uint32_t GetLength( void ) const
Devuelve la longitud de los datos asociados con el elemento TLV actual.
La longitud de los datos solo se aplica a elementos de tipo cadena UTF8 o cadena de bytes. Para cadenas UTF8, el valor devuelto es el número de bytes en la cadena, no el número de caracteres.
Detalles | |
---|---|
Devoluciones | La longitud (en bytes) de los datos asociados con el elemento TLV actual, o 0 si el elemento actual no es una cadena UTF8 o una cadena de bytes, o si el lector no está posicionado en un elemento. |
GetLengthRead
uint32_t GetLengthRead( void ) const
Devuelve el número total de bytes leídos desde que se inicializó el lector.
Detalles | |
---|---|
Devoluciones | Número total de bytes leídos desde que se inicializó el lector. |
GetReadPoint
const uint8_t * GetReadPoint( void ) const
Obtiene el punto en el búfer de entrada subyacente que corresponde a la posición actual del lector.
Detalles | |
---|---|
Devoluciones | Un puntero al búfer de entrada subyacente que corresponde a la posición actual del lector. |
GetRemainingLength
uint32_t GetRemainingLength( void ) const
Devuelve el número total de bytes que se pueden leer hasta que se alcanza la longitud máxima de lectura.
Detalles | |
---|---|
Devoluciones | Número total de bytes que se pueden leer hasta que se alcanza la longitud máxima de lectura. |
GetString
WEAVE_ERROR GetString( char *buf, uint32_t bufSize )
Obtiene el valor del byte actual o del elemento de cadena UTF8 como una cadena terminada en nulo.
Para determinar el tamaño de búfer de entrada requerido, llame al método GetLength () antes de llamar a GetBytes () . El búfer de entrada debe ser al menos un byte más grande que la longitud de la cadena para acomodar el carácter nulo.
Detalles | |||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|
Parámetros |
| ||||||||||
Valores devueltos |
|
GetTag
uint64_t GetTag( void ) const
Devuelve la etiqueta asociada con el elemento TLV actual.
El valor devuelto por GetTag () se puede utilizar con las funciones de la utilidad de etiqueta ( IsProfileTag () , IsContextTag () , ProfileIdFromTag () , etc.) para determinar el tipo de etiqueta y extraer varios valores de campo de etiqueta.
Detalles | |
---|---|
Devoluciones | Un número entero sin signo que contiene información sobre la etiqueta asociada con el elemento TLV actual. |
GetType
TLVType GetType( void ) const
En eso
void Init( const TLVReader & aReader )
En eso
void Init( const uint8_t *data, uint32_t dataLen )
En eso
void Init( PacketBuffer *buf, uint32_t maxLen )
Inicializa un objetoTLVReader para leer desde un solo PacketBuffer.
El análisis comienza en la posición inicial del búfer (buf-> DataStart ()) y continúa hasta el final de los datos en el búfer (como se indica mediante buf-> Datalen ()), o se han analizado los bytes maxLen.
Detalles | |||||
---|---|---|---|---|---|
Parámetros |
|
En eso
void Init( PacketBuffer *buf, uint32_t maxLen, bool allowDiscontiguousBuffers )
Inicializa un objetoTLVReader para leer de uno o más PacketBuffers.
El análisis comienza en la posición de inicio del búfer inicial (buf-> DataStart ()). Si allowDiscontiguousBuffers es verdadero, el lector avanzará a través de la cadena de búferes enlazados por sus punteros Next () . El análisis continúa hasta que se han consumido todos los datos de la cadena de búfer (como se indica mediante buf-> Datalen ()), o se han analizado los bytes maxLen.
Detalles | |||||||
---|---|---|---|---|---|---|---|
Parámetros |
|
próximo
WEAVE_ERROR Next( void )
Avanza el objetoTLVReader al siguiente elemento TLV que se leerá.
El método Next () coloca el objeto lector en el siguiente elemento de una codificación TLV que reside en el mismo contexto de contención. En particular, si el lector está ubicado en el nivel más externo de una codificación TLV , llamar a Next () hará que el lector avance al siguiente elemento superior. Si el lector está ubicado dentro de un elemento contenedor TLV (una estructura, matriz o ruta), llamar a Next () avanzará al lector al siguiente elemento miembro del contenedor.
Dado que Next () restringe el movimiento del lector al contexto de contención actual, llamar a Next () cuando el lector está posicionado en un elemento contenedor avanzará sobre el contenedor, omitiendo sus elementos miembros (y los miembros de cualquier contenedor anidado) hasta que llegue al primero elemento después del contenedor.
Cuando no hay más elementos dentro de un contexto de contención particular, el método Next () devolverá un error WEAVE_END_OF_TLV y la posición del lector permanecerá sin cambios.
Detalles | |||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Valores devueltos |
|
próximo
WEAVE_ERROR Next( TLVType expectedType, uint64_t expectedTag )
Avanza el objetoTLVReader al siguiente elemento TLV a leer, afirmando el tipo y la etiqueta del nuevo elemento.
El método Next (TLVType esperabaType, uint64_t esperabaTag) es un método de conveniencia que tiene el mismo comportamiento que Next () , pero también verifica que el tipo y la etiqueta del nuevo elemento TLV coincidan con los argumentos proporcionados.
Detalles | |||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Parámetros |
| ||||||||||||||||
Valores devueltos |
|
OpenContainer
WEAVE_ERROR OpenContainer( TLVReader & containerReader )
Inicializa un nuevo objetoTLVReader para leer los miembros de un elemento contenedor TLV .
El método OpenContainer () inicializa un nuevo objetoTLVReader para leer los elementos miembros de un contenedor TLV (una estructura, matriz o ruta). Cuando se llama a OpenContainer () , el objetoTLVReader actual debe colocarse en el elemento contenedor para ser leído. El método toma como único argumento una referencia a un nuevo lector que se inicializará para leer el contenedor. Este lector se conoce como lector de contenedor, mientras que el lector en el que se llama a OpenContainer () se conoce como lector principal .
Cuando el método OpenContainer () regresa, el lector de contenedor se coloca inmediatamente antes del primer miembro del contenedor. Llamar a Next () en el lector de contenedores avanzará a través de los miembros de la colección hasta llegar al final, momento en el que el lector devolverá WEAVE_END_OF_TLV.
Mientras el lector de contenedor está abierto, las aplicaciones no deben realizar llamadas ni alterar el estado del lector principal. Una vez que una aplicación ha terminado de usar el lector de contenedores, debe cerrarla llamando a CloseContainer () en el lector principal, pasando el lector de contenedores como argumento. Las aplicaciones pueden cerrar el lector de contenedores en cualquier momento, con o sin leer todos los elementos contenidos en el contenedor subyacente. Una vez que se cierra el lector de contenedores, las aplicaciones pueden continuar usando el lector principal.
El lector de contenedores hereda varias propiedades de configuración del lector principal. Estos son:
- El ID de perfil implícito (ImplicitProfileId)
- El puntero de datos de la aplicación (AppData)
- El puntero de la función GetNextBuffer
Details | |||||
---|---|---|---|---|---|
Parameters |
| ||||
Return Values |
|
Skip
WEAVE_ERROR Skip( void )
Advances theTLVReader object to immediately after the current TLV element.
The Skip() method positions the reader object immediately after the current TLV element, such that a subsequent call to Next() will advance the reader to the following element. Like Next() , if the reader is positioned on a container element at the time of the call, the members of the container will be skipped. If the reader is not positioned on any element, its position remains unchanged.
Details | |||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Return Values |
|
VerifyEndOfContainer
WEAVE_ERROR VerifyEndOfContainer( void )
Verifies that the TVLReader object is at the end of a TLV container.
The VerifyEndOfContainer() method verifies that there are no further TLV elements to be read within the current TLV container. This is a convenience method that is equivalent to calling Next() and checking for a return value of WEAVE_END_OF_TLV.
Details | |||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Return Values |
|
Protected functions
ClearElementState
void ClearElementState( void )
ElementType
TLVElementType ElementType( void ) const
This is a private method that returns the TLVElementType from mControlByte.
EnsureData
WEAVE_ERROR EnsureData( WEAVE_ERROR noDataErr )
GetElementHeadLength
WEAVE_ERROR GetElementHeadLength( uint8_t & elemHeadBytes ) const
This is a private method used to compute the length of a TLV element head.
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 )
Skip any data contained in the current TLV by reading over it without a destination buffer.
Details | |||||
---|---|---|---|---|---|
Return Values |
|
SkipToEndOfContainer
WEAVE_ERROR SkipToEndOfContainer( void )
VerifyElement
WEAVE_ERROR VerifyElement( void )
Protected static functions
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 )