repoindex/alpm/utilities.cpp

#include "./utilities.h"
#include "./config.h"

#include <c++utilities/conversion/stringconversion.h>

#include <QJsonObject>
#include <QJsonArray>
#include <QStringList>
#include <QFileInfo>

#include <iostream>

using namespace std;

namespace RepoIndex {

namespace Utilities {

/*!
 * \brief Returns the package names of the specified \a dependencyList.
 */
list<string> getNames(DependencyList dependencyList)
{
    list<string> res;
    for(auto dependency : dependencyList) {
        res.push_back(dependency->name);
    }
    return res;
}

/*!
 * \brief Returns string representations for the specified \a sigLevel.
 */
QJsonArray sigLevelStrings(alpm_siglevel_t sigLevel)
{
    QJsonArray options;
    if(sigLevel & ALPM_SIG_PACKAGE) {
        options << QStringLiteral("package");
    }
    if(sigLevel & ALPM_SIG_PACKAGE_OPTIONAL) {
        options << QStringLiteral("package optional");
    }
    if(sigLevel & ALPM_SIG_PACKAGE_MARGINAL_OK) {
        options << QStringLiteral("package marginal ok");
    }
    if(sigLevel & ALPM_SIG_PACKAGE_UNKNOWN_OK) {
        options << QStringLiteral("package unknown ok");
    }
    if(sigLevel & ALPM_SIG_DATABASE) {
        options << QStringLiteral("database");
    }
    if(sigLevel & ALPM_SIG_DATABASE_OPTIONAL) {
        options << QStringLiteral("database optional");
    }
    if(sigLevel & ALPM_SIG_DATABASE_MARGINAL_OK) {
        options << QStringLiteral("database marginal ok");
    }
    if(sigLevel & ALPM_SIG_DATABASE_UNKNOWN_OK) {
        options << QStringLiteral("database unknown ok");
    }
    if(sigLevel & ALPM_SIG_USE_DEFAULT) {
        options << QStringLiteral("use default");
    }
    return options;
}

/*!
 * \brief Returns string representations for the specified database \a usage.
 */
QJsonArray usageStrings(alpm_db_usage_t usage)
{
    QJsonArray strings;
    if(usage & ALPM_DB_USAGE_SYNC) {
        strings << QStringLiteral("refreshing");
    }
    if(usage & ALPM_DB_USAGE_SEARCH) {
        strings << QStringLiteral("searching");
    }
    if(usage & ALPM_DB_USAGE_INSTALL) {
        strings << QStringLiteral("installing");
    }
    if(usage & ALPM_DB_USAGE_UPGRADE) {
        strings << QStringLiteral("upgrading");
    }
    return strings;
}

/*!
 * \brief Returns the string representation for the specified \a sigStatus.
 */
QString sigStatusString(alpm_sigstatus_t sigStatus)
{
    switch(sigStatus) {
    case ALPM_SIGSTATUS_VALID:
        return QStringLiteral("valid");
    case ALPM_SIGSTATUS_KEY_EXPIRED:
        return QStringLiteral("key expired");
    case ALPM_SIGSTATUS_SIG_EXPIRED:
        return QStringLiteral("sig expired");
    case ALPM_SIGSTATUS_KEY_UNKNOWN:
        return QStringLiteral("key unknown");
    case ALPM_SIGSTATUS_KEY_DISABLED:
        return QStringLiteral("key disabled");
    default:
        return QStringLiteral("invalid");
    }
}

/*!
 * \brief Returns the string representation for the specified \a validationMethods.
 */
QJsonArray validationMethodsStrings(alpm_pkgvalidation_t validationMethods)
{
    QJsonArray jsonArray;
    if(validationMethods & 0x1) {
        jsonArray << QStringLiteral("none");
    }
    if(validationMethods & 0x2) {
        jsonArray << QStringLiteral("MD5");
    }
    if(validationMethods & 0x4) {
        jsonArray << QStringLiteral("SHA256");
    }
    if(validationMethods & 0x8) {
        jsonArray << QStringLiteral("signature");
    }
    if(jsonArray.empty()) {
        jsonArray << QStringLiteral("unknown");
    }
    return jsonArray;
}

QJsonArray qjarry(StringList list)
{
    QJsonArray jsonArray;
    for(const char *str : list) {
        jsonArray << qstr(str);
    }
    return jsonArray;
}

QJsonArray qjarry(DependencyList list)
{
    QJsonArray jsonArray;
    for(alpm_depend_t *dep : list) {
        QJsonObject depObj;
        depObj.insert(QStringLiteral("name"), dep->name);
        depObj.insert(QStringLiteral("desc"), dep->desc);
        depObj.insert(QStringLiteral("ver"), dep->version);
        switch(dep->mod) {
        case ALPM_DEP_MOD_ANY:
            depObj.insert(QStringLiteral("mod"), QStringLiteral("any"));
            break;
        case ALPM_DEP_MOD_EQ:
            depObj.insert(QStringLiteral("mod"), QStringLiteral("eq"));
            break;
        case ALPM_DEP_MOD_GE:
            depObj.insert(QStringLiteral("mod"), QStringLiteral("ge"));
            break;
        case ALPM_DEP_MOD_LE:
            depObj.insert(QStringLiteral("mod"), QStringLiteral("le"));
            break;
        case ALPM_DEP_MOD_GT:
            depObj.insert(QStringLiteral("mod"), QStringLiteral("gt"));
            break;
        case ALPM_DEP_MOD_LT:
            depObj.insert(QStringLiteral("mod"), QStringLiteral("lt"));
            break;
        }
        jsonArray << depObj;
    }
    return jsonArray;
}

QJsonArray qjarry(_alpm_pkgvalidation_t validation)
{
    QJsonArray jsonArray;
    if(validation & 0x1) {
        jsonArray << QStringLiteral("none");
    }
    if(validation & 0x2) {
        jsonArray << QStringLiteral("MD5");
    }
    if(validation & 0x4) {
        jsonArray << QStringLiteral("SHA256");
    }
    if(validation & 0x8) {
        jsonArray << QStringLiteral("signature");
    }
    if(jsonArray.empty()) {
        jsonArray << QStringLiteral("unknown");
    }
    return jsonArray;
}

QStringList qstrlist(StringList list)
{
    QStringList strings;
    for(const auto *str : list) {
        strings << qstr(str);
    }
    return strings;
}

void printValues(ostream &output, const char *label, const QStringList &values)
{
    output << label << ':';
    for(const auto &value : values) {
        output << ' ' << value.toLocal8Bit().data();
    }
    output << endl;
}

void printBashArray(ostream &output, const char *name, const QStringList &values)
{
    output << "export " << name << '=' << '(';
    for(const auto &value : values) {
        output << ' ' << '\'' << value.toLocal8Bit().data() << '\'';
    }
    output << ' ' << ')' << endl;
}

void printError(const exception &ex)
{
    string message(ex.what());
    printError(message);
}

void printError(const QString &message)
{
    string msg(message.toStdString());
    printError(msg);
}

void printError(string &message)
{
    if(useShSyntax) {
        ConversionUtilities::findAndReplace<string>(message, "'", "\'");
        cerr << "export REPOINDEX_ERROR='" << message << '\'' << endl;
    } else {
        cerr << shchar << "Error: " << message << endl;
    }
}

}

} // namespace Alpm