Method deserialize

implementation/protocol/src/assign_client_command.cpp:57–114

}

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

    if (_buffer.size() < COMMAND_HEADER_SIZE) {
        _error = error_e::ERROR_NOT_ENOUGH_BYTES;
        return;
    }

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

    size_t read_position(COMMAND_POSITION_PAYLOAD);
    size_t remaining(_buffer.size() - COMMAND_HEADER_SIZE);

    // deserialize name length and name
    if (remaining < sizeof(uint32_t)) {
        _error = error_e::ERROR_NOT_ENOUGH_BYTES;
        return;
    }

    uint32_t name_length = 0;
    std::memcpy(&name_length, &_buffer[read_position], sizeof(uint32_t));
    read_position += sizeof(uint32_t);
    remaining -= sizeof(uint32_t);

    if (remaining < name_length) {
        _error = error_e::ERROR_NOT_ENOUGH_BYTES;
        return;
    }

    if (name_length > 0) {
        name_.assign(&_buffer[read_position], &_buffer[read_position + name_length]);
        read_position += name_length;
        remaining -= name_length;
    }

    if (remaining < sizeof(uint8_t)) {
        _error = error_e::ERROR_NOT_ENOUGH_BYTES;
        return;
    }

    uint8_t has_address = 0;
    std::memcpy(&has_address, &_buffer[read_position], sizeof(uint8_t));
    read_position += sizeof(uint8_t);
    remaining -= sizeof(uint8_t);

    if (has_address) {
        if (remaining < sizeof(boost::asio::ip::address_v4::bytes_type) + sizeof(port_t)) {
            _error = error_e::ERROR_NOT_ENOUGH_BYTES;
            return;
        }
        boost::asio::ip::address_v4::bytes_type its_array;
        std::memcpy(&its_array, &_buffer[read_position], its_array.size());
        address_ = boost::asio::ip::address_v4(its_array);
        read_position += its_array.size();
        std::memcpy(&port_, &_buffer[read_position], sizeof(port_t));
    }
}