#include <kis_meta_data_value.h>

Public Types
enum	ValueType { Invalid , Variant , OrderedArray , UnorderedArray , AlternativeArray , LangArray , Structure , Rational }
	Define the possible value type. More...

Public Member Functions
void	addPropertyQualifier (const QString &_name, const Value &)

QList< KisMetaData::Value >	asArray () const

double	asDouble () const

int	asInteger () const

QMap< QString, KisMetaData::Value >	asLangArray () const

KisMetaData::Rational	asRational () const

QMap< QString, KisMetaData::Value >	asStructure () const

QVariant	asVariant () const

bool	isArray () const

Value &	operator+= (const Value &)

Value &	operator= (const Value &v)

bool	operator== (const Value &) const

const QMap< QString, Value > &	propertyQualifiers () const

bool	setArrayVariant (int index, const QVariant &variant)

bool	setStructureVariant (const QString &fieldNAme, const QVariant &variant)

bool	setVariant (const QVariant &variant)

QString	toString () const

ValueType	type () const

	Value ()

	Value (const KisMetaData::Rational &rational)

	Value (const QList< Value > &array, ValueType type=OrderedArray)

	Value (const QMap< QString, Value > &structure)

	Value (const QVariant &value)

	Value (const Value &v)

	~Value ()

Private Attributes
Private *const	d

Detailed Description

Value is build on top of QVariant to extend it to support the various types and extensions through property qualifiers.

Definition at line 34 of file kis_meta_data_value.h.

Member Enumeration Documentation

◆ ValueType

enum KisMetaData::Value::ValueType

Define the possible value type.

Enumerator
Invalid
Variant
OrderedArray
UnorderedArray
AlternativeArray
LangArray
Structure
Rational

Definition at line 39 of file kis_meta_data_value.h.

                   {
        Invalid,
        Variant,
        OrderedArray,
        UnorderedArray,
        AlternativeArray,
        LangArray,
        Structure,
        Rational
    };

Constructor & Destructor Documentation

◆ Value() [1/6]

Value::Value ( )

Definition at line 31 of file kis_meta_data_value.cc.

             : d(new Private)
{
    d->type = Invalid;
}

References d, and Invalid.

◆ Value() [2/6]

KisMetaData::Value::Value ( const QVariant & value )

◆ Value() [3/6]

Value::Value	(	const QList< Value > &	array,
		ValueType	type = OrderedArray )

Parameters

type	is one of OrderedArray, UnorderedArray, AlternativeArray or LangArray

Definition at line 43 of file kis_meta_data_value.cc.

                                                      : d(new Private)
{
    Q_ASSERT(type == OrderedArray || type == UnorderedArray || type == AlternativeArray || type == LangArray);
    d->value.array = new QList<Value>(array);
    d->type = type; // TODO: I am hesitating about LangArray to keep them as array or convert them to maps
}

References AlternativeArray, d, LangArray, OrderedArray, type(), and UnorderedArray.

◆ Value() [4/6]

Value::Value ( const QMap< QString, Value > & structure )

Definition at line 50 of file kis_meta_data_value.cc.

                                                  : d(new Private)
{
    d->type = Structure;
    d->value.structure = new QMap<QString, Value>(structure);
}

References d, and Structure.

◆ Value() [5/6]

KisMetaData::Value::Value ( const KisMetaData::Rational & rational )

◆ Value() [6/6]

Value::Value ( const Value & v )

Definition at line 63 of file kis_meta_data_value.cc.

                           : d(new Private)
{
    d->type = Invalid;
    *this = v;
}

References d, Invalid, and v.

◆ ~Value()

Value::~Value ( )

Definition at line 95 of file kis_meta_data_value.cc.

{
    delete d;
}

References d.

Member Function Documentation

◆ addPropertyQualifier()

void Value::addPropertyQualifier	(	const QString &	_name,
		const Value &	_value )

Definition at line 100 of file kis_meta_data_value.cc.

{
    d->propertyQualifiers[_name] = _value;
}

References d.

◆ asArray()

QList< Value > Value::asArray ( ) const

Returns: the array hold by this Value, or an empty array if this Value is not either an OrderedArray, UnorderedArray or AlternativeArray

Definition at line 208 of file kis_meta_data_value.cc.

{
    if (isArray()) {
        return *d->value.array;
    }
    return QList<Value>();
}

References d, and isArray().

◆ asDouble()

double Value::asDouble ( ) const

Returns: the value as a double, or null if it's not possible, rationals are evaluated

Definition at line 115 of file kis_meta_data_value.cc.

{
    switch (type()) {
    case Variant:
        return d->value.variant->toDouble(0);
    case Rational:
        return d->value.rational->numerator / (double)d->value.rational->denominator;
    default:
        return 0.0;
    }
    return 0.0;
}

References d, Rational, type(), and Variant.

◆ asInteger()

int Value::asInteger ( ) const

Returns: the value as an integer, or null if it's not possible, rationals are evaluated

Definition at line 128 of file kis_meta_data_value.cc.

{
    switch (type()) {
    case Variant:
        return d->value.variant->toInt(0);
    case Rational:
        return d->value.rational->numerator / d->value.rational->denominator;
    default:
        return 0;
    }
    return 0;
}

References d, Rational, type(), and Variant.

◆ asLangArray()

QMap< QString, KisMetaData::Value > Value::asLangArray ( ) const

It's a convenient function that build a map from a LangArray using the property qualifier "xml:lang" for the key of the map.

Definition at line 386 of file kis_meta_data_value.cc.

{
    Q_ASSERT(d->type == LangArray);
    QMap<QString, KisMetaData::Value> langArray;
    Q_FOREACH (const KisMetaData::Value& val, *d->value.array) {
        Q_ASSERT(val.d->propertyQualifiers.contains("xml:lang"));  // TODO probably worth to have an assert for this in the constructor as well
        KisMetaData::Value valKeyVal = val.d->propertyQualifiers.value("xml:lang");
        Q_ASSERT(valKeyVal.type() == Variant);
        QVariant valKeyVar = valKeyVal.asVariant();
        Q_ASSERT(valKeyVar.type() == QVariant::String);
        langArray[valKeyVar.toString()] = val;
    }
    return langArray;
}

References asVariant(), d, LangArray, type(), and Variant.

◆ asRational()

KisMetaData::Rational Value::asRational ( ) const

Returns: the Rational hold by this Value, or a null rational if this Value is not an Rational

Definition at line 200 of file kis_meta_data_value.cc.

{
    if (d->type == Rational) {
        return *d->value.rational;
    }
    return KisMetaData::Rational();
}

References d.

◆ asStructure()

QMap< QString, KisMetaData::Value > Value::asStructure ( ) const

Returns: the structure hold by this Value, or an empty structure if this Value is not a Structure

Definition at line 222 of file kis_meta_data_value.cc.

{
    if (type() == Structure) {
        return *d->value.structure;
    }
    return QMap<QString, KisMetaData::Value>();
}

References d, Structure, and type().

◆ asVariant()

QVariant Value::asVariant ( ) const

Returns: the Variant hold by this Value, or an empty QVariant if this Value is not a Variant

Definition at line 141 of file kis_meta_data_value.cc.

{
    switch (type()) {
    case Variant:
        return *d->value.variant;
    case Rational:
        return QVariant(QString("%1 / %2").arg(d->value.rational->numerator).arg(d->value.rational->denominator));
    default: break;
    }
    return QVariant();
}

References d, Rational, type(), and Variant.

◆ isArray()

bool Value::isArray ( ) const

Returns: true if this Value is either an OrderedArray, UnorderedArray or AlternativeArray

Definition at line 217 of file kis_meta_data_value.cc.

{
    return type() == OrderedArray || type() == UnorderedArray || type() == AlternativeArray;
}

References AlternativeArray, OrderedArray, type(), and UnorderedArray.

◆ operator+=()

Value & Value::operator+= ( const Value & v )

Definition at line 276 of file kis_meta_data_value.cc.

{
    switch (d->type) {
    case Value::Invalid:
        Q_ASSERT(v.type() == Value::Invalid);
        break;
    case Value::Variant:
        Q_ASSERT(v.type() == Value::Variant);
        {
            QVariant v1 = *d->value.variant;
            QVariant v2 = *v.d->value.variant;
            Q_ASSERT(v2.canConvert(v1.type()));
            switch (v1.type()) {
            default:
                warnMetaData << "KisMetaData: Merging metadata of type" << v1.type() << "is unsupported!";
                break;
            case QVariant::Date:
                *d->value.variant = qMax(v1.toDate(), v2.toDate());
                break;
            case QVariant::DateTime:
                *d->value.variant = qMax(v1.toDate(), v2.toDate());
                break;
            case QVariant::Double:
                *d->value.variant = v1.toDouble() + v2.toDouble();
                break;
            case QVariant::Int:
                *d->value.variant = v1.toInt() + v2.toInt();
                break;
            case QVariant::List:
                *d->value.variant = v1.toList() + v2.toList();
                break;
            case QVariant::LongLong:
                *d->value.variant = v1.toLongLong() + v2.toLongLong();
                break;
            case QVariant::Point:
                *d->value.variant = v1.toPoint() + v2.toPoint();
                break;
            case QVariant::PointF:
                *d->value.variant = v1.toPointF() + v2.toPointF();
                break;
            case QVariant::String:
                *d->value.variant = QVariant(v1.toString() + v2.toString());
                break;
            case QVariant::StringList:
                *d->value.variant = v1.toStringList() + v2.toStringList();
                break;
            case QVariant::Time: {
                QTime t1 = v1.toTime();
                QTime t2 = v2.toTime();
                int h = t1.hour() + t2.hour();
                int m = t1.minute() + t2.minute();
                int s = t1.second() + t2.second();
                int ms = t1.msec() + t2.msec();
                if (ms > 999) {
                    ms -= 999; s++;
                }
                if (s > 60) {
                    s -= 60; m++;
                }
                if (m > 60) {
                    m -= 60; h++;
                }
                if (h > 24) {
                    h -= 24;
                }
                *d->value.variant = QTime(h, m, s, ms);
            }
            break;
            case QVariant::UInt:
                *d->value.variant = v1.toUInt() + v2.toUInt();
                break;
            case QVariant::ULongLong:
                *d->value.variant = v1.toULongLong() + v2.toULongLong();
                break;
            }
 
        }
        break;
    case Value::OrderedArray:
    case Value::UnorderedArray:
    case Value::AlternativeArray: {
        if (v.isArray()) {
            *(d->value.array) += *(v.d->value.array);
        } else {
            d->value.array->append(v);
        }
    }
    break;
    case Value::LangArray: {
        Q_ASSERT(v.type() == Value::LangArray);
    }
    break;
    case Value::Structure: {
        Q_ASSERT(v.type() == Value::Structure);
        break;
    }
    case Value::Rational: {
        Q_ASSERT(v.type() == Value::Rational);
        d->value.rational->numerator =
            (d->value.rational->numerator
             * v.d->value.rational->denominator)
            + (v.d->value.rational->numerator
               * d->value.rational->denominator);
        d->value.rational->denominator *= v.d->value.rational->denominator;
        break;
    }
    }
    return *this;
}

References AlternativeArray, d, Invalid, LangArray, OrderedArray, Rational, Structure, UnorderedArray, v, Variant, and warnMetaData.

◆ operator=()

Value & Value::operator= ( const Value & v )

Definition at line 69 of file kis_meta_data_value.cc.

{
    d->type = v.d->type;
    d->propertyQualifiers = v.d->propertyQualifiers;
    switch (d->type) {
    case Invalid:
        break;
    case Variant:
        d->value.variant = new QVariant(*v.d->value.variant);
        break;
    case OrderedArray:
    case UnorderedArray:
    case AlternativeArray:
    case LangArray:
        d->value.array = new QList<Value>(*v.d->value.array);
        break;
    case Structure:
        d->value.structure = new QMap<QString, Value>(*v.d->value.structure);
        break;
    case Rational:
        d->value.rational = new KisMetaData::Rational(*v.d->value.rational);
    }
    return *this;
}

References AlternativeArray, d, Invalid, LangArray, OrderedArray, Rational, Structure, UnorderedArray, v, and Variant.

◆ operator==()

bool Value::operator== ( const Value & rhs ) const

Definition at line 255 of file kis_meta_data_value.cc.

{
    if (d->type != rhs.d->type) return false;
    switch (d->type) {
    case Value::Invalid:
        return true;
    case Value::Variant:
        return asVariant() == rhs.asVariant();
    case Value::OrderedArray:
    case Value::UnorderedArray:
    case Value::AlternativeArray:
    case Value::LangArray:
        return asArray() == rhs.asArray();
    case Value::Structure:
        return asStructure() == rhs.asStructure();
    case Value::Rational:
        return asRational() == rhs.asRational();
    }
    return false;
}

References AlternativeArray, asArray(), asRational(), asStructure(), asVariant(), d, Invalid, LangArray, OrderedArray, Rational, Structure, UnorderedArray, and Variant.

◆ propertyQualifiers()

const QMap< QString, Value > & KisMetaData::Value::propertyQualifiers ( ) const

◆ setArrayVariant()

bool Value::setArrayVariant	(	int	index,
		const QVariant &	variant )

Definition at line 189 of file kis_meta_data_value.cc.

{
    if (isArray()) {
        for (int i = d->value.array->size(); i <= index; ++i) {
            d->value.array->append(Value());
        }
        (*d->value.array)[index].setVariant(variant);
    }
    return false;
}

References d, isArray(), setVariant(), and Value().

◆ setStructureVariant()

bool Value::setStructureVariant	(	const QString &	fieldNAme,
		const QVariant &	variant )

Definition at line 181 of file kis_meta_data_value.cc.

{
    if (type() == Structure) {
        return (*d->value.structure)[fieldNAme].setVariant(variant);
    }
    return false;
}

References d, Structure, and type().

◆ setVariant()

bool Value::setVariant ( const QVariant & variant )

Set this Value to the given variant, or does nothing if this Value is not a Variant.

Returns: true if the value was changed

Definition at line 153 of file kis_meta_data_value.cc.

{
    switch (type()) {
    case KisMetaData::Value::Invalid:
        *this = KisMetaData::Value(variant);
        return true;
    case Rational: {
        QRegExp rx("([^\\/]*)\\/([^\\/]*)");
        rx.indexIn(variant.toString());
        // TODO: erm... did someone forgot to write actual code here?
 
        // for now just safe assert and return a failure
        KIS_SAFE_ASSERT_RECOVER_NOOP(0 && "Rational metadata values are not implemented!");
        return false;
    }
    case KisMetaData::Value::Variant: {
        if (d->value.variant->type() == variant.type()) {
            *d->value.variant = variant;
            return true;
        }
    }
    return true;
    default:
        break;
    }
    return false;
}

References d, Invalid, KIS_SAFE_ASSERT_RECOVER_NOOP, Rational, type(), and Variant.

◆ toString()

QString Value::toString ( ) const

Definition at line 401 of file kis_meta_data_value.cc.

{
    switch (type()) {
    case Value::Invalid:
        return i18n("Invalid value.");
    case Value::Variant:
        return d->value.variant->toString();
        break;
    case Value::OrderedArray:
    case Value::UnorderedArray:
    case Value::AlternativeArray:
    case Value::LangArray: {
        QString r = QString("[%1]{ ").arg(d->value.array->size());
        for (int i = 0; i < d->value.array->size(); ++i) {
            const Value& val = d->value.array->at(i);
            r += val.toString();
            if (i != d->value.array->size() - 1) {
                r += ',';
            }
            r += ' ';
        }
        r += '}';
        return r;
    }
    case Value::Structure: {
        QString r = "{ ";
        QList<QString> fields = d->value.structure->keys();
        for (int i = 0; i < fields.count(); ++i) {
            const QString& field = fields[i];
            const Value& val = d->value.structure->value(field);
            r += field + " => " + val.toString();
            if (i != d->value.array->size() - 1) {
                r += ',';
            }
            r += ' ';
        }
        r += '}';
        return r;
    }
    break;
    case Value::Rational:
        return QString("%1 / %2").arg(d->value.rational->numerator).arg(d->value.rational->denominator);
    }
    return i18n("Invalid value.");
}

References AlternativeArray, d, Invalid, LangArray, OrderedArray, Rational, Structure, toString(), type(), UnorderedArray, and Variant.

◆ type()

ValueType KisMetaData::Value::type ( ) const

Returns: the type of this Value

Member Data Documentation

◆ d

Private* const KisMetaData::Value::d

private

Definition at line 115 of file kis_meta_data_value.h.

The documentation for this class was generated from the following files:

libs/metadata/kis_meta_data_value.h
libs/metadata/kis_meta_data_value.cc

Public Types

Public Member Functions

Private Attributes

Detailed Description

Member Enumeration Documentation

◆ ValueType

Constructor & Destructor Documentation

◆ Value() [1/6]

◆ Value() [2/6]

◆ Value() [3/6]

◆ Value() [4/6]

◆ Value() [5/6]

◆ Value() [6/6]

◆ ~Value()

Member Function Documentation

◆ addPropertyQualifier()

◆ asArray()

◆ asDouble()

◆ asInteger()

◆ asLangArray()

◆ asRational()

◆ asStructure()

◆ asVariant()

◆ isArray()

◆ operator+=()

◆ operator=()

◆ operator==()

◆ propertyQualifiers()

◆ setArrayVariant()

◆ setStructureVariant()

◆ setVariant()

◆ toString()

◆ type()

Member Data Documentation

◆ d