toys/dbcc/source/signal_processor.cpp

#include "dbcc/signal_processor.h"

#include <tuple>

namespace ad {
namespace dbcc {

size_t SignalProcessor::SignalIndex(uint32_t msg_id, const std::string& signal_name)
{
    auto msg_iter = dbc_iter_.find(msg_id);

    if (msg_iter == dbc_iter_.end()) {
        return kInvalidIndex;
    }

    if (!msg_iter->contains(signal_name)) {
        return kInvalidIndex;
    }

    return (*msg_iter)[signal_name];
}

bool SignalProcessor::DecodeMessage(uint32_t msg_id, const uint8_t* data, size_t length)
{
    ad::dbcc::ParsedValue pv;

    auto iter = decoder_map_.find(msg_id);

    if (iter == decoder_map_.end()) {
        return false;
    }

    ad::dbcc::Message msg;
    std::vector<size_t> vt;

    std::tie(msg, vt) = iter->second;

    for (size_t i = 0; i < vt.size(); i++) {
        auto& sig = msg[vt[i]];

        if (sig.Decode(data, length, pv)) {
            sig.GetDecodeDelegate()->OnDecoded(msg_id, sig.Name(), pv);
        } else {
            std::cout << "[WARNING] Failed to decode: " << msg_id << ":" << sig.Name() << std::endl;

            return false;
        }
    }

    return true;
}

bool SignalProcessor::EncodeMessage(uint32_t msg_id, const SignalValues& pvs, uint8_t* data,
                                    size_t length)
{
    auto iter = encoder_map_.find(msg_id);

    if (iter == encoder_map_.end()) {
        return false;
    }

    ad::dbcc::Message msg;
    std::vector<size_t> vt;

    std::tie(msg, vt) = iter->second;

    for (size_t i = 0; i < pvs.size(); i++) {
        auto& pv = pvs[i];
        auto idx = msg[pv.first];
        if (idx != kInvalidIndex) {
            auto& sig = msg[idx];
            if (sig.Encode(pv.second, data, length)) {
                if (!sig.GetEncodeDelegate()->OnEncoded(msg_id, sig.Name(), data, length, pv.second,
                                                        i == pvs.size() - 1)) {
                    break;
                }
            } else {
                std::cout << "[WARNING] Failed to encode: " << msg_id << ":" << sig.Name()
                          << std::endl;

                return false;
            }
        } else {
            std::cout << "[WARNING] The signal (" << msg_id << ":" << pv.first
                      << ") does not exist!" << std::endl;

            return false;
        }
    }

    return true;
}

bool SignalProcessor::EncodeMessage(uint32_t msg_id, const SignalValuesVector& pvs, uint8_t* data,
                                    size_t length)
{
    auto iter = encoder_map_.find(msg_id);

    if (iter == encoder_map_.end()) {
        return false;
    }

    ParsedValue rpv;

    ad::dbcc::Message msg;
    std::vector<size_t> vt;

    std::tie(msg, vt) = iter->second;

    for (size_t i = 0; i < pvs.size(); i++) {
        auto& pv = pvs[i];
        auto idx = msg[pv.first];
        if (idx != kInvalidIndex) {
            auto& sig = msg[idx];
            if (sig.Encode(pv.second, data, length)) {
                rpv.is_integer = !sig.IsFloat();
                if (rpv.is_integer) {
                    rpv.i = static_cast<int32_t>(pv.second);
                } else {
                    rpv.f = static_cast<float>(pv.second);
                }

                if (!sig.GetEncodeDelegate()->OnEncoded(msg_id, sig.Name(), data, length, rpv,
                                                        i == pvs.size() - 1)) {
                    break;
                }
            } else {
                std::cout << "[WARNING] Failed to encode: " << msg_id << ":" << sig.Name()
                          << std::endl;

                return false;
            }
        } else {
            std::cout << "[WARNING] The signal (" << msg_id << ":" << pv.first
                      << ") does not exist!" << std::endl;

            return false;
        }
    }

    return true;
}

bool SignalProcessor::EncodeMessage(uint32_t msg_id, const SignalValuesMap& pvs, uint8_t* data,
                                    size_t length)
{
    auto iter = encoder_map_.find(msg_id);

    if (iter == encoder_map_.end()) {
        return false;
    }

    ParsedValue rpv;

    ad::dbcc::Message msg;
    std::vector<size_t> vt;

    std::tie(msg, vt) = iter->second;

    size_t i = 0;

    for (auto& kv : pvs) {
        auto idx = msg[kv.first];
        if (idx != kInvalidIndex) {
            auto& sig = msg[idx];
            if (sig.Encode(kv.second, data, length)) {
                rpv.is_integer = !sig.IsFloat();
                if (rpv.is_integer) {
                    rpv.i = static_cast<int32_t>(kv.second);
                } else {
                    rpv.f = static_cast<float>(kv.second);
                }

                if (!sig.GetEncodeDelegate()->OnEncoded(msg_id, sig.Name(), data, length, rpv,
                                                        i == pvs.size() - 1)) {
                    break;
                }
            } else {
                std::cout << "[WARNING] Failed to encode: " << msg_id << ":" << sig.Name()
                          << std::endl;

                return false;
            }
        } else {
            std::cout << "[WARNING] The signal (" << msg_id << ":" << kv.first
                      << ") does not exist!" << std::endl;

            return false;
        }

        ++i;
    }

    return true;
}

} // namespace dbcc
} // namespace ad