[prev in list] [next in list] [prev in thread] [next in thread] 

List:       kde-commits
Subject:    KDE/kdelibs/nepomuk/query
From:       Sebastian Trueg <sebastian () trueg ! de>
Date:       2010-09-06 19:50:28
Message-ID: 20100906195028.C1F47AC884 () svn ! kde ! org
[Download RAW message or body]

SVN commit 1172247 by trueg:

Moved the implementation of Query::optimized() to the new method Term::optimized(). \
This is more convinient when handling terms.

 M  +2 -65     query.cpp  
 M  +2 -0      query.h  
 M  +64 -0     term.cpp  
 M  +13 -0     term.h  


--- trunk/KDE/kdelibs/nepomuk/query/query.cpp #1172246:1172247
@@ -71,69 +71,6 @@
 
 
 namespace {
-    Nepomuk::Query::Term optimizeTerm( const Nepomuk::Query::Term& term )
-    {
-        switch( term.type() ) {
-        case Nepomuk::Query::Term::And:
-        case Nepomuk::Query::Term::Or: {
-            QList<Nepomuk::Query::Term> subTerms = static_cast<const \
                Nepomuk::Query::GroupTerm&>( term ).subTerms();
-            QList<Nepomuk::Query::Term> newSubTerms;
-            QList<Nepomuk::Query::Term>::const_iterator end( subTerms.constEnd() );
-            for ( QList<Nepomuk::Query::Term>::const_iterator it = \
                subTerms.constBegin();
-                  it != end; ++it ) {
-                const Nepomuk::Query::Term& t = *it;
-                Nepomuk::Query::Term ot = optimizeTerm( t );
-                QList<Nepomuk::Query::Term> terms;
-                if ( ot.type() == term.type() ) {
-                    terms = static_cast<const Nepomuk::Query::GroupTerm&>( ot \
                ).subTerms();
-                }
-                else if( ot.isValid() ) {
-                    terms += ot;
-                }
-                Q_FOREACH( const Nepomuk::Query::Term& t, terms ) {
-                    if( !newSubTerms.contains( t ) )
-                        newSubTerms += t;
-                }
-            }
-            if ( newSubTerms.count() == 0 )
-                return Nepomuk::Query::Term();
-            else if ( newSubTerms.count() == 1 )
-                return *newSubTerms.begin();
-            else if ( term.isAndTerm() )
-                return Nepomuk::Query::AndTerm( newSubTerms );
-            else
-                return Nepomuk::Query::OrTerm( newSubTerms );
-        }
-
-        case Nepomuk::Query::Term::Negation: {
-            Nepomuk::Query::NegationTerm nt = term.toNegationTerm();
-            // a negation in a negation
-            if( nt.subTerm().isNegationTerm() )
-                return optimizeTerm( nt.subTerm().toNegationTerm().subTerm() );
-            else
-                return Nepomuk::Query::NegationTerm::negateTerm( optimizeTerm( \
                nt.subTerm() ) );
-        }
-
-        case Nepomuk::Query::Term::Optional: {
-            Nepomuk::Query::OptionalTerm ot = term.toOptionalTerm();
-            // remove duplicate optional terms
-            if( ot.subTerm().isOptionalTerm() )
-                return optimizeTerm( ot.subTerm() );
-            else
-                return Nepomuk::Query::OptionalTerm::optionalizeTerm( optimizeTerm( \
                ot.subTerm() ) );
-        }
-
-        case Nepomuk::Query::Term::Comparison: {
-            Nepomuk::Query::ComparisonTerm ct( term.toComparisonTerm() );
-            ct.setSubTerm( optimizeTerm( ct.subTerm() ) );
-            return ct;
-        }
-
-        default:
-            return term;
-        }
-    }
-
     Nepomuk::Query::Term prepareForSparql( const Nepomuk::Query::Term& term )
     {
         //
@@ -482,7 +419,7 @@
     }
 
     // optimize whatever we can
-    term = optimizeTerm( prepareForSparql( term ) );
+    term = prepareForSparql( term ).optimized();
 
     // actually build the SPARQL query patterns
     QueryBuilderData qbd( flags );
@@ -607,7 +544,7 @@
 Nepomuk::Query::Query Nepomuk::Query::Query::optimized() const
 {
     Query newQuery( *this );
-    newQuery.setTerm( optimizeTerm( term() ) );
+    newQuery.setTerm( term().optimized() );
     return newQuery;
 }
 
--- trunk/KDE/kdelibs/nepomuk/query/query.h #1172246:1172247
@@ -416,6 +416,8 @@
              * \return An optimized version of this query.
              *
              * \since 4.6
+             *
+             * \sa Query::optimized()
              */
             Query optimized() const;
 
--- trunk/KDE/kdelibs/nepomuk/query/term.cpp #1172246:1172247
@@ -87,6 +87,70 @@
 }
 
 
+Nepomuk::Query::Term Nepomuk::Query::Term::optimized() const
+{
+    switch( type() ) {
+    case Nepomuk::Query::Term::And:
+    case Nepomuk::Query::Term::Or: {
+        QList<Nepomuk::Query::Term> subTerms = static_cast<const \
Nepomuk::Query::GroupTerm&>( *this ).subTerms(); +        QList<Nepomuk::Query::Term> \
newSubTerms; +        QList<Nepomuk::Query::Term>::const_iterator end( \
subTerms.constEnd() ); +        for ( QList<Nepomuk::Query::Term>::const_iterator it \
= subTerms.constBegin(); +              it != end; ++it ) {
+            const Nepomuk::Query::Term& t = *it;
+            Nepomuk::Query::Term ot = t.optimized();
+            QList<Nepomuk::Query::Term> terms;
+            if ( ot.type() == type() ) {
+                terms = static_cast<const Nepomuk::Query::GroupTerm&>( ot \
).subTerms(); +            }
+            else if( ot.isValid() ) {
+                terms += ot;
+            }
+            Q_FOREACH( const Nepomuk::Query::Term& t, terms ) {
+                if( !newSubTerms.contains( t ) )
+                    newSubTerms += t;
+            }
+        }
+        if ( newSubTerms.count() == 0 )
+            return Nepomuk::Query::Term();
+        else if ( newSubTerms.count() == 1 )
+            return *newSubTerms.begin();
+        else if ( isAndTerm() )
+            return Nepomuk::Query::AndTerm( newSubTerms );
+        else
+            return Nepomuk::Query::OrTerm( newSubTerms );
+    }
+
+    case Nepomuk::Query::Term::Negation: {
+        Nepomuk::Query::NegationTerm nt = toNegationTerm();
+        // a negation in a negation
+        if( nt.subTerm().isNegationTerm() )
+            return nt.subTerm().toNegationTerm().subTerm().optimized();
+        else
+            return Nepomuk::Query::NegationTerm::negateTerm( \
nt.subTerm().optimized() ); +    }
+
+    case Nepomuk::Query::Term::Optional: {
+        Nepomuk::Query::OptionalTerm ot = toOptionalTerm();
+        // remove duplicate optional terms
+        if( ot.subTerm().isOptionalTerm() )
+            return ot.subTerm().optimized();
+        else
+            return Nepomuk::Query::OptionalTerm::optionalizeTerm( \
ot.subTerm().optimized() ); +    }
+
+    case Nepomuk::Query::Term::Comparison: {
+        Nepomuk::Query::ComparisonTerm ct( toComparisonTerm() );
+        ct.setSubTerm( ct.subTerm().optimized() );
+        return ct;
+    }
+
+    default:
+        return *this;
+    }
+}
+
+
 bool Nepomuk::Query::Term::isLiteralTerm() const
 {
     return type() == Literal;
--- trunk/KDE/kdelibs/nepomuk/query/term.h #1172246:1172247
@@ -168,6 +168,19 @@
             Type type() const;
 
             /**
+             * Optimizes the term without chaning its meaning. This removes
+             * redundant terms such as NegationTerm and OptionalTerm nestings and \
flattens +             * AndTerm and OrTerm hierarchies.
+             *
+             * \return An optimized version of this term.
+             *
+             * \since 4.6
+             *
+             * \sa Query::optimized()
+             */
+            Term optimized() const;
+
+            /**
              * \return \p true if this term is a LiteralTerm.
              */
             bool isLiteralTerm() const;


[prev in list] [next in list] [prev in thread] [next in thread]