Conversion.cpp

Go to the documentation of this file.

#include "dbe/Conversion.hpp"
#include "dbe/Exceptions.hpp"
 
namespace dbe {
namespace convert {
 
template<> QStringList to<QStringList>(std::vector<std::string> const & x) {
    QStringList ret;
 
    for(std::string const & a : x) {
        ret.append(QString::fromStdString(a));
    }
 
    return ret;
}
 
template<>
std::string to<std::string>(QStringList const & DataList) {
    std::string rString;
 
    for(int i = 0; i < DataList.size(); ++i) {
        rString = DataList.at(i).toStdString();
    }
 
    return rString;
}
 
template<>
std::vector<std::string> to<std::vector<std::string> >(QStringList const & DataList) {
    std::vector<std::string> rVector;
 
    for(int i = 0; i < DataList.size(); ++i) {
        rVector.push_back(DataList.at(i).toStdString());
    }
 
    return rVector;
}
 
template<>
std::string to<std::string>(QStringList const & DataList, dunedaq::conffwk::int_format_t Format) {
    Q_UNUSED (Format)
 
    std::string rString;
 
    for(int i = 0; i < DataList.size(); ++i) {
        rString = DataList.at(i).toStdString();
    }
 
    return rString;
}
 
template<>
std::vector<std::string> to<std::vector<std::string>>(QStringList const & DataList, dunedaq::conffwk::int_format_t Format) {
    Q_UNUSED (Format)
 
    std::vector<std::string> rVector;
 
    for(int i = 0; i < DataList.size(); ++i) {
        rVector.push_back(DataList.at(i).toStdString());
    }
 
    return rVector;
}
 
template<>
u_int8_t to<u_int8_t>(QStringList const & DataList, dunedaq::conffwk::int_format_t Format) {
    bool ok = false;
    u_int8_t uChar = 0;
 
    if(DataList.size() > 0) {
        if(Format == dunedaq::conffwk::dec_int_format) {
            uChar = (u_int8_t) (DataList.at(0).toULong(&ok, 10));
        } else if(Format == dunedaq::conffwk::hex_int_format) {
            uChar = (u_int8_t) (DataList.at(0).toULong(&ok, 16));
        } else if(Format == dunedaq::conffwk::oct_int_format) {
            uChar = (u_int8_t) (DataList.at(0).toULong(&ok, 8));
        } else if(Format == dunedaq::conffwk::na_int_format) {
            uChar = (u_int8_t) (DataList.at(0).toULong(&ok));
        }
    }
 
    return uChar;
}
 
template<>
std::vector<u_int8_t> to<std::vector<u_int8_t> >(QStringList const & DataList, dunedaq::conffwk::int_format_t Format) {
    std::vector<u_int8_t> rVector;
 
    for(int i = 0; i < DataList.size(); ++i) {
        bool ok = false;
        u_int8_t uChar = 0;
 
        if(Format == dunedaq::conffwk::dec_int_format) {
            uChar = (u_int8_t) (DataList.at(i).toULong(&ok, 10));
        } else if(Format == dunedaq::conffwk::hex_int_format) {
            uChar = (u_int8_t) (DataList.at(i).toULong(&ok, 16));
        } else if(Format == dunedaq::conffwk::oct_int_format) {
            uChar = (u_int8_t) (DataList.at(i).toULong(&ok, 8));
        } else if(Format == dunedaq::conffwk::na_int_format) {
            uChar = (u_int8_t) (DataList.at(i).toULong(&ok));
        }
 
        rVector.push_back(uChar);
    }
 
    return rVector;
}
 
template<>
int8_t to<int8_t>(QStringList const & DataList, dunedaq::conffwk::int_format_t Format) {
    bool ok = false;
    int8_t sChar = 0;
 
    if(DataList.size() > 0) {
        if(Format == dunedaq::conffwk::dec_int_format) {
            sChar = (int8_t) (DataList.at(0).toLong(&ok, 10));
        } else if(Format == dunedaq::conffwk::hex_int_format) {
            sChar = (int8_t) (DataList.at(0).toLong(&ok, 16));
        } else if(Format == dunedaq::conffwk::oct_int_format) {
            sChar = (int8_t) (DataList.at(0).toLong(&ok, 8));
        } else if(Format == dunedaq::conffwk::na_int_format) {
            sChar = (int8_t) (DataList.at(0).toLong(&ok));
        }
    }
 
    return sChar;
}
 
template<>
std::vector<int8_t> to<std::vector<int8_t>>(QStringList const & DataList, dunedaq::conffwk::int_format_t Format) {
    std::vector<int8_t> rVector;
 
    for(int i = 0; i < DataList.size(); ++i) {
        bool ok = false;
        int8_t sChar = 0;
 
        if(Format == dunedaq::conffwk::dec_int_format) {
            sChar = (int8_t) (DataList.at(i).toLong(&ok, 10));
        } else if(Format == dunedaq::conffwk::hex_int_format) {
            sChar = (int8_t) (DataList.at(i).toLong(&ok, 16));
        } else if(Format == dunedaq::conffwk::oct_int_format) {
            sChar = (int8_t) (DataList.at(i).toLong(&ok, 8));
        } else if(Format == dunedaq::conffwk::na_int_format) {
            sChar = (int8_t) (DataList.at(i).toLong(&ok));
        }
 
        rVector.push_back(sChar);
    }
 
    return rVector;
}
 
template<>
u_int16_t to<u_int16_t>(QStringList const & DataList, dunedaq::conffwk::int_format_t Format) {
    bool ok = false;
    u_int16_t uShort = 0;
 
    if(DataList.size() > 0) {
        if(Format == dunedaq::conffwk::dec_int_format) {
            uShort = DataList.at(0).toUShort(&ok, 10);
        } else if(Format == dunedaq::conffwk::hex_int_format) {
            uShort = DataList.at(0).toUShort(&ok, 16);
        } else if(Format == dunedaq::conffwk::oct_int_format) {
            uShort = DataList.at(0).toUShort(&ok, 8);
        } else if(Format == dunedaq::conffwk::na_int_format) {
            uShort = DataList.at(0).toUShort(&ok);
        }
    }
 
    return uShort;
}
 
template<>
std::vector<u_int16_t> to<std::vector<u_int16_t>>(QStringList const & DataList, dunedaq::conffwk::int_format_t Format) {
    std::vector<u_int16_t> rVector;
 
    for(int i = 0; i < DataList.size(); ++i) {
        bool ok = false;
        u_int16_t uShort = 0;
 
        if(Format == dunedaq::conffwk::dec_int_format) {
            uShort = DataList.at(i).toUShort(&ok, 10);
        } else if(Format == dunedaq::conffwk::hex_int_format) {
            uShort = DataList.at(i).toUShort(&ok, 16);
        } else if(Format == dunedaq::conffwk::oct_int_format) {
            uShort = DataList.at(i).toUShort(&ok, 8);
        } else if(Format == dunedaq::conffwk::na_int_format) {
            uShort = DataList.at(i).toUShort(&ok);
        }
 
        rVector.push_back(uShort);
    }
 
    return rVector;
}
 
template<>
int16_t to<int16_t>(QStringList const & DataList, dunedaq::conffwk::int_format_t Format) {
    bool ok = false;
    int16_t sShort = 0;
 
    if(DataList.size() > 0) {
        if(Format == dunedaq::conffwk::dec_int_format) {
            sShort = DataList.at(0).toShort(&ok, 10);
        } else if(Format == dunedaq::conffwk::hex_int_format) {
            sShort = DataList.at(0).toShort(&ok, 16);
        } else if(Format == dunedaq::conffwk::oct_int_format) {
            sShort = DataList.at(0).toShort(&ok, 8);
        } else if(Format == dunedaq::conffwk::na_int_format) {
            sShort = DataList.at(0).toShort(&ok);
        }
    }
 
    return sShort;
}
 
template<>
std::vector<int16_t> to<std::vector<int16_t>>(QStringList const & DataList, dunedaq::conffwk::int_format_t Format) {
    std::vector<int16_t> rVector;
 
    for(int i = 0; i < DataList.size(); ++i) {
        bool ok = false;
        int16_t sShort = 0;
 
        if(Format == dunedaq::conffwk::dec_int_format) {
            sShort = DataList.at(i).toShort(&ok, 10);
        } else if(Format == dunedaq::conffwk::hex_int_format) {
            sShort = DataList.at(i).toShort(&ok, 16);
        } else if(Format == dunedaq::conffwk::oct_int_format) {
            sShort = DataList.at(i).toShort(&ok, 8);
        } else if(Format == dunedaq::conffwk::na_int_format) {
            sShort = DataList.at(i).toShort(&ok);
        }
 
        rVector.push_back(sShort);
    }
 
    return rVector;
}
 
template<>
u_int32_t to<u_int32_t>(QStringList const & DataList, dunedaq::conffwk::int_format_t Format) {
    bool ok = false;
    u_int32_t uLong = 0;
 
    if(DataList.size() > 0) {
        if(Format == dunedaq::conffwk::dec_int_format) {
            uLong = DataList.at(0).toULong(&ok, 10);
        } else if(Format == dunedaq::conffwk::hex_int_format) {
            uLong = DataList.at(0).toULong(&ok, 16);
        } else if(Format == dunedaq::conffwk::oct_int_format) {
            uLong = DataList.at(0).toULong(&ok, 8);
        } else if(Format == dunedaq::conffwk::na_int_format) {
            uLong = DataList.at(0).toULong(&ok);
        }
    }
 
    return uLong;
}
 
template<>
std::vector<u_int32_t> to<std::vector<u_int32_t>>(QStringList const & DataList, dunedaq::conffwk::int_format_t Format) {
    std::vector<u_int32_t> rVector;
 
    for(int i = 0; i < DataList.size(); ++i) {
        bool ok = false;
        u_int32_t uLong = 0;
 
        if(Format == dunedaq::conffwk::dec_int_format) {
            uLong = DataList.at(i).toULong(&ok, 10);
        } else if(Format == dunedaq::conffwk::hex_int_format) {
            uLong = DataList.at(i).toULong(&ok, 16);
        } else if(Format == dunedaq::conffwk::oct_int_format) {
            uLong = DataList.at(i).toULong(&ok, 8);
        } else if(Format == dunedaq::conffwk::na_int_format) {
            uLong = DataList.at(i).toULong(&ok);
        }
 
        rVector.push_back(uLong);
    }
 
    return rVector;
}
 
template<>
int32_t to<int32_t>(QStringList const & DataList, dunedaq::conffwk::int_format_t Format) {
    bool ok = false;
    int32_t sLong = 0;
 
    if(DataList.size() > 0) {
        if(Format == dunedaq::conffwk::dec_int_format) {
            sLong = DataList.at(0).toLong(&ok, 10);
        } else if(Format == dunedaq::conffwk::hex_int_format) {
            sLong = DataList.at(0).toLong(&ok, 16);
        } else if(Format == dunedaq::conffwk::oct_int_format) {
            sLong = DataList.at(0).toLong(&ok, 8);
        } else if(Format == dunedaq::conffwk::na_int_format) {
            sLong = DataList.at(0).toLong(&ok);
        }
    }
 
    return sLong;
}
 
template<>
std::vector<int32_t> to<std::vector<int32_t>>(QStringList const & DataList, dunedaq::conffwk::int_format_t Format) {
    std::vector<int32_t> rVector;
 
    for(int i = 0; i < DataList.size(); ++i) {
        bool ok = false;
        int32_t sLong = 0;
 
        if(Format == dunedaq::conffwk::dec_int_format) {
            sLong = DataList.at(i).toLong(&ok, 10);
        } else if(Format == dunedaq::conffwk::hex_int_format) {
            sLong = DataList.at(i).toLong(&ok, 16);
        } else if(Format == dunedaq::conffwk::oct_int_format) {
            sLong = DataList.at(i).toLong(&ok, 8);
        } else if(Format == dunedaq::conffwk::na_int_format) {
            sLong = DataList.at(i).toLong(&ok, 10);
        }
 
        rVector.push_back(sLong);
    }
 
    return rVector;
}
 
template<>
u_int64_t to<u_int64_t>(QStringList const & DataList, dunedaq::conffwk::int_format_t Format) {
    bool ok = false;
    u_int64_t u64 = 0;
 
    if(DataList.size() > 0) {
        if(Format == dunedaq::conffwk::dec_int_format) {
            u64 = (uint64_t) (DataList.at(0).toULongLong(&ok, 10));
        } else if(Format == dunedaq::conffwk::hex_int_format) {
            u64 = (uint64_t) (DataList.at(0).toULongLong(&ok, 16));
        } else if(Format == dunedaq::conffwk::oct_int_format) {
            u64 = (uint64_t) (DataList.at(0).toULongLong(&ok, 8));
        } else if(Format == dunedaq::conffwk::na_int_format) {
            u64 = (uint64_t) (DataList.at(0).toULongLong(&ok, 10));
        }
    }
 
    return u64;
}
 
template<>
std::vector<u_int64_t> to<std::vector<u_int64_t>>(QStringList const & DataList, dunedaq::conffwk::int_format_t Format) {
    std::vector<u_int64_t> rVector;
 
    for(int i = 0; i < DataList.size(); ++i) {
        bool ok = false;
        u_int64_t u64 = 0;
 
        if(Format == dunedaq::conffwk::dec_int_format) {
            u64 = (uint64_t) (DataList.at(i).toULongLong(&ok, 10));
        } else if(Format == dunedaq::conffwk::hex_int_format) {
            u64 = (uint64_t) (DataList.at(i).toULongLong(&ok, 16));
        } else if(Format == dunedaq::conffwk::oct_int_format) {
            u64 = (uint64_t) (DataList.at(i).toULongLong(&ok, 8));
        } else if(Format == dunedaq::conffwk::na_int_format) {
            u64 = (uint64_t) (DataList.at(i).toULongLong(&ok, 10));
        }
 
        rVector.push_back(u64);
    }
 
    return rVector;
}
 
template<>
int64_t to<int64_t>(QStringList const & DataList, dunedaq::conffwk::int_format_t Format) {
    bool ok = false;
    int64_t i64 = 0;
 
    if(DataList.size() > 0) {
        if(Format == dunedaq::conffwk::dec_int_format) {
            i64 = (int64_t) (DataList.at(0).toLongLong(&ok, 10));
        } else if(Format == dunedaq::conffwk::hex_int_format) {
            i64 = (int64_t) (DataList.at(0).toLongLong(&ok, 16));
        } else if(Format == dunedaq::conffwk::oct_int_format) {
            i64 = (int64_t) (DataList.at(0).toLongLong(&ok, 8));
        } else if(Format == dunedaq::conffwk::na_int_format) {
            i64 = (int64_t) (DataList.at(0).toLongLong(&ok, 10));
        }
    }
 
    return i64;
}
 
template<>
std::vector<int64_t> to<std::vector<int64_t>>(QStringList const & DataList, dunedaq::conffwk::int_format_t Format) {
    std::vector<int64_t> rVector;
 
    for(int i = 0; i < DataList.size(); ++i) {
        bool ok = false;
        int64_t i64 = 0;
 
        if(Format == dunedaq::conffwk::dec_int_format) {
            i64 = (int64_t) (DataList.at(i).toLongLong(&ok, 10));
        } else if(Format == dunedaq::conffwk::hex_int_format) {
            i64 = (int64_t) (DataList.at(i).toLongLong(&ok, 16));
        } else if(Format == dunedaq::conffwk::oct_int_format) {
            i64 = (int64_t) (DataList.at(i).toLongLong(&ok, 8));
        } else if(Format == dunedaq::conffwk::na_int_format) {
            i64 = (int64_t) (DataList.at(i).toLongLong(&ok, 10));
        }
 
        rVector.push_back(i64);
    }
 
    return rVector;
}
 
template<>
float to<float>(QStringList const & DataList, dunedaq::conffwk::int_format_t Format) {
    Q_UNUSED (Format)
 
    float f {0};
 
    for(auto i = 0; i < DataList.size(); ++i) {
        f = DataList.at(i).toFloat();
    }
 
    return f;
}
 
template<>
std::vector<float> to<std::vector<float>>(QStringList const & DataList, dunedaq::conffwk::int_format_t Format) {
    Q_UNUSED (Format)
 
    std::vector<float> rVector;
 
    for(int i = 0; i < DataList.size(); ++i) {
        rVector.push_back(DataList.at(i).toFloat());
    }
 
    return rVector;
}
 
template<>
double to<double>(QStringList const & DataList, dunedaq::conffwk::int_format_t Format) {
    Q_UNUSED (Format)
 
    double d {0};
 
    for(int i = 0; i < DataList.size(); ++i) {
        d = DataList.at(i).toDouble();
    }
 
    return d;
}
 
template<>
std::vector<double> to<std::vector<double>>(QStringList const & DataList, dunedaq::conffwk::int_format_t Format) {
    Q_UNUSED (Format)
 
    std::vector<double> rVector;
 
    for(int i = 0; i < DataList.size(); ++i) {
        rVector.push_back(DataList.at(i).toDouble());
    }
 
    return rVector;
}
 
template<>
bool to<bool>(QStringList const & DataList, dunedaq::conffwk::int_format_t Format) {
    bool b = false;
    Q_UNUSED (Format)
 
    for(int i = 0; i < DataList.size(); ++i) {
        if(QString::compare(DataList.at(i), QString("true"), Qt::CaseInsensitive) == 0
                || QString::compare(DataList.at(i), QString("1"), Qt::CaseInsensitive) == 0) {
            b = true;
        } else if(QString::compare(DataList.at(i), QString("false"), Qt::CaseInsensitive) == 0
                || QString::compare(DataList.at(i), QString("0"), Qt::CaseInsensitive) == 0) {
            b = false;
        } else {
            std::string message = "Conversion to enum of " + DataList.at(i).toStdString() + " is not possible!";
            throw daq::dbe::BadConversion( ERS_HERE, message.c_str() );
        }
    }
 
    return b;
}
 
template<>
std::vector<bool> to<std::vector<bool>>(QStringList const & DataList, dunedaq::conffwk::int_format_t Format) {
    std::vector<bool> rVector;
    Q_UNUSED (Format)
 
    for(int i = 0; i < DataList.size(); ++i) {
        if(QString::compare(DataList.at(i), QString("true"), Qt::CaseInsensitive) == 0
                || QString::compare(DataList.at(i), QString("1"), Qt::CaseInsensitive) == 0) {
            rVector.push_back(true);
        } else if(QString::compare(DataList.at(i), QString("false"), Qt::CaseInsensitive) == 0
                || QString::compare(DataList.at(i), QString("0"), Qt::CaseInsensitive) == 0) {
            rVector.push_back(false);
        } else {
            std::string message = "Conversion to enum of " + DataList.at(i).toStdString() + " is not possible!";
            throw daq::dbe::BadConversion( ERS_HERE, message.c_str() );
        }
    }
 
    return rVector;
}
 
}
}