/usr/include/gammaray/core/varianthandler.h is in gammaray-dev 2.7.0-1ubuntu8.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 | /*
varianthandler.h
This file is part of GammaRay, the Qt application inspection and
manipulation tool.
Copyright (C) 2013-2017 Klarälvdalens Datakonsult AB, a KDAB Group company, info@kdab.com
Author: Volker Krause <volker.krause@kdab.com>
Licensees holding valid commercial KDAB GammaRay licenses may use this file in
accordance with GammaRay Commercial License Agreement provided with the Software.
Contact info@kdab.com if any conditions of this licensing are not clear to you.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef GAMMARAY_VARIANTHANDLER_H
#define GAMMARAY_VARIANTHANDLER_H
#include "gammaray_core_export.h"
#include <QVariant>
namespace GammaRay {
/** @brief Variant conversion functions, extendable by plugins. */
namespace VariantHandler {
///@cond internal
template<typename RetT> struct Converter
{
virtual RetT operator()(const QVariant &v) = 0;
};
template<typename RetT, typename InputT,
typename FuncT> struct ConverterImpl : public Converter<RetT>
{
explicit inline ConverterImpl(FuncT converter)
: f(converter)
{
}
RetT operator()(const QVariant &v) override
{
return f(v.value<InputT>());
}
FuncT f;
};
///@endcond
/**
* Returns a human readable string version of the QVariant value.
* Converts to the variant type and prints the string value accordingly.
* @param value is a QVariant.
*
* @return a QString containing the human readable string.
*/
GAMMARAY_CORE_EXPORT QString displayString(const QVariant &value);
/**
* Returns a human readable string version of the given value.
* Thihs is a convenience overload of the QVariant-based version above.
*
* @return a QString containing the human readable string.
*/
template<typename T>
inline QString displayString(T value) { return displayString(QVariant::fromValue<T>(value)); }
/**
* Returns a value representing @p value in a itemview decoration role.
* @param value is a QVariant.
*
* @return a QVariant itemview decoration role.
*/
GAMMARAY_CORE_EXPORT QVariant decoration(const QVariant &value);
/**
* Register a string conversion functions for a variant type.
* @internal
*/
GAMMARAY_CORE_EXPORT void registerStringConverter(int type, Converter<QString> *converter);
/**
* Register a string conversion function for a variant type.
* @tparam T The type for which to use this converter function.
*/
template<typename T, typename FuncT>
inline void registerStringConverter(FuncT f)
{
Converter<QString> *converter = new ConverterImpl<QString, T, FuncT>(f);
registerStringConverter(qMetaTypeId<T>(), converter);
}
typedef QString (*GenericStringConverter)(const QVariant &value, bool *ok);
/**
* Register a generic string conversion function for various variant types.
* This can be used when you have a converter that can dynamically check if
* it can handle a given variant, and the types it can handle aren't known
* at compile time (example: QQmlListProperty).
* @param converter The converter function. It's second parameter is used to
* indicate if the value could be handled.
*/
GAMMARAY_CORE_EXPORT void registerGenericStringConverter(GenericStringConverter converter);
/**
* Converts the given variant into an variant of a different type that can be transferred
* to another process.
* This is most prominently needed for pointer types, e.g. const QMatrix4x4* -> QMatrix4x4,
* primarily for the fancy display delegate on the client side.
*/
GAMMARAY_CORE_EXPORT QVariant serializableVariant(const QVariant &value);
///@cond internal
void clear();
///@endcond
}
}
#endif // GAMMARAY_VARIANTHANDLER_H
|