src/lib/enum.cpp

0001 /*
0002  * SPDX-FileCopyrightText: 2018-2019 Daniel Vrátil <dvratil@kde.org>
0003  *
0004  * SPDX-License-Identifier: GPL-2.0-only OR GPL-3.0-only OR LicenseRef-KDE-Accepted-GPL
0005  */
0006
0007 #include "enum.h"
0008 #include "libkbolt_debug.h"
0009
0010 #include <QStringList>
0011 #if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
0012 #include <QStringRef>
0013 #else
0014 #include <QStringView>
0015 #endif
0016 #include <QVector>
0017
0018 Bolt::Status Bolt::statusFromString(const QString &str)
0019 {
0020     if (str == QLatin1String("unknown")) {
0021         return Bolt::Status::Unknown;
0022     } else if (str == QLatin1String("disconnected")) {
0023         return Bolt::Status::Disconnected;
0024     } else if (str == QLatin1String("connecting")) {
0025         return Bolt::Status::Connecting;
0026     } else if (str == QLatin1String("connected")) {
0027         return Bolt::Status::Connected;
0028     } else if (str == QLatin1String("authorizing")) {
0029         return Bolt::Status::Authorizing;
0030     } else if (str == QLatin1String("authorized")) {
0031         return Bolt::Status::Authorized;
0032     } else if (str == QLatin1String("auth-error")) {
0033         return Bolt::Status::AuthError;
0034     } else {
0035         qCCritical(log_libkbolt, "Unknown Status enum value '%s'", qUtf8Printable(str));
0036         Q_ASSERT(false);
0037         return Bolt::Status::Unknown;
0038     }
0039 }
0040
0041 QString Bolt::statusToString(Bolt::Status status)
0042 {
0043     switch (status) {
0044     case Bolt::Status::Unknown:
0045         return QStringLiteral("unknown");
0046     case Bolt::Status::Disconnected:
0047         return QStringLiteral("disconnected");
0048     case Bolt::Status::Connecting:
0049         return QStringLiteral("connecting");
0050     case Bolt::Status::Connected:
0051         return QStringLiteral("connected");
0052     case Bolt::Status::Authorizing:
0053         return QStringLiteral("authorizing");
0054     case Bolt::Status::Authorized:
0055         return QStringLiteral("authorized");
0056     case Bolt::Status::AuthError:
0057         return QStringLiteral("auth-error");
0058     }
0059     Q_UNREACHABLE();
0060     return {};
0061 }
0062
0063 Bolt::AuthFlags Bolt::authFlagsFromString(const QString &str)
0064 {
0065 #if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
0066     const auto splitRef = str.splitRef(QStringLiteral("|"));
0067 #else
0068     const auto splitRef = str.split(QStringLiteral("|"));
0069 #endif
0070     Bolt::AuthFlags outFlags = Bolt::Auth::None;
0071     for (const auto &flag : splitRef) {
0072         const auto f = flag.trimmed();
0073         if (f == QLatin1String("none")) {
0074             outFlags |= Bolt::Auth::None;
0075         } else if (f == QLatin1String("nopcie")) {
0076             outFlags |= Bolt::Auth::NoPCIE;
0077         } else if (f == QLatin1String("secure")) {
0078             outFlags |= Bolt::Auth::Secure;
0079         } else if (f == QLatin1String("nokey")) {
0080             outFlags |= Bolt::Auth::NoKey;
0081         } else if (f == QLatin1String("boot")) {
0082             outFlags |= Bolt::Auth::Boot;
0083         } else {
0084             qCCritical(log_libkbolt, "Unknown AuthFlags enum value '%s'", qUtf8Printable(str));
0085             Q_ASSERT(false);
0086             return Bolt::Auth::None;
0087         }
0088     }
0089     return outFlags;
0090 }
0091
0092 QString Bolt::authFlagsToString(AuthFlags flags)
0093 {
0094     QStringList str;
0095     if (flags == AuthFlags(Bolt::Auth::None)) {
0096         return QStringLiteral("none");
0097     }
0098     if (flags & Bolt::Auth::NoPCIE) {
0099         str.push_back(QStringLiteral("nopcie"));
0100     }
0101     if (flags & Bolt::Auth::Secure) {
0102         str.push_back(QStringLiteral("secure"));
0103     }
0104     if (flags & Bolt::Auth::NoKey) {
0105         str.push_back(QStringLiteral("nokey"));
0106     }
0107     if (flags & Bolt::Auth::Boot) {
0108         str.push_back(QStringLiteral("boot"));
0109     }
0110
0111     return str.join(QStringLiteral(" | "));
0112 }
0113
0114 Bolt::KeyState Bolt::keyStateFromString(const QString &str)
0115 {
0116     if (str == QLatin1String("unknown")) {
0117         return Bolt::KeyState::Unknown;
0118     } else if (str == QLatin1String("missing")) {
0119         return Bolt::KeyState::Missing;
0120     } else if (str == QLatin1String("have")) {
0121         return Bolt::KeyState::Have;
0122     } else if (str == QLatin1String("new")) {
0123         return Bolt::KeyState::New;
0124     } else {
0125         qCCritical(log_libkbolt, "Unknown KeyState enum value '%s'", qUtf8Printable(str));
0126         Q_ASSERT(false);
0127         return Bolt::KeyState::Unknown;
0128     }
0129 }
0130
0131 Bolt::Policy Bolt::policyFromString(const QString &str)
0132 {
0133     if (str == QLatin1String("unknown")) {
0134         return Bolt::Policy::Unknown;
0135     } else if (str == QLatin1String("default")) {
0136         return Bolt::Policy::Default;
0137     } else if (str == QLatin1String("manual")) {
0138         return Bolt::Policy::Manual;
0139     } else if (str == QLatin1String("auto")) {
0140         return Bolt::Policy::Auto;
0141     } else {
0142         qCCritical(log_libkbolt, "Unknown Policy enum value '%s'", qUtf8Printable(str));
0143         Q_ASSERT(false);
0144         return Bolt::Policy::Unknown;
0145     }
0146 }
0147
0148 QString Bolt::policyToString(Bolt::Policy policy)
0149 {
0150     switch (policy) {
0151     case Policy::Unknown:
0152         return QStringLiteral("unknown");
0153     case Policy::Auto:
0154         return QStringLiteral("auto");
0155     case Policy::Default:
0156         return QStringLiteral("default");
0157     case Policy::Manual:
0158         return QStringLiteral("manual");
0159     }
0160
0161     Q_UNREACHABLE();
0162     return {};
0163 }
0164
0165 Bolt::Type Bolt::typeFromString(const QString &str)
0166 {
0167     if (str == QLatin1String("unknown")) {
0168         return Bolt::Type::Unknown;
0169     } else if (str == QLatin1String("host")) {
0170         return Bolt::Type::Host;
0171     } else if (str == QLatin1String("peripheral")) {
0172         return Bolt::Type::Peripheral;
0173     } else {
0174         qCCritical(log_libkbolt, "Unknown Type enum value '%s'", qUtf8Printable(str));
0175         Q_ASSERT(false);
0176         return Bolt::Type::Unknown;
0177     }
0178 }
0179
0180 Bolt::AuthMode Bolt::authModeFromString(const QString &str)
0181 {
0182     if (str == QLatin1String("disabled")) {
0183         return Bolt::AuthMode::Disabled;
0184     } else if (str == QLatin1String("enabled")) {
0185         return Bolt::AuthMode::Enabled;
0186     } else {
0187         qCCritical(log_libkbolt, "Unknown AuthMode enum value '%s'", qUtf8Printable(str));
0188         Q_ASSERT(false);
0189         return Bolt::AuthMode::Disabled;
0190     }
0191 }
0192
0193 QString Bolt::authModeToString(Bolt::AuthMode authMode)
0194 {
0195     switch (authMode) {
0196     case Bolt::AuthMode::Enabled:
0197         return QStringLiteral("enabled");
0198     case Bolt::AuthMode::Disabled:
0199         return QStringLiteral("disabled");
0200     }
0201
0202     Q_UNREACHABLE();
0203     return {};
0204 }
0205
0206 Bolt::Security Bolt::securityFromString(const QString &str)
0207 {
0208     if (str == QLatin1String("unknown")) {
0209         return Bolt::Security::Unknown;
0210     } else if (str == QLatin1String("none")) {
0211         return Bolt::Security::None;
0212     } else if (str == QLatin1String("dponly")) {
0213         return Bolt::Security::DPOnly;
0214     } else if (str == QLatin1String("user")) {
0215         return Bolt::Security::User;
0216     } else if (str == QLatin1String("secure")) {
0217         return Bolt::Security::Secure;
0218     } else if (str == QLatin1String("usbonly")) {
0219         return Bolt::Security::USBOnly;
0220     } else {
0221         qCCritical(log_libkbolt, "Unknown Security enum value '%s'", qUtf8Printable(str));
0222         Q_ASSERT(false);
0223         return Bolt::Security::Unknown;
0224     }
0225 }