• Skip to content
  • Skip to link menu
KDE 4.2 API Reference
  • KDE API Reference
  • API Reference
  • Sitemap
  • Contact Us
 

NepomukDaemons

term.cpp

Go to the documentation of this file.
00001 /*
00002    This file is part of the Nepomuk KDE project.
00003    Copyright (C) 2007 Sebastian Trueg <trueg@kde.org>
00004 
00005    This library is free software; you can redistribute it and/or
00006    modify it under the terms of the GNU Library General Public
00007    License version 2 as published by the Free Software Foundation.
00008 
00009    This library is distributed in the hope that it will be useful,
00010    but WITHOUT ANY WARRANTY; without even the implied warranty of
00011    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00012    Library General Public License for more details.
00013 
00014    You should have received a copy of the GNU Library General Public License
00015    along with this library; see the file COPYING.LIB.  If not, write to
00016    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
00017    Boston, MA 02110-1301, USA.
00018  */
00019 
00020 #include "term.h"
00021 
00022 #include <QtCore/QString>
00023 #include <QtCore/QList>
00024 #include <QtCore/QSharedData>
00025 #include <QtCore/QDebug>
00026 
00027 
00028 class Nepomuk::Search::Term::Private : public QSharedData
00029 {
00030 public:
00031     Private( Type t = InvalidTerm, Comparator c = Equal )
00032         : type( t ),
00033           comparator( c ) {
00034     }
00035 
00036     Type type;
00037     Comparator comparator;
00038     Soprano::LiteralValue value;
00039     QUrl resource;
00040     QString field;
00041     QUrl property;
00042     QList<Term> subTerms;
00043 };
00044 
00045 
00046 Nepomuk::Search::Term::Term()
00047     : d( new Private() )
00048 {
00049 }
00050 
00051 
00052 Nepomuk::Search::Term::Term( const Term& other )
00053 {
00054     d = other.d;
00055 }
00056 
00057 
00058 Nepomuk::Search::Term::Term( const Soprano::LiteralValue& value )
00059     : d( new Private( LiteralTerm ) )
00060 {
00061     d->value = value;
00062 }
00063 
00064 
00065 Nepomuk::Search::Term::Term( const QUrl& value )
00066     : d( new Private( ResourceTerm ) )
00067 {
00068     d->resource = value;
00069 }
00070 
00071 
00072 Nepomuk::Search::Term::Term( const QString& field, const Soprano::LiteralValue& value, Comparator c )
00073     : d( new Private( ComparisonTerm, c ) )
00074 {
00075     d->field = field;
00076     d->subTerms.append( Term( value ) );
00077 }
00078 
00079 
00080 Nepomuk::Search::Term::Term( const QUrl& field, const Soprano::LiteralValue& value, Comparator c )
00081     : d( new Private( ComparisonTerm, c ) )
00082 {
00083     d->property = field;
00084     d->subTerms.append( Term( value ) );
00085 }
00086 
00087 
00088 Nepomuk::Search::Term::Term( const QUrl& field, const QUrl& resource )
00089     : d( new Private( ComparisonTerm ) )
00090 {
00091     d->property = field;
00092     d->subTerms.append( Term( resource ) );
00093 }
00094 
00095 
00096 Nepomuk::Search::Term::~Term()
00097 {
00098 }
00099 
00100 
00101 Nepomuk::Search::Term& Nepomuk::Search::Term::operator=( const Term& other )
00102 {
00103     d = other.d;
00104     return *this;
00105 }
00106 
00107 
00108 Nepomuk::Search::Term& Nepomuk::Search::Term::operator=( const Soprano::LiteralValue& literal )
00109 {
00110     d->value = literal;
00111     d->type = LiteralTerm;
00112     d->subTerms.clear();
00113     d->field = QString();
00114     return *this;
00115 }
00116 
00117 
00118 bool Nepomuk::Search::Term::isValid() const
00119 {
00120     switch ( d->type ) {
00121     case InvalidTerm:
00122         return false;
00123 
00124     case LiteralTerm:
00125         return d->value.isValid() && d->subTerms.isEmpty();
00126 
00127     case ResourceTerm:
00128         return d->resource.isValid() && d->subTerms.isEmpty();
00129 
00130     case AndTerm:
00131     case OrTerm:
00132         return !d->subTerms.isEmpty();
00133 
00134     case ComparisonTerm:
00135         return ( !d->field.isEmpty() || !d->property.isEmpty() ) && ( d->subTerms.count() == 1 );
00136     }
00137     // make gcc happy
00138     return false;
00139 }
00140 
00141 
00142 Nepomuk::Search::Term::Type Nepomuk::Search::Term::type() const
00143 {
00144     return d->type;
00145 }
00146 
00147 
00148 Soprano::LiteralValue Nepomuk::Search::Term::value() const
00149 {
00150     return d->value;
00151 }
00152 
00153 
00154 QUrl Nepomuk::Search::Term::resource() const
00155 {
00156     return d->resource;
00157 }
00158 
00159 
00160 Nepomuk::Search::Term::Comparator Nepomuk::Search::Term::comparator() const
00161 {
00162     return d->comparator;
00163 }
00164 
00165 
00166 QString Nepomuk::Search::Term::field() const
00167 {
00168     return d->field;
00169 }
00170 
00171 
00172 QUrl Nepomuk::Search::Term::property() const
00173 {
00174     return d->property;
00175 }
00176 
00177 
00178 QList<Nepomuk::Search::Term> Nepomuk::Search::Term::subTerms() const
00179 {
00180     return d->subTerms;
00181 }
00182 
00183 
00184 void Nepomuk::Search::Term::setType( Type type )
00185 {
00186     d->type = type;
00187 }
00188 
00189 
00190 void Nepomuk::Search::Term::setValue( const Soprano::LiteralValue& v )
00191 {
00192     d->value = v;
00193     d->resource = QUrl();
00194 }
00195 
00196 
00197 void Nepomuk::Search::Term::setResource( const QUrl& res )
00198 {
00199     d->resource = res;
00200     d->value = Soprano::LiteralValue();
00201 }
00202 
00203 
00204 void Nepomuk::Search::Term::setComparator( Comparator c )
00205 {
00206     d->comparator = c;
00207 }
00208 
00209 
00210 void Nepomuk::Search::Term::setField( const QString& f )
00211 {
00212     d->field = f;
00213     d->property = QUrl();
00214 }
00215 
00216 
00217 void Nepomuk::Search::Term::setSubTerms( const QList<Term>& terms )
00218 {
00219     d->subTerms = terms;
00220 }
00221 
00222 
00223 void Nepomuk::Search::Term::setProperty( const QUrl& p )
00224 {
00225     d->property = p;
00226     d->field = QString();
00227 }
00228 
00229 
00230 void Nepomuk::Search::Term::addSubTerm( const Term& term )
00231 {
00232     d->subTerms.append( term );
00233 }
00234 
00235 
00236 namespace {
00237     bool compareLists( const QList<Nepomuk::Search::Term>& t1, const QList<Nepomuk::Search::Term>& t2 ) {
00238         // brute-force
00239         foreach( const Nepomuk::Search::Term& t, t1 ) {
00240             if ( !t2.contains( t ) ) {
00241                 return false;
00242             }
00243         }
00244         foreach( const Nepomuk::Search::Term& t, t2 ) {
00245             if ( !t1.contains( t ) ) {
00246                 return false;
00247             }
00248         }
00249         return true;
00250     }
00251 }
00252 
00253 bool Nepomuk::Search::Term::operator==( const Term& other ) const
00254 {
00255     if ( d->type == other.d->type ) {
00256         if ( d->type == ComparisonTerm ) {
00257             return ( d->comparator == other.d->comparator &&
00258                      compareLists( d->subTerms, other.d->subTerms ) );
00259         }
00260         else {
00261             return d->value == other.d->value &&
00262                 d->resource == other.d->resource &&
00263                 d->field == other.d->field &&
00264                 d->property == other.d->property &&
00265                 compareLists( d->subTerms, other.d->subTerms );
00266         }
00267     }
00268 
00269     return false;
00270 }
00271 
00272 
00273 QDebug operator<<( QDebug dbg, const Nepomuk::Search::Term& term )
00274 {
00275     if ( term.isValid() ) {
00276         dbg << "(Term";
00277         switch( term.type() ) {
00278         case Nepomuk::Search::Term::LiteralTerm:
00279             dbg << "literal" << term.value();
00280             break;
00281         case Nepomuk::Search::Term::ResourceTerm:
00282             dbg << "resource" << term.resource();
00283             break;
00284         case Nepomuk::Search::Term::AndTerm:
00285             dbg << "and";
00286             break;
00287         case Nepomuk::Search::Term::OrTerm:
00288             dbg << "or";
00289             break;
00290         case Nepomuk::Search::Term::ComparisonTerm:
00291             dbg << "compare";
00292             switch( term.comparator() ) {
00293             case Nepomuk::Search::Term::Contains:
00294                 dbg << ":";
00295                 break;
00296             case Nepomuk::Search::Term::Equal:
00297                 dbg << "=";
00298                 break;
00299             case Nepomuk::Search::Term::Greater:
00300                 dbg << ">";
00301                 break;
00302             case Nepomuk::Search::Term::Smaller:
00303                 dbg << "<";
00304                 break;
00305             case Nepomuk::Search::Term::GreaterOrEqual:
00306                 dbg << ">=";
00307                 break;
00308             case Nepomuk::Search::Term::SmallerOrEqual:
00309                 dbg << "<=";
00310                 break;
00311             }
00312         default:
00313             break;
00314         }
00315         if ( term.type() == Nepomuk::Search::Term::ComparisonTerm ) {
00316             if ( term.property().isValid() ) {
00317                 dbg << "Property" << term.property();
00318             }
00319             else {
00320                 dbg << "Field:" << term.field();
00321             }
00322             dbg << term.subTerms().first();
00323         }
00324         if ( term.type() == Nepomuk::Search::Term::AndTerm ||
00325              term.type() == Nepomuk::Search::Term::OrTerm ) {
00326             dbg << "Subterms: [";
00327             foreach( const Nepomuk::Search::Term &t, term.subTerms() ) {
00328                 dbg << t;
00329             }
00330             dbg << "]";
00331         }
00332         dbg << ")";
00333     }
00334 
00335     return dbg;
00336 }
00337 
00338 
00339 uint Nepomuk::Search::qHash( const Nepomuk::Search::Term& term )
00340 {
00341     switch( term.type() ) {
00342     case Nepomuk::Search::Term::LiteralTerm:
00343         return qHash( term.value().toString() );
00344 
00345     case Nepomuk::Search::Term::ComparisonTerm:
00346         return( qHash( term.property().isValid() ?  term.property().toString() : term.field() )<<16 |
00347                 qHash( term.subTerms().first() )<<8 |
00348                 ( uint )term.comparator() );
00349 
00350     case Nepomuk::Search::Term::AndTerm:
00351     case Nepomuk::Search::Term::OrTerm: {
00352         uint h = ( uint )term.type();
00353         QList<Nepomuk::Search::Term> subTerms = term.subTerms();
00354         for ( int i = 0; i < subTerms.count(); ++i ) {
00355             h |= ( qHash( subTerms[i] )<<i );
00356         }
00357         return h;
00358     }
00359 
00360     default:
00361         return 0;
00362     }
00363 }

NepomukDaemons

Skip menu "NepomukDaemons"
  • Main Page
  • Namespace List
  • Class Hierarchy
  • Alphabetical List
  • Class List
  • File List
  • Namespace Members
  • Class Members
  • Related Pages

API Reference

Skip menu "API Reference"
  • KCMShell
  • KNotify
  • KStyles
  • Nepomuk Daemons
Generated for API Reference by doxygen 1.5.7
This website is maintained by Adriaan de Groot and Allen Winter.
KDE® and the K Desktop Environment® logo are registered trademarks of KDE e.V. | Legal