simulator-update-struct.h

#ifndef     SIMULATOR_UPDATE_STRUCT_H
#define     SIMULATOR_UPDATE_STRUCT_H

#include    <QString>
#include    <QByteArray>
#include    <QBuffer>
#include    <QDataStream>

//------------------------------------------------------------------------------
//
//------------------------------------------------------------------------------
struct simulator_update_players_t
{
    std::vector<int> clients_id;
    std::vector<int> current_vehicles;
    std::vector<int> controlled_vehicles;

    simulator_update_players_t()
    {

    }

    QByteArray serialize()
    {
        QByteArray data;
        QBuffer buff(&data);
        buff.open(QIODevice::WriteOnly);
        QDataStream stream(&buff);

        stream << static_cast<uint32_t>(clients_id.size());
        for (auto id : clients_id)
        {
            stream << id;
        }

        stream << static_cast<uint32_t>(current_vehicles.size());
        for (auto veh : current_vehicles)
        {
            stream << veh;
        }

        stream << static_cast<uint32_t>(controlled_vehicles.size());
        for (auto veh : controlled_vehicles)
        {
            stream << veh;
        }

        return buff.data();
    }

    void deserialize(QByteArray &data)
    {
        QBuffer buff(&data);
        buff.open(QIODevice::ReadOnly);
        QDataStream stream(&buff);

        uint32_t num;

        stream >> num;
        clients_id.clear();
        clients_id.resize(num);
        for (uint32_t i = 0; i < clients_id.size(); ++i)
        {
            stream >> clients_id[i];
        }

        stream >> num;
        current_vehicles.clear();
        current_vehicles.resize(num);
        for (uint32_t i = 0; i < current_vehicles.size(); ++i)
        {
            stream >> current_vehicles[i];
        }

        stream >> num;
        controlled_vehicles.clear();
        controlled_vehicles.resize(num);
        for (uint32_t i = 0; i < controlled_vehicles.size(); ++i)
        {
            stream >> controlled_vehicles[i];
        }
    }
};

//------------------------------------------------------------------------------
//
//------------------------------------------------------------------------------
struct simulator_vehicle_pos_update_t
{
    double  position_x = 0.0;
    double  position_y = 0.0;
    double  position_z = 0.0;
    double  orth_x = 0.0;
    double  orth_y = 0.0;
    double  orth_z = 0.0;
    double  up_x = 0.0;
    double  up_y = 0.0;
    double  up_z = 1.0;

    QByteArray serialize()
    {
        QByteArray data;
        QBuffer buff(&data);
        buff.open(QIODevice::WriteOnly);
        QDataStream stream(&buff);

        stream << position_x;
        stream << position_y;
        stream << position_z;
        float tmp;
        tmp = static_cast<float>(orth_x);
        stream << tmp;
        tmp = static_cast<float>(orth_y);
        stream << tmp;
        tmp = static_cast<float>(orth_z);
        stream << tmp;
        tmp = static_cast<float>(up_x);
        stream << tmp;
        tmp = static_cast<float>(up_y);
        stream << tmp;
        tmp = static_cast<float>(up_z);
        stream << tmp;

        return buff.data();
    }

    void deserialize(QByteArray &data)
    {
        QBuffer buff(&data);
        buff.open(QIODevice::ReadOnly);
        QDataStream stream(&buff);

        stream >> position_x;
        stream >> position_y;
        stream >> position_z;
        float tmp;
        stream >> tmp;
        orth_x = static_cast<double>(tmp);
        stream >> tmp;
        orth_y = static_cast<double>(tmp);
        stream >> tmp;
        orth_z = static_cast<double>(tmp);
        stream >> tmp;
        up_x = static_cast<double>(tmp);
        stream >> tmp;
        up_y = static_cast<double>(tmp);
        stream >> tmp;
        up_z = static_cast<double>(tmp);
    }
};

//------------------------------------------------------------------------------
//
//------------------------------------------------------------------------------
struct simulator_update_pos_t
{
    double time = 0.0;
    std::vector<simulator_vehicle_pos_update_t> vehicles;

    simulator_update_pos_t()
    {

    }

    QByteArray serialize()
    {
        QByteArray data;
        QBuffer buff(&data);
        buff.open(QIODevice::WriteOnly);
        QDataStream stream(&buff);

        stream << time;

        stream << static_cast<uint32_t>(vehicles.size());
        for (auto veh_pos : vehicles)
        {
            stream << veh_pos.serialize();
        }

        return buff.data();
    }

    void deserialize(QByteArray &data)
    {
        QBuffer buff(&data);
        buff.open(QIODevice::ReadOnly);
        QDataStream stream(&buff);

        stream >> time;

        uint32_t num;

        stream >> num;
        vehicles.clear();
        vehicles.resize(num);

        for (uint32_t i = 0; i < vehicles.size(); ++i)
        {
            QByteArray vehicle_data;
            stream >> vehicle_data;

            vehicles[i].deserialize(vehicle_data);
        }
    }
};

//------------------------------------------------------------------------------
//
//------------------------------------------------------------------------------
struct simulator_vehicle_update_t
{
    int orientation = 1;
    int train_id = 0;
    int prev_vehicle = -1;
    int next_vehicle = -1;
    std::vector<float>   analogSignal;

    simulator_vehicle_update_t()
    {

    }

    QByteArray serialize()
    {
        QByteArray data;
        QBuffer buff(&data);
        buff.open(QIODevice::WriteOnly);
        QDataStream stream(&buff);

        stream << orientation;
        stream << train_id;
        stream << prev_vehicle;
        stream << next_vehicle;

        stream << static_cast<uint32_t>(analogSignal.size());

        for (auto signal : analogSignal)
        {
            stream << signal;
        }

        return buff.data();
    }

    void deserialize(QByteArray &data)
    {
        QBuffer buff(&data);
        buff.open(QIODevice::ReadOnly);
        QDataStream stream(&buff);

        stream >> orientation;
        stream >> train_id;
        stream >> prev_vehicle;
        stream >> next_vehicle;

        uint32_t num;
        stream >> num;
        analogSignal.clear();
        analogSignal.resize(num);

        for (uint32_t i = 0; i < analogSignal.size(); ++i)
        {
            stream >> analogSignal[i];
        }
    }
};

//------------------------------------------------------------------------------
//
//------------------------------------------------------------------------------
struct simulator_train_update_t
{
    int  first_vehicle_id = 0;
    int  last_vehicle_id = 0;
    //QString train_ID = "";

    QByteArray serialize()
    {
        QByteArray data;
        QBuffer buff(&data);
        buff.open(QIODevice::WriteOnly);
        QDataStream stream(&buff);

        stream << first_vehicle_id;
        stream << last_vehicle_id;
        //stream << train_ID;
        return buff.data();
    }

    void deserialize(QByteArray &data)
    {
        QBuffer buff(&data);
        buff.open(QIODevice::ReadOnly);
        QDataStream stream(&buff);

        stream >> first_vehicle_id;
        stream >> last_vehicle_id;
        //stream >> train_ID;
    }
};

//------------------------------------------------------------------------------
//
//------------------------------------------------------------------------------
struct simulator_update_t
{
    std::vector<simulator_train_update_t> trains;
    std::vector<simulator_vehicle_update_t> vehicles;

    simulator_update_t()
    {

    }

    QByteArray serialize()
    {
        QByteArray data;
        QBuffer buff(&data);
        buff.open(QIODevice::WriteOnly);
        QDataStream stream(&buff);

        stream << static_cast<uint32_t>(trains.size());

        for (auto train : trains)
        {
            stream << train.serialize();
        }

        stream << static_cast<uint32_t>(vehicles.size());

        for (auto vehicle : vehicles)
        {
            stream << vehicle.serialize();
        }

        return buff.data();
    }

    void deserialize(QByteArray &data)
    {
        QBuffer buff(&data);
        buff.open(QIODevice::ReadOnly);
        QDataStream stream(&buff);

        uint32_t num;
        stream >> num;

        trains.clear();
        trains.resize(num);

        for (uint32_t i = 0; i < trains.size(); ++i)
        {
            QByteArray train_data;
            stream >> train_data;

            trains[i].deserialize(train_data);
        }

        stream >> num;

        vehicles.clear();
        vehicles.resize(num);

        for (uint32_t i = 0; i < vehicles.size(); ++i)
        {
            QByteArray vehicle_data;
            stream >> vehicle_data;

            vehicles[i].deserialize(vehicle_data);
        }
    }
};

//------------------------------------------------------------------------------
//
//------------------------------------------------------------------------------
struct simulator_vehicle_controlled_update_t
{
    int current_vehicle = 0;
    QString currentDebugMsg = "";
    int controlled_vehicle = 0;
    QString controlledDebugMsg = "";

    simulator_vehicle_controlled_update_t()
    {

    }

    QByteArray serialize()
    {
        QByteArray data;
        QBuffer buff(&data);
        buff.open(QIODevice::WriteOnly);
        QDataStream stream(&buff);

        stream << current_vehicle;
        stream << currentDebugMsg;
        stream << controlled_vehicle;
        stream << controlledDebugMsg;

        return buff.data();
    }

    void deserialize(QByteArray &data)
    {
        QBuffer buff(&data);
        buff.open(QIODevice::ReadOnly);
        QDataStream stream(&buff);

        stream >> current_vehicle;
        stream >> currentDebugMsg;
        stream >> controlled_vehicle;
        stream >> controlledDebugMsg;
    }
};

#endif // SIMULATOR_UPDATE_STRUCT_H