query.h

Go to the documentation of this file.

/*
   This file is part of the Nepomuk KDE project.
   Copyright (C) 2008-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 _NEPOMUK_QUERY_QUERY_H_
#define _NEPOMUK_QUERY_QUERY_H_

#include <QtCore/QSharedDataPointer>
#include <QtCore/QList>
#include <QtCore/QPair>
#include <QtCore/QDebug>

#include <kurl.h>

#include "property.h"

#include "nepomukquery_export.h"

class QTextStream;

namespace Nepomuk {
    namespace Query {

        class Term;
        class QueryPrivate;
        class FileQuery;

        typedef QHash<QString, Nepomuk::Types::Property> RequestPropertyMap;

        class NEPOMUKQUERY_EXPORT Query
        {
        public:
            Query();

            explicit Query( const Term& term );

            Query( const Query& );

            ~Query();

            Query& operator=( const Query& );

            Query& operator=( const Term& term );

            bool isValid() const;

            bool isFileQuery() const;

            FileQuery toFileQuery() const;

            Term term() const;

            int limit() const;

            int offset() const;

            void setTerm( const Term& );

            void setLimit( int );

            void setOffset( int offset );

            void setFullTextScoringEnabled( bool enabled );

            void setFullTextScoringSortOrder( Qt::SortOrder order );

            bool fullTextScoringEnabled() const;

            Qt::SortOrder fullTextScoringSortOrder() const;

            enum QueryFlag {
                NoQueryFlags = 0x0,

                NoResultRestrictions = 0x1,

                WithoutFullTextExcerpt = 0x2
            };
            Q_DECLARE_FLAGS( QueryFlags, QueryFlag )

            
            void setQueryFlags( QueryFlags flags );

            QueryFlags queryFlags() const;

            class NEPOMUKQUERY_EXPORT RequestProperty {
            public:
                RequestProperty( const Nepomuk::Types::Property& property,
                                 bool optional = true );

                RequestProperty( const RequestProperty& );

                ~RequestProperty();

                RequestProperty& operator=( const RequestProperty& );

                bool operator==( const RequestProperty& other ) const;

                Nepomuk::Types::Property property() const;

                bool optional() const;

            private:
                class Private;
                QSharedDataPointer<Private> d;
            };

            void addRequestProperty( const RequestProperty& property );

            void setRequestProperties( const QList<RequestProperty>& properties );

            QList<RequestProperty> requestProperties() const;

            enum SparqlFlag {
                NoFlags = 0x0,

                CreateCountQuery = 0x1,

                HandleInverseProperties = 0x2,

                CreateAskQuery = 0x4
            };
            Q_DECLARE_FLAGS( SparqlFlags, SparqlFlag )

            
            QString toSparqlQuery( SparqlFlags flags = NoFlags ) const;

            KUrl toSearchUrl( SparqlFlags flags = NoFlags ) const;

            KUrl toSearchUrl( const QString& customTitle, SparqlFlags flags = NoFlags ) const;

            RequestPropertyMap requestPropertyMap() const;

            bool operator==( const Query& query ) const;

            bool operator!=( const Query& query ) const;

            Query optimized() const;

            QString toString() const;

            static Query fromString( const QString& queryString );

            static Query fromQueryUrl( const KUrl& url );

            static QString sparqlFromQueryUrl( const KUrl& url );

            static QString titleFromQueryUrl( const KUrl& url );

        protected:
            QSharedDataPointer<QueryPrivate> d;
        };

        NEPOMUKQUERY_EXPORT Query operator&&( const Query& query, const Term& term );

        NEPOMUKQUERY_EXPORT Query operator||( const Query& query, const Term& term );

        NEPOMUKQUERY_EXPORT Query operator!( const Query& query );

        NEPOMUKQUERY_EXPORT uint qHash( const Nepomuk::Query::Query& );
    }
}

Q_DECLARE_OPERATORS_FOR_FLAGS( Nepomuk::Query::Query::SparqlFlags )
Q_DECLARE_OPERATORS_FOR_FLAGS( Nepomuk::Query::Query::QueryFlags )

NEPOMUKQUERY_EXPORT QDebug operator<<( QDebug, const Nepomuk::Query::Query& );

#endif