runtime/nepomuk/strigibackend/util.cpp

   1 /*
   2    Copyright (C) 2007-2008 Sebastian Trueg <trueg@kde.org>
   3
   4    This library is free software; you can redistribute it and/or
   5    modify it under the terms of the GNU General Public License as
   6    published by the Free Software Foundation; either version 2 of
   7    the License, or (at your option) any later version.
   8
   9    This library is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12    Library General Public License for more details.
  13
  14    You should have received a copy of the GNU General Public License
  15    along with this library; see the file COPYING.  If not, write to
  16    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  17    Boston, MA 02110-1301, USA.
  18 */
  19
  20 #include "util.h"
  21
  22 #include <strigi/variant.h>
  23 #include <strigi/fieldtypes.h>
  24
  25 #include <QtCore/QUrl>
  26 #include <QtCore/QFile>
  27 #include <QtCore/QFileInfo>
  28 #include <QtCore/QUuid>
  29 #include <QtCore/QDebug>
  30
  31 #include <Soprano/Index/CLuceneIndex>
  32 #include <Soprano/Model>
  33 #include <Soprano/Vocabulary/RDF>
  34 #include <Soprano/Vocabulary/RDFS>
  35 #include <Soprano/Vocabulary/Xesam>
  36 #include <Soprano/Vocabulary/NRL>
  37 #include <Soprano/Vocabulary/XMLSchema>
  38
  39
  40 #define STRIGI_NS "http://www.strigi.org/data#"
  41
  42 QUrl Strigi::Soprano::Util::fieldUri( const std::string& s )
  43 {
  44     QString qKey = QString::fromUtf8( s.c_str() );
  45     QUrl url;
  46
  47     // very naive test for proper URI
  48     if ( qKey.contains( ":/" ) ) {
  49         url = qKey;
  50     }
  51     else {
  52         url = STRIGI_NS + qKey;
  53     }
  54
  55     // just to be sure
  56     if ( url.isRelative() ) {
  57         url.setScheme( "http" );
  58     }
  59
  60     return url;
  61 }
  62
  63
  64 QUrl Strigi::Soprano::Util::fileUrl( const std::string& filename )
  65 {
  66     QUrl url = QUrl::fromLocalFile( QFileInfo( QString::fromUtf8( filename.c_str() ) ).absoluteFilePath() );
  67     url.setScheme( "file" );
  68     return url;
  69 }
  70
  71
  72 std::string Strigi::Soprano::Util::fieldName( const QUrl& uri )
  73 {
  74     QString s = uri.toString();
  75     if ( s.startsWith( STRIGI_NS ) ) {
  76         s = s.mid( strlen( STRIGI_NS ) );
  77     }
  78     return s.toUtf8().data();
  79 }
  80
  81
  82 TString Strigi::Soprano::Util::convertSearchField( const std::string& field )
  83 {
  84     if ( QString::fromUtf8( field.c_str() ) == ::Soprano::Index::CLuceneIndex::defaultSearchField() ) {
  85         return TString::fromUtf8( field.c_str() );
  86     }
  87     else {
  88         return fieldUri( field ).toString();
  89     }
  90 }
  91
  92
  93 QUrl Strigi::Soprano::Util::uniqueUri( const QString& ns, ::Soprano::Model* model )
  94 {
  95     QUrl uri;
  96     do {
  97         QString uid = QUuid::createUuid().toString();
  98         uri = ( ns + uid.mid( 1, uid.length()-2 ) );
  99     } while ( model->containsAnyStatement( ::Soprano::Statement( uri, ::Soprano::Node(), ::Soprano::Node() ) ) );
 100     return uri;
 101 }
 102
 103
 104 Strigi::Variant Strigi::Soprano::Util::nodeToVariant( const ::Soprano::Node& node )
 105 {
 106     if ( node.isLiteral() ) {
 107         switch( node.literal().type() ) {
 108         case QVariant::Int:
 109         case QVariant::UInt:
 110         case QVariant::LongLong:  // FIXME: no perfect conversion :(
 111         case QVariant::ULongLong:
 112             return Strigi::Variant( node.literal().toInt() );
 113
 114         case QVariant::Bool:
 115             return Strigi::Variant( node.literal().toBool() );
 116
 117         default:
 118             return Strigi::Variant( node.literal().toString().toUtf8().data() );
 119         }
 120     }
 121     else {
 122         qWarning() << "(Soprano::Util::nodeToVariant) cannot convert non-literal node to variant.";
 123         return Strigi::Variant();
 124     }
 125 }
 126
 127
 128 void Strigi::Soprano::Util::storeStrigiMiniOntology( ::Soprano::Model* model )
 129 {
 130     // we use some nice URI here although we still have the STRIGI_NS for backwards comp
 131     // at some point (if parentUrl will not be moved to xesam) we should move to a proper onto
 132
 133     QUrl graph( "http://nepomuk.kde.org/ontologies/2008/07/24/strigi/metadata" );
 134     ::Soprano::Statement parentUrlProp( fieldUri( FieldRegister::parentLocationFieldName ),
 135                                         ::Soprano::Vocabulary::RDF::type(),
 136                                         ::Soprano::Vocabulary::RDF::Property(),
 137                                         graph );
 138     ::Soprano::Statement parentUrlRange( parentUrlProp.subject(),
 139                                          ::Soprano::Vocabulary::RDFS::range(),
 140                                          ::Soprano::Vocabulary::RDFS::Resource(),
 141                                          graph );
 142     ::Soprano::Statement oldParentUrlRange( parentUrlProp.subject(),
 143                                             ::Soprano::Vocabulary::RDFS::range(),
 144                                             ::Soprano::Vocabulary::XMLSchema::string(),
 145                                             graph );
 146     ::Soprano::Statement parentUrlDomain( parentUrlProp.subject(),
 147                                           ::Soprano::Vocabulary::RDFS::domain(),
 148                                           ::Soprano::Vocabulary::Xesam::File(),
 149                                           graph );
 150     ::Soprano::Statement metaDataType( graph,
 151                                        ::Soprano::Vocabulary::RDF::type(),
 152                                        ::Soprano::Vocabulary::NRL::Ontology(),
 153                                        graph );
 154
 155     if ( !model->containsStatement( parentUrlProp ) ) {
 156         model->addStatement( parentUrlProp );
 157     }
 158     if ( !model->containsStatement( parentUrlRange ) ) {
 159         model->removeStatement( oldParentUrlRange );
 160         model->addStatement( parentUrlRange );
 161     }
 162     if ( !model->containsStatement( parentUrlDomain ) ) {
 163         model->addStatement( parentUrlDomain );
 164     }
 165     if ( !model->containsStatement( metaDataType ) ) {
 166         model->addStatement( metaDataType );
 167     }
 168 }
 169
 170
 171 QUrl Strigi::Ontology::indexGraphFor()
 172 {
 173     return QUrl::fromEncoded( "http://www.strigi.org/fields#indexGraphFor", QUrl::StrictMode );
 174 }