coredbsearchxml.h

Go to the documentation of this file.

/* ============================================================
 *
 * This file is a part of digiKam project
 * https://www.digikam.org
 *
 * Date        : 2008-01-09
 * Description : Core database searches XML queries manager
 *
 * Copyright (C) 2008-2012 by Marcel Wiesweg <marcel dot wiesweg at gmx dot de>
 * Copyright (C) 2010-2022 by Gilles Caulier <caulier dot gilles at gmail dot com>
 *
 * 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, 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.
 *
 * ============================================================ */
 
#ifndef DIGIKAM_CORE_DB_SEARCH_XML_H
#define DIGIKAM_CORE_DB_SEARCH_XML_H
 
// Qt includes
 
#include <QString>
#include <QDateTime>
#include <QXmlStreamReader>
#include <QXmlStreamWriter>
#include <QStringList>
#include <QVariant>
 
// Local includes
 
#include "digikam_export.h"
 
namespace Digikam
{
 
namespace SearchXml
{
 
enum Operator
{
    And,
    Or,
    AndNot,
    OrNot
};
 
enum Element
{
    Search,
    Group,
    GroupEnd,
    Field,
    FieldEnd,
    End
};
 
enum Relation
{
    Equal,
    Unequal,
    Like,
    NotLike,
    LessThan,
    GreaterThan,
    LessThanOrEqual,
    GreaterThanOrEqual,
    Interval,          // [a,b]
    IntervalOpen,      // (a,b)
    OneOf,
    AllOf,
    InTree,
    NotInTree,
    Near,
    Inside
};
 
template <typename T>
bool testRelation(T v1, T v2, Relation rel)
{
    if      (rel == Equal)
    {
        return v1 == v2;
    }
    else if (rel == Unequal)
    {
        return v1 != v2;
    }
    else if (rel == LessThan)
    {
        return v1 < v2;
    }
    else if (rel == LessThanOrEqual)
    {
        return v1 <= v2;
    }
    else if (rel == GreaterThan)
    {
        return v1 > v2;
    }
    else if (rel == GreaterThanOrEqual)
    {
        return v1 >= v2;
    }
 
    return false;
}
 
inline SearchXml::Operator standardGroupOperator()
{
    return SearchXml::Or;
}
 
inline SearchXml::Operator standardFieldOperator()
{
    return SearchXml::And;
}
 
inline SearchXml::Relation standardFieldRelation()
{
    return SearchXml::Equal;
}
 
} // namespace SearchXml
 
// ---------------------------------------------------------------------------------
 
class DIGIKAM_DATABASE_EXPORT SearchXmlReader : public QXmlStreamReader
{
public:
 
    explicit SearchXmlReader(const QString& xml);
 
    SearchXml::Element  readNext();
 
    bool                isGroupElement() const;
 
    bool                isFieldElement() const;
 
    SearchXml::Operator groupOperator() const;
 
    QString             groupCaption() const;
 
    SearchXml::Operator defaultFieldOperator() const;
 
    SearchXml::Operator fieldOperator() const;
    QString             fieldName() const;
    SearchXml::Relation fieldRelation() const;
 
    QString             value();
    int                 valueToInt();
    qlonglong           valueToLongLong();
    double              valueToDouble();
    QDateTime           valueToDateTime();
    QList<int>          valueToIntList();
    QList<qlonglong>    valueToLongLongList();
    QList<double>       valueToDoubleList();
    QStringList         valueToStringList();
    QList<QDateTime>    valueToDateTimeList();
 
    QList<int>          valueToIntOrIntList();
    QList<double>       valueToDoubleOrDoubleList();
    QList<QString>      valueToStringOrStringList();
 
    bool readToStartOfElement(const QString& name);
 
    void readToEndOfElement();
 
    void readToFirstField();
 
protected:
 
    SearchXml::Operator readOperator(const QString&, SearchXml::Operator) const;
    SearchXml::Relation readRelation(const QString&, SearchXml::Relation) const;
 
protected:
 
    SearchXml::Operator m_defaultFieldOperator;
};
 
// ---------------------------------------------------------------------------------
 
class DIGIKAM_DATABASE_EXPORT SearchXmlWriter : public QXmlStreamWriter
{
public:
 
    explicit SearchXmlWriter();
 
    void writeGroup();
 
    void setGroupOperator(SearchXml::Operator op);
 
    void setGroupCaption(const QString& caption);
 
    void setDefaultFieldOperator(SearchXml::Operator op);
 
    void writeField(const QString& name, SearchXml::Relation relation);
 
    void setFieldOperator(SearchXml::Operator op);
 
    void writeValue(const QString& value);
    void writeValue(int value);
    void writeValue(qlonglong value);
    void writeValue(float value, int precision = 6);
    void writeValue(double value, int precision = 8);
    void writeValue(const QDateTime& dateTime);
    void writeValue(const QList<int>& valueList);
    void writeValue(const QList<qlonglong>& valueList);
    void writeValue(const QList<float>& valueList, int precision = 6);
    void writeValue(const QList<double>& valueList, int precision = 8);
    void writeValue(const QStringList& valueList);
    void writeValue(const QList<QDateTime>& valueList);
 
    void finishField();
 
    void finishGroup();
 
    void finish();
 
    QString xml() const;
 
    static QString keywordSearch(const QString& keyword);
 
protected:
 
    void writeOperator(const QString&, SearchXml::Operator);
    void writeRelation(const QString&, SearchXml::Relation);
 
protected:
 
    QString m_xml;
};
 
// ---------------------------------------------------------------------------------
 
namespace KeywordSearch
{
 
DIGIKAM_DATABASE_EXPORT QStringList split(const QString& string);
 
DIGIKAM_DATABASE_EXPORT QString merge(const QStringList& keywordList);
 
DIGIKAM_DATABASE_EXPORT QString merge(const QString& previousContent, const QString& newEntry);
 
} // namespace KeywordSearch
 
// ---------------------------------------------------------------------------------
 
class DIGIKAM_DATABASE_EXPORT KeywordSearchReader : public SearchXmlReader
{
public:
 
    explicit KeywordSearchReader(const QString& xml);
 
    QStringList keywords();
 
    bool isSimpleKeywordSearch();
 
private:
 
    void    readGroup(QStringList& list);
    bool    isSimpleKeywordSearchGroup();
    QString readField();
};
 
// ---------------------------------------------------------------------------------
 
class DIGIKAM_DATABASE_EXPORT KeywordSearchWriter : public SearchXmlWriter
{
public:
 
    explicit KeywordSearchWriter();
 
    QString xml(const QStringList& keywordList);
};
 
// ---------------------------------------------------------------------------------
 
class DIGIKAM_DATABASE_EXPORT SearchXmlCachingReader : public SearchXmlReader
{
public:
 
    explicit SearchXmlCachingReader(const QString& xml);
 
    SearchXml::Element  readNext();
 
    SearchXml::Operator groupOperator() const;
    QString             groupCaption()  const;
 
    SearchXml::Operator fieldOperator() const;
    QString             fieldName()     const;
    SearchXml::Relation fieldRelation() const;
    QString             value();
    int                 valueToInt();
    qlonglong           valueToLongLong();
    double              valueToDouble();
    QDateTime           valueToDateTime();
    QList<int>          valueToIntList();
    QList<qlonglong>    valueToLongLongList();
    QList<double>       valueToDoubleList();
    QStringList         valueToStringList();
    QList<QDateTime>    valueToDateTimeList();
    QList<int>          valueToIntOrIntList();
    QList<double>       valueToDoubleOrDoubleList();
    QList<QString>      valueToStringOrStringList();
 
protected:
 
    SearchXml::Operator m_groupOperator;
    QString             m_groupCaption;
    SearchXml::Operator m_fieldOperator;
    QString             m_fieldName;
    SearchXml::Relation m_fieldRelation;
    QVariant            m_value;
    bool                m_readValue;
};
 
} // namespace Digikam
 
#endif // DIGIKAM_CORE_DB_SEARCH_XML_H