utilitytypes.h

Go to the documentation of this file.

/**********************************************************************
 * LeechCraft - modular cross-platform feature rich internet client.
 * Copyright (C) 2006-2014  Georg Rudoy
 *
 * Distributed under the Boost Software License, Version 1.0.
 * (See accompanying file LICENSE or copy at https://www.boost.org/LICENSE_1_0.txt)
 **********************************************************************/
 
#pragma once
 
#include <utility>
#include <QDataStream>
#include <QByteArray>
#include "oral.h"
 
namespace LC::Util::oral
{
    struct CharEnumTypeName
    {
        constexpr auto operator() () const noexcept
        {
            return "VARCHAR(1)"_ct;
        }
    };
 
    template<typename Fst, typename Snd>
    struct NttpPair
    {
        Fst first;
        Snd second;
    };
 
    template<typename Enum, NttpPair<Enum, char>... Chars>
        requires std::is_enum_v<Enum>
    struct ConvertEnum
    {
        static_assert (sizeof... (Chars) > 0);
 
        QVariant operator() (Enum val) const
        {
            for (const auto& [e, ch] : { Chars... })
                if (e == val)
                    return QString { QChar { ch } };
 
            throw std::runtime_error { "invalid enum value " + std::to_string (static_cast<int> (val)) };
        }
 
        Enum operator() (const QVariant& var) const
        {
            if (const auto& str = var.toString ();
                str.size () == 1)
            {
                const auto ch = str.at (0).toLatin1 ();
                for (const auto& [k, v] : { Chars... })
                    if (v == ch)
                        return k;
            }
 
            qWarning () << "invalid stored value:" << var;
            return Chars... [0].first;
        }
    };
 
    template<typename From, typename To, auto Cvt>
    concept Converter = requires (const From& from) { { std::invoke (Cvt, from) } -> std::same_as<To>; };
 
    template<typename T, typename Base, auto ToBaseType, auto FromBaseType>
        requires Converter<T, Base, ToBaseType> && Converter<Base, T, FromBaseType>
    struct ConvertVia
    {
        using BaseType = Base;
 
        static QVariant operator() (const T& t) noexcept (noexcept (std::invoke (ToBaseType, t)))
        {
            return Convert<BaseType> (std::invoke (ToBaseType, t));
        }
 
        static T operator() (const QVariant& var) noexcept (noexcept (std::invoke (FromBaseType, std::declval<const BaseType&> ())))
        {
            return std::invoke (FromBaseType, Convert<BaseType> (var));
        }
    };
 
    template<typename T>
    struct AsDataStream
    {
        T Val_;
 
        operator T () const &
        {
            return Val_;
        }
 
        operator T&& () &&
        {
            return std::move (Val_);
        }
 
        AsDataStream () = default;
        AsDataStream (const AsDataStream&) = default;
        AsDataStream (AsDataStream&&) = default;
 
        AsDataStream& operator= (const AsDataStream&) = default;
        AsDataStream& operator= (AsDataStream&&) = default;
 
        template<typename... Args>
        AsDataStream (Args&&... args)
        : Val_ { std::forward<Args> (args)... }
        {
        }
 
        template<typename U>
        AsDataStream& operator= (U&& val)
        {
            Val_ = std::forward<U> (val);
            return *this;
        }
 
        QByteArray ToByteArray () const
        {
            QByteArray ba;
            {
                QDataStream out { &ba, QIODevice::WriteOnly };
                out << Val_;
            }
            return ba;
        }
 
        static AsDataStream FromByteArray (const QByteArray& ba)
        {
            QDataStream in { ba };
 
            AsDataStream res;
            in >> res.Val_;
            return res;
        }
    };
 
    template<typename T>
    struct ConvertT<AsDataStream<T>>
        : ConvertVia<
                AsDataStream<T>,
                QByteArray,
                &AsDataStream<T>::ToByteArray,
                &AsDataStream<T>::FromByteArray
            > {};
}