File indexing completed on 2024-05-12 15:59:16

 /*
  *  SPDX-FileCopyrightText: 2007 Cyrille Berger <cberger@cberger.net>
  *
  *  SPDX-License-Identifier: LGPL-2.1-or-later
  */
 
 #include "kis_meta_data_store.h"
 
 #include <QStringList>
 
 #include <kis_debug.h>
 
 #include "kis_meta_data_entry.h"
 #include "kis_meta_data_filter.h"
 #include "kis_meta_data_schema.h"
 #include "kis_meta_data_schema_registry.h"
 #include "kis_meta_data_value.h"
 
 using namespace KisMetaData;
 
 uint qHash(const Entry& e)
 {
     return qHash(e.qualifiedName());
 }
 
 struct Q_DECL_HIDDEN Store::Private {
     QHash<QString, Entry> entries;
 };
 
 Store::Store() : d(new Private)
 {
 
 }
 
 Store::Store(const Store& s) : d(new Private(*s.d))
 {
     // TODO: reaffect all schemas
 }
 
 Store::~Store()
 {
     delete d;
 }
 
 void Store::copyFrom(const Store* store)
 {
     for (QHash<QString, Entry>::const_iterator entryIt = store->begin();
             entryIt != store->end(); ++entryIt) {
         const Entry& entry = entryIt.value();
         if (entry.value().type() != KisMetaData::Value::Invalid) {
             if (containsEntry(entry.qualifiedName())) {
                 getEntry(entry.qualifiedName()).value() = entry.value();
             } else {
                 addEntry(entry);
             }
         }
     }
 }
 
 bool Store::addEntry(const Entry& entry)
 {
     Q_ASSERT(!entry.name().isEmpty());
     if (d->entries.contains(entry.qualifiedName()) && d->entries[entry.qualifiedName()].isValid()) {
         dbgMetaData << "Entry" << entry.qualifiedName() << " already exists in the store, cannot be included twice";
         return false;
     }
     d->entries.insert(entry.qualifiedName(), entry);
     return true;
 }
 
 bool Store::empty() const
 {
     return d->entries.isEmpty();
 }
 
 bool Store::isEmpty() const
 {
     return d->entries.isEmpty();
 }
 
 bool Store::containsEntry(const QString & entryKey) const
 {
     return d->entries.contains(entryKey);
 }
 
 bool Store::containsEntry(const QString & uri, const QString & entryName) const
 {
     const Schema* schema = SchemaRegistry::instance()->schemaFromUri(uri);
     return containsEntry(schema->generateQualifiedName(entryName));
 }
 
 bool Store::containsEntry(const KisMetaData::Schema* schema, const QString & entryName) const
 {
     if (schema) {
         return containsEntry(schema->generateQualifiedName(entryName));
     }
     return false;
 }
 
 Entry& Store::getEntry(const QString & entryKey)
 {
     if (!d->entries.contains(entryKey)) {
         QStringList splitKey = entryKey.split(':');
         QString prefix = splitKey[0];
         splitKey.pop_front();
         d->entries[entryKey] = Entry(SchemaRegistry::instance()->schemaFromPrefix(prefix),
                                      splitKey.join(":"),
                                      Value());
     }
     return d->entries [entryKey];
 }
 
 Entry& Store::getEntry(const QString & uri, const QString & entryName)
 {
     const Schema* schema = SchemaRegistry::instance()->schemaFromUri(uri);
     Q_ASSERT(schema);
     return getEntry(schema, entryName);
 }
 
 Entry& Store::getEntry(const KisMetaData::Schema* schema, const QString & entryName)
 {
     return getEntry(schema->generateQualifiedName(entryName));
 }
 
 
 const Entry& Store::getEntry(const QString & entryKey) const
 {
     return d->entries[entryKey];
 }
 
 const Entry& Store::getEntry(const QString & uri, const QString & entryName) const
 {
     const Schema* schema = SchemaRegistry::instance()->schemaFromUri(uri);
     Q_ASSERT(schema);
     return getEntry(schema, entryName);
 }
 
 const Entry& Store::getEntry(const KisMetaData::Schema* schema, const QString & entryName) const
 {
     return getEntry(schema->generateQualifiedName(entryName));
 }
 
 void Store::removeEntry(const QString & entryKey)
 {
     d->entries.remove(entryKey);
 }
 
 void Store::removeEntry(const QString & uri, const QString & entryName)
 {
     const Schema* schema = SchemaRegistry::instance()->schemaFromUri(uri);
     Q_ASSERT(schema);
     removeEntry(schema, entryName);
 }
 
 void Store::removeEntry(const KisMetaData::Schema* schema, const QString & entryName)
 {
     removeEntry(schema->generateQualifiedName(entryName));
 }
 
 const Value& Store::getValue(const QString & uri, const QString & entryName) const
 {
     return getEntry(uri, entryName).value();
 }
 
 QHash<QString, Entry>::const_iterator Store::begin() const
 {
     return d->entries.constBegin();
 }
 
 QHash<QString, Entry>::const_iterator Store::end() const
 {
     return d->entries.constEnd();
 }
 
 void Store::debugDump() const
 {
     dbgMetaData << "=== Dumping MetaData Store ===";
     dbgMetaData << " - Metadata (there are" << d->entries.size() << " entries)";
     Q_FOREACH (const Entry& e, d->entries) {
         if (e.isValid()) {
             dbgMetaData << e;
         } else {
             dbgMetaData << "Invalid entry";
         }
     }
 }
 
 void Store::applyFilters(const QList<const Filter*> & filters)
 {
     dbgMetaData << "Apply " << filters.size() << " filters";
     Q_FOREACH (const Filter* filter, filters) {
         filter->filter(this);
     }
 }
 
 QList<QString> Store::keys() const
 {
     return d->entries.keys();
 }
 
 QList<Entry> Store::entries() const
 {
     return d->entries.values();
 }