CapnConverter.cpp

#include "stdafx.h"
#include "CapnConverter.h"
#include "capnp/message.h"

CapnConverter::CapnConverter()
{
}


CapnConverter::~CapnConverter()
{
}

ValuesStruct CapnConverter::convertValues(Values::Reader reader)
{
    // Read the data into std types
    std::string instanceName = reader.getInstanceName();

    // int
    std::vector<uint32_t> intVrs;
    for (auto element : reader.getIntegerValueRefs())
    {
        intVrs.push_back(element);
    }
    std::vector<int32_t> intValues;
    for (auto element : reader.getIntegerValues())
    {
        intValues.push_back(element);
    }
    // real
    std::vector<uint32_t> realVrs;
    for (auto element : reader.getRealValueRefs())
    {
        realVrs.push_back(element);
    }
    std::vector<double> realValues;
    for (auto element : reader.getRealValues())
    {
        realValues.push_back(element);
    }
    // bool
    std::vector<uint32_t> boolVrs;
    for (auto element : reader.getBoolValueRefs())
    {
        boolVrs.push_back(element);
    }
    std::vector<bool> boolValues;
    for (auto element : reader.getBoolValues())
    {
        boolValues.push_back(element);
    }
    // string
    std::vector<uint32_t> stringVrs;
    for (auto element : reader.getStringValueRefs())
    {
        stringVrs.push_back(element);
    }
    std::vector<std::string> stringValues;
    for (auto textReader : reader.getStringValues())
    {
        // std copy does not work because we have to convert the textreader implicity
        stringValues.push_back(textReader);
    }
    // assemble
    return ValuesStruct{
        instanceName,
        intVrs,
        intValues,
        realVrs,
        realValues,
        boolVrs,
        boolValues,
        stringVrs,
        stringValues
    };
}

Values::Builder CapnConverter::convertValues(ValuesStruct values)
{
    capnp::MallocMessageBuilder builder;
    auto retVal = builder.initRoot<Values>();
    retVal.setInstanceName(values.instanceName);

    // int
    auto intVrs = retVal.initIntegerValueRefs(values.integerValueRefs.size());
    for (int i = 0; i < intVrs.size(); i++)
    {
        intVrs.set(i, values.integerValueRefs[i]);
    }
    auto intValues = retVal.initIntegerValues(values.integerValues.size());
    for (int i = 0; i < intValues.size(); i++)
    {
        intValues.set(i, values.integerValues[i]);
    }
    // real
    auto realVrs = retVal.initRealValueRefs(values.realValueRefs.size());
    for (int i = 0; i < realVrs.size(); i++)
    {
        realVrs.set(i, values.realValueRefs[i]);
    }
    auto realValues = retVal.initRealValues(values.realValues.size());
    for (int i = 0; i < realValues.size(); i++)
    {
        realValues.set(i, values.realValues[i]);
    }
    // bool
    auto boolVrs = retVal.initBoolValueRefs(values.boolValueRefs.size());
    for (int i = 0; i < boolVrs.size(); i++)
    {
        boolVrs.set(i, values.boolValueRefs[i]);
    }
    auto boolValues = retVal.initBoolValues(values.boolValues.size());
    for (int i = 0; i < boolValues.size(); i++)
    {
        boolValues.set(i, values.boolValues[i]);
    }
    // string
    auto stringVrs = retVal.initStringValueRefs(values.stringValueRefs.size());
    for (int i = 0; i < stringVrs.size(); i++)
    {
        stringVrs.set(i, values.stringValueRefs[i]);
    }
    auto stringValues = retVal.initStringValues(values.stringValues.size());
    for (int i = 0; i < stringValues.size(); i++)
    {
        stringValues.set(i, values.stringValues[i]);
    }
    return retVal;
}

ModeliBackend::ChannelLink::Builder CapnConverter::convertChannelLink(ChannelLink channelLink)
{
    capnp::MallocMessageBuilder builder;
    auto retVal = builder.initRoot<ModeliBackend::ChannelLink>();
    retVal.setMasterInstanceName(channelLink.masterInstanceName);
    retVal.setSlaveInstanceName(channelLink.slaveInstanceName);
    retVal.setMasterValueRef(channelLink.masterValueRef);
    retVal.setSlaveValueRef(channelLink.slaveValueRef);
    retVal.setFactor(channelLink.factor);
    retVal.setOffset(channelLink.offset);
    return retVal;
}