NepomukDaemons
term.cpp
Go to the documentation of this file.00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
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
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
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 }