term.h

Go to the documentation of this file.

/*
   This file is part of the Nepomuk KDE project.
   Copyright (C) 2007-2010 Sebastian Trueg <trueg@kde.org>

   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License version 2 as published by the Free Software Foundation.

   This library 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
   Library General Public License for more details.

   You should have received a copy of the GNU Library General Public License
   along with this library; see the file COPYING.LIB.  If not, write to
   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
   Boston, MA 02110-1301, USA.
 */

#ifndef _NEPOMUK2_SEARCH_TERM_H_
#define _NEPOMUK2_SEARCH_TERM_H_

#include <QtCore/QList>
#include <QtCore/QUrl>
#include <QtCore/QSharedDataPointer>

#include <Soprano/LiteralValue>

#include "nepomuk_export.h"

namespace Nepomuk2 {

    class Variant;

    namespace Types {
        class Property;
    }

    namespace Query {

        class LiteralTerm;
        class ResourceTerm;
        class NegationTerm;
        class AndTerm;
        class OrTerm;
        class ComparisonTerm;
        class ResourceTypeTerm;
        class OptionalTerm;

        class TermPrivate;

        class NEPOMUK_EXPORT Term
        {
        public:
            enum Type {
                Invalid,

                Literal,

                Resource,

                And,

                Or,

                Comparison,

                ResourceType,

                Negation,

                Optional
            };

            Term();

            Term( const Term& other );

            ~Term();

            Term& operator=( const Term& other );

            bool isValid() const;

            Type type() const;

            void setUserData( const QString& key, const QVariant& value );

            QVariant userData( const QString& key ) const;

            Term optimized() const;

            bool isLiteralTerm() const;

            bool isResourceTerm() const;

            bool isNegationTerm() const;

            bool isOptionalTerm() const;

            bool isAndTerm() const;

            bool isOrTerm() const;

            bool isComparisonTerm() const;

            bool isResourceTypeTerm() const;

            LiteralTerm toLiteralTerm() const;

            ResourceTerm toResourceTerm() const;

            NegationTerm toNegationTerm() const;

            OptionalTerm toOptionalTerm() const;

            AndTerm toAndTerm() const;

            OrTerm toOrTerm() const;

            ComparisonTerm toComparisonTerm() const;

            ResourceTypeTerm toResourceTypeTerm() const;

            LiteralTerm& toLiteralTerm();

            ResourceTerm& toResourceTerm();

            NegationTerm& toNegationTerm();

            OptionalTerm& toOptionalTerm();

            AndTerm& toAndTerm();

            OrTerm& toOrTerm();

            ComparisonTerm& toComparisonTerm();

            ResourceTypeTerm& toResourceTypeTerm();

            QString toString() const;

            static Term fromString( const QString& s );

            static Term fromVariant( const Variant& variant );

            static Term fromProperty( const Types::Property& property, const Variant& variant );

            bool operator==( const Term& term ) const;

            bool operator!=( const Term& term ) const;

            // FIXME: the compiler does not find this operator!
            QDebug operator<<( QDebug ) const;

        protected:
            Term( TermPrivate* );

            QSharedDataPointer<TermPrivate> d_ptr;

            friend class TermPrivate;
            friend class GroupTermPrivate;
            friend class AndTermPrivate;
            friend class OrTermPrivate;
            friend class ComparisonTermPrivate;
            friend class NegationTermPrivate;
            friend class OptionalTermPrivate;
            friend class Query;
            friend class QueryPrivate;
        };

        NEPOMUK_EXPORT Term operator&&( const Term& term1, const Term& term2 );

        NEPOMUK_EXPORT Term operator||( const Term& term1, const Term& term2 );

        NEPOMUK_EXPORT Term operator!( const Term& term );

        NEPOMUK_EXPORT ComparisonTerm operator<( const Types::Property& property, const Term& term );

        NEPOMUK_EXPORT ComparisonTerm operator>( const Types::Property& property, const Term& term );

        NEPOMUK_EXPORT ComparisonTerm operator<=( const Types::Property& property, const Term& term );

        NEPOMUK_EXPORT ComparisonTerm operator>=( const Types::Property& property, const Term& term );

        NEPOMUK_EXPORT ComparisonTerm operator==( const Types::Property& property, const Term& term );

        NEPOMUK_EXPORT Term operator!=( const Types::Property& property, const Term& term );

        NEPOMUK_EXPORT uint qHash( const Nepomuk2::Query::Term& );
    }

}

// there is a hand written instantiation of clone()
template<> Nepomuk2::Query::TermPrivate* QSharedDataPointer<Nepomuk2::Query::TermPrivate>::clone();
// FIXME: the compiler does not find the operator in the class
NEPOMUK_EXPORT QDebug operator<<( QDebug, const Nepomuk2::Query::Term& );

#endif