path: root/tools/assistant/lib/fulltextsearch/qquery.cpp

/****************************************************************************
**
** Copyright (C) 2003-2006 Ben van Klinken and the CLucene Team.
** All rights reserved.
**
** Portion Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
**
** This file may be used under the terms of the GNU Lesser General Public
** License version 2.1 as published by the Free Software Foundation and
** appearing in the file LICENSE.LGPL included in the packaging of this file.
** Please review the following information to ensure the GNU Lesser General
** Public License version 2.1 requirements will be met:
** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
****************************************************************************/

#include "qquery_p.h"
#include "qclucene_global_p.h"

#include <CLucene.h>
#include <CLucene/search/PhraseQuery.h>
#include <CLucene/search/SearchHeader.h>

QT_BEGIN_NAMESPACE

QCLuceneQueryPrivate::QCLuceneQueryPrivate()
    : QSharedData()
{
    query = 0;
    deleteCLuceneQuery = true;
}

QCLuceneQueryPrivate::QCLuceneQueryPrivate(const QCLuceneQueryPrivate &other)
    : QSharedData()
{
    query = _CL_POINTER(other.query);
    deleteCLuceneQuery = other.deleteCLuceneQuery;
}

QCLuceneQueryPrivate::~QCLuceneQueryPrivate()
{
    if (deleteCLuceneQuery)
        _CLDECDELETE(query);
}


QCLuceneQuery::QCLuceneQuery()
    : d(new QCLuceneQueryPrivate())
{
    // nothing todo, private
}

QCLuceneQuery::~QCLuceneQuery()
{
    // nothing todo
}

void QCLuceneQuery::setBoost(qreal boost)
{
    d->query->setBoost(qreal(boost));
}

qreal QCLuceneQuery::getBoost() const
{
    return qreal(d->query->getBoost());
}

QString QCLuceneQuery::getQueryName() const
{
    return TCharToQString(d->query->getQueryName());
}

bool QCLuceneQuery::instanceOf(const QString &other) const
{
	if (other == getQueryName())
		return true;

	return false;
}

QString QCLuceneQuery::toString(const QString &field) const
{
    TCHAR *fieldName = QStringToTChar(field);
    QString retValue = TCharToQString(d->query->toString(fieldName));
    delete [] fieldName;

    return retValue;
}

quint32 QCLuceneQuery::hashCode() const
{
    return quint32(d->query->hashCode());
}

QString QCLuceneQuery::toString() const
{
    return TCharToQString(d->query->toString());
}

bool QCLuceneQuery::equals(const QCLuceneQuery &other) const
{
    return d->query->equals(other.d->query);
}


QCLucenePrefixQuery::QCLucenePrefixQuery(const QCLuceneTerm &prefix)
    : QCLuceneQuery()
    , prefix(prefix)
{
    d->query = new lucene::search::PrefixQuery(prefix.d->term);
}

QCLucenePrefixQuery::~QCLucenePrefixQuery()
{
    // nothing todo
}

QString QCLucenePrefixQuery::getClassName()
{
    return TCharToQString(lucene::search::PrefixQuery::getClassName());
}

QCLuceneTerm QCLucenePrefixQuery::getPrefix() const
{
    return prefix;
}


QCLuceneRangeQuery::QCLuceneRangeQuery(const QCLuceneTerm &lowerTerm,
                                       const QCLuceneTerm &upperTerm,
                                       bool inclusive)
    : QCLuceneQuery()
    , lowerTerm(lowerTerm)
    , upperTerm(upperTerm)
{
    d->query = new lucene::search::RangeQuery(lowerTerm.d->term,
        upperTerm.d->term, inclusive);
}

QCLuceneRangeQuery::~QCLuceneRangeQuery()
{
    // nothing todo
}

QString QCLuceneRangeQuery::getClassName()
{
    return TCharToQString(lucene::search::RangeQuery::getClassName());
}

QCLuceneTerm QCLuceneRangeQuery::getLowerTerm() const
{
    return lowerTerm;
}

QCLuceneTerm QCLuceneRangeQuery::getUpperTerm() const
{
    return upperTerm;
}

bool QCLuceneRangeQuery::isInclusive() const
{
    lucene::search::RangeQuery *query = 
        static_cast<lucene::search::RangeQuery*> (d->query);

    if (query == 0)
        return false;

    return query->isInclusive();
}

QString QCLuceneRangeQuery::getField() const
{
    lucene::search::RangeQuery *query = 
        static_cast<lucene::search::RangeQuery*> (d->query);

    if (query == 0)
        return QString();

    return TCharToQString(query->getField());
}


QCLuceneTermQuery::QCLuceneTermQuery(const QCLuceneTerm &term)
    : QCLuceneQuery()
    , term(term)
{
    d->query = new lucene::search::TermQuery(term.d->term);
}

QCLuceneTermQuery::~QCLuceneTermQuery()
{
    // nothing todo
}

QString QCLuceneTermQuery::getClassName()
{
    return TCharToQString(lucene::search::TermQuery::getClassName());
}

QCLuceneTerm QCLuceneTermQuery::getTerm() const
{
    return term;
}


QCLuceneBooleanQuery::QCLuceneBooleanQuery()
    : QCLuceneQuery()
{
    d->query = new lucene::search::BooleanQuery();
}

QCLuceneBooleanQuery::~QCLuceneBooleanQuery()
{
    qDeleteAll(queries);
}

QString QCLuceneBooleanQuery::getClassName()
{
    return TCharToQString(lucene::search::BooleanQuery::getClassName());
}

quint32 QCLuceneBooleanQuery::getClauseCount() const
{
    lucene::search::BooleanQuery *query = 
        static_cast<lucene::search::BooleanQuery*> (d->query);

    if (query == 0)
        return 1024;

    return quint32(query->getClauseCount());
}

quint32 QCLuceneBooleanQuery::getMaxClauseCount() const
{
    lucene::search::BooleanQuery *query = 
        static_cast<lucene::search::BooleanQuery*> (d->query);

    if (query == 0)
        return 1024;

    return quint32(query->getMaxClauseCount());
}

void QCLuceneBooleanQuery::setMaxClauseCount(quint32 maxClauseCount)
{
    lucene::search::BooleanQuery *query = 
        static_cast<lucene::search::BooleanQuery*> (d->query);

    if (query == 0)
        return;

    query->setMaxClauseCount(size_t(maxClauseCount));
}

void QCLuceneBooleanQuery::add(QCLuceneQuery *query, bool required, bool prohibited)
{ 
    add(query, false, required, prohibited); 
}

void QCLuceneBooleanQuery::add(QCLuceneQuery *query, bool delQuery, 
                               bool required, bool prohibited)
{
    lucene::search::BooleanQuery *booleanQuery = 
        static_cast<lucene::search::BooleanQuery*> (d->query);

    if (booleanQuery == 0)
        return;

    booleanQuery->add(query->d->query, delQuery, required, prohibited);

    if (delQuery) {
        queries.append(query);
        query->d->deleteCLuceneQuery = false;
    }
}


QCLucenePhraseQuery::QCLucenePhraseQuery()
    : QCLuceneQuery()
{
    d->query = new lucene::search::PhraseQuery();
}

QCLucenePhraseQuery::~QCLucenePhraseQuery()
{
    termList.clear();
}

QString QCLucenePhraseQuery::getClassName()
{
    return TCharToQString(lucene::search::RangeQuery::getClassName());
}

qint32 QCLucenePhraseQuery::getSlop() const
{
    lucene::search::PhraseQuery *phraseQuery = 
        static_cast<lucene::search::PhraseQuery*> (d->query);

    if (phraseQuery == 0)
        return 0;

    return qint32(phraseQuery->getSlop());
}

void QCLucenePhraseQuery::setSlop(const qint32 slop)
{
    lucene::search::PhraseQuery *phraseQuery = 
        static_cast<lucene::search::PhraseQuery*> (d->query);

    if (phraseQuery == 0)
        return;

    phraseQuery->setSlop(int32_t(slop));
}

void QCLucenePhraseQuery::addTerm(const QCLuceneTerm &term)
{
    lucene::search::PhraseQuery *phraseQuery = 
        static_cast<lucene::search::PhraseQuery*> (d->query);

    if (phraseQuery == 0)
        return;

    termList.append(term);
    phraseQuery->add(term.d->term);
}

void QCLucenePhraseQuery::addTerm(const QCLuceneTerm &term, qint32 position)
{
    lucene::search::PhraseQuery *phraseQuery = 
        static_cast<lucene::search::PhraseQuery*> (d->query);

    if (phraseQuery == 0)
        return;

    termList.insert(position, term);
    phraseQuery->add(term.d->term, int32_t(position));

}

QString QCLucenePhraseQuery::getFieldName() const
{
    lucene::search::PhraseQuery *phraseQuery = 
        static_cast<lucene::search::PhraseQuery*> (d->query);

    if (phraseQuery == 0)
        return QString();

    return TCharToQString(phraseQuery->getFieldName());
}

QList<QCLuceneTerm> QCLucenePhraseQuery::getTerms() const
{
    return termList;
}

QT_END_NAMESPACE