#include <algorithm>
#include <string.h>
#include "Utils.h"
namespace ggk {
void Utils::trimBeginInPlace(std::string &str)
{
str.erase(str.begin(), std::find_if(str.begin(), str.end(),
[](int ch)
{
return !std::isspace(ch);
}));
}
void Utils::trimEndInPlace(std::string &str)
{
str.erase(std::find_if(str.rbegin(), str.rend(),
[](int ch)
{
return !std::isspace(ch);
}).base(), str.end());
}
void Utils::trimInPlace(std::string &str)
{
trimBeginInPlace(str);
trimEndInPlace(str);
}
std::string Utils::trimBegin(const std::string &str)
{
std::string out = str;
trimBeginInPlace(out);
return out;
}
std::string Utils::trimEnd(const std::string &str)
{
std::string out = str;
trimEndInPlace(out);
return out;
}
std::string Utils::trim(const std::string &str)
{
std::string out = str;
trimInPlace(out);
return out;
}
std::string Utils::hex(uint8_t value)
{
char hex[16];
sprintf(hex, "0x%02X", value);
return hex;
}
std::string Utils::hex(uint16_t value)
{
char hex[16];
sprintf(hex, "0x%04X", value);
return hex;
}
std::string Utils::hex(uint32_t value)
{
char hex[16];
sprintf(hex, "0x%08X", value);
return hex;
}
std::string Utils::hex(const uint8_t *pData, int count)
{
char hex[16];
std::string line;
std::vector<std::string> hexData;
for (int i = 0; i < count; ++i)
{
sprintf(hex, "%02X ", pData[i]);
line += hex;
if (line.length() >= 16 * 3)
{
hexData.push_back(line);
line = "";
}
}
if (!line.empty())
{
hexData.push_back(line);
line = "";
}
std::vector<std::string> asciiData;
for (int i = 0; i < count; ++i)
{
if (pData[i] < 0x20 || pData[i] > 0x7e)
{
line += ".";
}
else
{
line += pData[i];
}
if (line.length() >= 16)
{
asciiData.push_back(line);
line = "";
}
}
if (!line.empty())
{
asciiData.push_back(line);
}
std::string result = "";
size_t dataSize = hexData.size();
for (size_t i = 0; i < dataSize; ++i)
{
std::string hexPart = hexData[i];
hexPart.insert(hexPart.length(), 48-hexPart.length(), ' ');
std::string asciiPart = asciiData[i];
asciiPart.insert(asciiPart.length(), 16-asciiPart.length(), ' ');
result += std::string(" > ") + hexPart + " [" + asciiPart + "]";
if (i < dataSize - 1) { result += "\n"; }
}
return result;
}
std::string Utils::bluetoothAddressString(uint8_t *pAddress)
{
char hex[32];
snprintf(hex, sizeof(hex), "%02X:%02X:%02X:%02X:%02X:%02X",
pAddress[0], pAddress[1], pAddress[2], pAddress[3], pAddress[4], pAddress[5]);
return hex;
}
GVariant *Utils::gvariantFromString(const char *pStr)
{
return g_variant_new_string(pStr);
}
GVariant *Utils::gvariantFromString(const std::string &str)
{
return g_variant_new_string(str.c_str());
}
GVariant *Utils::gvariantFromStringArray(const char *pStr, va_list args)
{
if (pStr == 0)
{
return g_variant_new("as", nullptr);
}
g_auto(GVariantBuilder) builder;
g_variant_builder_init(&builder, G_VARIANT_TYPE_ARRAY);
while(nullptr != pStr)
{
g_variant_builder_add(&builder, "s", pStr);
pStr = va_arg(args, const char *);
}
return g_variant_builder_end(&builder);
}
GVariant *Utils::gvariantFromStringArray(const char *pStr, ...)
{
if (pStr == 0)
{
return g_variant_new("as", nullptr);
}
g_auto(GVariantBuilder) builder;
g_variant_builder_init(&builder, G_VARIANT_TYPE_ARRAY);
va_list args;
va_start(args, pStr);
GVariant *pResult = gvariantFromStringArray(pStr, args);
va_end(args);
return pResult;
}
GVariant *Utils::gvariantFromStringArray(const std::vector<std::string> &arr)
{
if (arr.empty())
{
return g_variant_new("as", nullptr);
}
g_auto(GVariantBuilder) builder;
g_variant_builder_init(&builder, G_VARIANT_TYPE_ARRAY);
for (std::string str : arr)
{
g_variant_builder_add(&builder, "s", str.c_str());
}
return g_variant_builder_end(&builder);
}
GVariant *Utils::gvariantFromStringArray(const std::vector<const char *> &arr)
{
if (arr.empty())
{
return g_variant_new("as", nullptr);
}
g_auto(GVariantBuilder) builder;
g_variant_builder_init(&builder, G_VARIANT_TYPE_ARRAY);
for (const char *pStr : arr)
{
g_variant_builder_add(&builder, "s", pStr);
}
return g_variant_builder_end(&builder);
}
GVariant *Utils::gvariantFromObject(const DBusObjectPath &path)
{
return g_variant_new_object_path(path.c_str());
}
GVariant *Utils::gvariantFromBoolean(bool b)
{
return g_variant_new_boolean(b);
}
GVariant *Utils::gvariantFromInt(gint16 value)
{
return g_variant_new_int16(value);
}
GVariant *Utils::gvariantFromInt(gint32 value)
{
return g_variant_new_int32(value);
}
GVariant *Utils::gvariantFromByteArray(const char *pStr)
{
if (*pStr == 0)
{
return g_variant_new("ay", nullptr);
}
return gvariantFromByteArray(reinterpret_cast<const guint8 *>(pStr), strlen(pStr));
}
GVariant *Utils::gvariantFromByteArray(const std::string &str)
{
return gvariantFromByteArray(reinterpret_cast<const guint8 *>(str.c_str()), str.length());
}
GVariant *Utils::gvariantFromByteArray(const guint8 *pBytes, int count)
{
GBytes *pGbytes = g_bytes_new(pBytes, count);
return g_variant_new_from_bytes(G_VARIANT_TYPE_BYTESTRING, pGbytes, count);
}
GVariant *Utils::gvariantFromByteArray(const std::vector<guint8> bytes)
{
GBytes *pGbytes = g_bytes_new(bytes.data(), bytes.size());
return g_variant_new_from_bytes(G_VARIANT_TYPE_BYTESTRING, pGbytes, bytes.size());
}
GVariant *Utils::gvariantFromByteArray(const guint8 data)
{
return gvariantFromByteArray((const guint8 *) &data, sizeof(data));
}
GVariant *Utils::gvariantFromByteArray(const gint8 data)
{
return gvariantFromByteArray((const guint8 *) &data, sizeof(data));
}
GVariant *Utils::gvariantFromByteArray(const guint16 data)
{
return gvariantFromByteArray((const guint8 *) &data, sizeof(data));
}
GVariant *Utils::gvariantFromByteArray(const gint16 data)
{
return gvariantFromByteArray((const guint8 *) &data, sizeof(data));
}
GVariant *Utils::gvariantFromByteArray(const guint32 data)
{
return gvariantFromByteArray((const guint8 *) &data, sizeof(data));
}
GVariant *Utils::gvariantFromByteArray(const gint32 data)
{
return gvariantFromByteArray((const guint8 *) &data, sizeof(data));
}
GVariant *Utils::gvariantFromByteArray(const guint64 data)
{
return gvariantFromByteArray((const guint8 *) &data, sizeof(data));
}
GVariant *Utils::gvariantFromByteArray(const gint64 data)
{
return gvariantFromByteArray((const guint8 *) &data, sizeof(data));
}
std::string Utils::stringFromGVariantByteArray(const GVariant *pVariant)
{
gsize size;
gconstpointer pPtr = g_variant_get_fixed_array(const_cast<GVariant *>(pVariant), &size, 1);
std::vector<gchar> array(size + 1, 0);
memcpy(array.data(), pPtr, size);
return array.data();
}
};