Method deserialize

implementation/protocol/src/subscribe_command.cpp:67–122

}

void subscribe_command::deserialize(const std::vector<byte_t>& _buffer, error_e& _error) {

    size_t its_size(COMMAND_HEADER_SIZE + sizeof(service_) + sizeof(instance_) + sizeof(eventgroup_) + sizeof(major_) + sizeof(event_)
                    + sizeof(pending_id_));

    if (its_size > _buffer.size()) {

        _error = error_e::ERROR_NOT_ENOUGH_BYTES;
        return;
    }

    // deserialize header
    command::deserialize(_buffer, _error);
    if (_error != error_e::ERROR_OK)
        return;

    // deserialize subscription
    subscribe_command_base::deserialize(_buffer, _error);
    if (_error != error_e::ERROR_OK)
        return;

    // deserialize filter
    size_t its_offset(its_size);
    if (_buffer.size() - its_offset >= sizeof(bool) + sizeof(bool) + sizeof(int64_t)) {

        filter_ = std::make_shared<debounce_filter_impl_t>();
        std::memcpy(&filter_->on_change_, &_buffer[its_offset], sizeof(filter_->on_change_));
        its_offset += sizeof(filter_->on_change_);
        std::memcpy(&filter_->on_change_resets_interval_, &_buffer[its_offset], sizeof(filter_->on_change_resets_interval_));
        its_offset += sizeof(filter_->on_change_resets_interval_);
        std::memcpy(&filter_->interval_, &_buffer[its_offset], sizeof(filter_->interval_));
        its_offset += sizeof(filter_->interval_);

        while (_buffer.size() - its_offset >= sizeof(size_t) + sizeof(byte_t)) {

            size_t its_key;
            byte_t its_value;

            std::memcpy(&its_key, &_buffer[its_offset], sizeof(its_key));
            if (filter_->ignore_.contains(its_key)) {

                _error = error_e::ERROR_MALFORMED;
                return;
            }

            its_offset += sizeof(its_key);
            its_value = _buffer[its_offset];
            its_offset += sizeof(its_value);

            filter_->ignore_.emplace(std::make_pair(its_key, its_value));
        }

        std::memcpy(&filter_->send_current_value_after_, &_buffer[its_offset], sizeof(filter_->send_current_value_after_));
        its_offset += sizeof(filter_->send_current_value_after_);
    }
}

} // namespace protocol