kis_xmp_io.cpp File Reference

#include "kis_xmp_io.h"
#include <string>
#include <QIODevice>
#include <QRegularExpression>
#include <kis_exiv2_common.h>
#include <kis_meta_data_entry.h>
#include <kis_meta_data_parser.h>
#include <kis_meta_data_schema.h>
#include <kis_meta_data_schema_registry.h>
#include <kis_meta_data_store.h>
#include <kis_meta_data_type_info.h>
#include <kis_meta_data_value.h>
#include <KisUsageLogger.h>
#include <kis_debug.h>

Go to the source code of this file.

Functions
std::string	exiv2Prefix (const KisMetaData::Schema *_schema)
bool	parseTagName (const QString &tagString, QString &structName, int &arrayIndex, QString &tagName, const KisMetaData::TypeInfo **typeInfo, const KisMetaData::Schema *schema)

Function Documentation

exiv2Prefix()

std::string exiv2Prefix ( const KisMetaData::Schema * _schema )

inline

Definition at line 36 of file kis_xmp_io.cpp.

{
    const QByteArray latin1SchemaUri = _schema->uri().toLatin1();
    std::string prefix = Exiv2::XmpProperties::prefix(latin1SchemaUri.constData());
    if (prefix.empty()) {
        dbgMetaData << "Unknown namespace " << ppVar(_schema->uri()) << ppVar(_schema->prefix());
        prefix = _schema->prefix().toLatin1().constData();
        Exiv2::XmpProperties::registerNs(latin1SchemaUri.constData(), prefix);
    }
    return prefix;
}

References dbgMetaData, ppVar, KisMetaData::Schema::prefix, and KisMetaData::Schema::uri.

parseTagName()

bool parseTagName	(	const QString &	tagString,
		QString &	structName,
		int &	arrayIndex,
		QString &	tagName,
		const KisMetaData::TypeInfo **	typeInfo,
		const KisMetaData::Schema *	schema )

We use Unicode-matching mode, because according to XML specification the name of an entity can contain Unicode characters.

Definition at line 167 of file kis_xmp_io.cpp.

{
    arrayIndex = -1;
    *typeInfo = 0;
 
    int numSubNames = tagString.count('/') + 1;
 
    if (numSubNames == 1) {
        structName.clear();
        tagName = tagString;
        *typeInfo = schema->propertyType(tagName);
        return true;
    }
 
    if (numSubNames == 2) {
        QRegularExpression regexp("([A-Za-z]\\w+)/([A-Za-z]\\w+):([A-Za-z]\\w+)");
        regexp.setPatternOptions(QRegularExpression::UseUnicodePropertiesOption);
 
        QRegularExpressionMatch match;
        if (tagString.contains(regexp, &match)) {
            structName = match.captured(1);
            tagName = match.captured(3);
            *typeInfo = schema->propertyType(structName);
 
            if (*typeInfo && (*typeInfo)->propertyType() == KisMetaData::TypeInfo::StructureType) {
                *typeInfo = (*typeInfo)->structureSchema()->propertyType(tagName);
            }
 
            return true;
        }
 
        QRegularExpression regexp2("([A-Za-z]\\w+)\\[(\\d+)\\]/([A-Za-z]\\w+):([A-Za-z]\\w+)");
        regexp2.setPatternOptions(QRegularExpression::UseUnicodePropertiesOption);
 
        QRegularExpressionMatch match2;
        if (tagString.contains(regexp2, &match2)) {
            structName = match2.captured(1);
            arrayIndex = match2.captured(2).toInt() - 1;
            tagName = match2.captured(4);
 
            if (schema->propertyType(structName)) {
                *typeInfo = schema->propertyType(structName)->embeddedPropertyType();
                Q_ASSERT(*typeInfo);
 
                if ((*typeInfo)->propertyType() == KisMetaData::TypeInfo::StructureType) {
                    *typeInfo = (*typeInfo)->structureSchema()->propertyType(tagName);
                }
            }
 
            return true;
        }
    }
 
    warnKrita << "WARNING: Unsupported tag. We do not yet support nested tags. The tag will be dropped!";
    warnKrita << "         Failing tag:" << tagString;
    return false;
}

References KisMetaData::TypeInfo::embeddedPropertyType(), KisMetaData::TypeInfo::propertyType(), KisMetaData::Schema::propertyType(), KisMetaData::TypeInfo::structureSchema(), KisMetaData::TypeInfo::StructureType, and warnKrita.