HF::Core::GroupTable::ReadEntriesResponse Struct Reference

This class the response for a GroupTable::READ_ENTRIES_CMD command. More...

#include <group_table.h>

Inheritance diagram for HF::Core::GroupTable::ReadEntriesResponse:

Collaboration diagram for HF::Core::GroupTable::ReadEntriesResponse:

Public Member Functions
	ReadEntriesResponse (Common::Result _code=Common::Result::OK, uint8_t _start=0, uint8_t _count=0)
	Constructor. More...
uint16_t	size () const
	Number bytes needed to serialize the message. More...
uint16_t	pack (Common::ByteArray &array, uint16_t offset=0) const
	Write the object on to a ByteArray so it can be sent over the network. More...
uint16_t	unpack (const Common::ByteArray &array, uint16_t offset=0)
	Read a message from a ByteArray. More...
Public Member Functions inherited from HF::Protocol::Response
uint16_t	size () const
	Number bytes needed to serialize the message. More...
uint16_t	pack (Common::ByteArray &array, uint16_t offset=0) const
	Write the object on to a ByteArray so it can be sent over the network. More...
uint16_t	unpack (const Common::ByteArray &array, uint16_t offset=0)
	Read a message from a ByteArray. More...

Data Fields
uint8_t	start
	Offset to start reading entries from. More...
std::vector< Entry >	entries
	Vector containing the entries in the response. More...

Static Public Attributes
static constexpr uint16_t	min_size
	Minimum required data size for pack/unpack.
Static Public Attributes inherited from HF::Protocol::Response
static constexpr uint16_t	min_size = sizeof(uint8_t)
	Minimum number of bytes required by this message.

Detailed Description

This class the response for a GroupTable::READ_ENTRIES_CMD command.

Definition at line 270 of file group_table.h.

Constructor & Destructor Documentation

ReadEntriesResponse()

HF::Core::GroupTable::ReadEntriesResponse::ReadEntriesResponse ( Common::Result  _code = Common::Result::OK, uint8_t  _start = 0, uint8_t  _count = 0  )

inline

Constructor.

Parameters

[in]	_code	the response code for the response.
[in]	_start	the offset for the entries in the response.
[in]	_count	number of entries this response will contain.

Definition at line 283 of file group_table.h.

References entries.

                                                                       :
               Protocol::Response(_code), start(_start)
            {
               entries.reserve(_count);
            }

Member Function Documentation

pack()

uint16_t HF::Core::GroupTable::ReadEntriesResponse::pack ( Common::ByteArray &  array, uint16_t  offset = 0  ) const

inline

Write the object on to a ByteArray so it can be sent over the network.

The buffer passed in MUST have enough size to hold the serialized object, e.g.,

Serializable obj;
ByteArray payload(obj.size());
obj.pack(payload);

Parameters

[in,out]	array	ByteArray reference to write the object to.
[in]	offset	offset to start writing to.

Returns

the number of bytes written.

Definition at line 315 of file group_table.h.

References entries, HF_SERIALIZABLE_CHECK, HF::Protocol::Response::pack(), size(), start, and HF::Common::ByteArray::write().

            {
               HF_SERIALIZABLE_CHECK(array, offset, size());

               uint16_t _start = offset;

               offset += Protocol::Response::pack(array, offset);

               offset += array.write(offset, start);
               offset += array.write(offset, (uint8_t) entries.size());

               std::for_each(entries.begin(), entries.end(),
                             [&array, &offset](const Entry &entry)
               {
                  offset += entry.pack(array, offset);
               });

               return offset - _start;
            }

Here is the call graph for this function:

size()

uint16_t HF::Core::GroupTable::ReadEntriesResponse::size ( ) const

inline

Number bytes needed to serialize the message.

Returns

number of bytes the message requires to be serialized.

Definition at line 300 of file group_table.h.

References entries, and HF::Protocol::Response::size().

Referenced by pack().

            {
               uint16_t res = Protocol::Response::size()
                              + sizeof(uint8_t)
                              + sizeof(uint8_t);

               std::for_each(entries.begin(), entries.end(), [&res](const Entry &entry)
               {
                  res += entry.size();
               });

               return res;
            }

Here is the call graph for this function:

Here is the caller graph for this function:

unpack()

uint16_t HF::Core::GroupTable::ReadEntriesResponse::unpack ( const Common::ByteArray &  array, uint16_t  offset = 0  )

inline

Read a message from a ByteArray.

Parameters

[in]	array	ByteArray reference to read the message from.
[in]	offset	offset to start reading from.

Returns

the number of bytes read.

Definition at line 336 of file group_table.h.

References entries, HF_SERIALIZABLE_CHECK, HF::Core::GroupTable::Entry::min_size, min_size, HF::Common::ByteArray::read(), start, HF::Core::GroupTable::Entry::unpack(), and HF::Protocol::Response::unpack().

            {
               HF_SERIALIZABLE_CHECK(array, offset, min_size);

               uint16_t _start = offset;

               offset += Protocol::Response::unpack(array, offset);

               offset += array.read(offset, start);

               uint8_t count = 0;
               offset += array.read(offset, count);

               HF_SERIALIZABLE_CHECK(array, offset, count * Entry::min_size);

               entries.reserve(count * Entry::min_size);

               for (int i = 0; i < count; ++i)
               {
                  Entry entry;
                  offset += entry.unpack(array, offset);
                  entries.push_back(entry);
               }

               return offset - _start;
            }

Here is the call graph for this function:

Field Documentation

entries

std::vector<Entry> HF::Core::GroupTable::ReadEntriesResponse::entries

Vector containing the entries in the response.

Definition at line 274 of file group_table.h.

Referenced by pack(), ReadEntriesResponse(), size(), and unpack().

start

uint8_t HF::Core::GroupTable::ReadEntriesResponse::start

Offset to start reading entries from.

Definition at line 272 of file group_table.h.

Referenced by pack(), and unpack().

---

The documentation for this struct was generated from the following file:

• group_table.h