comparison rdf/SimpleSPARQLQuery.cpp @ 686:b4a8d8221eaf debug-output

Remove most toStdString calls (no longer needed, with debug header)

         librdf_free_storage(storage);
         return 0;
     }
     QString err;
     if (!loadUri(model, fromUri, err)) {
-        std::cerr << "SimpleSPARQLQuery: ERROR: Failed to parse into new model: " << err.toStdString() << std::endl;
+        std::cerr << "SimpleSPARQLQuery: ERROR: Failed to parse into new model: " << err << std::endl;
         librdf_free_model(model);
         librdf_free_storage(storage);
         m_ownModelUris[fromUri] = 0;
         return 0;
     }

 
 void
 WredlandWorldWrapper::freeModel(QString forUri)
 {
 #ifdef DEBUG_SIMPLE_SPARQL_QUERY
-    std::cerr << "SimpleSPARQLQuery::freeModel: Model uri = \"" << forUri.toStdString() << "\"" << std::endl;
+    std::cerr << "SimpleSPARQLQuery::freeModel: Model uri = \"" << forUri << "\"" << std::endl;
 #endif
 
     QMutexLocker locker(&m_mutex);
     if (forUri == "") {
         std::cerr << "SimpleSPARQLQuery::freeModel: ERROR: Can't free default model" << std::endl;
         return;
     }
     if (m_ownModelUris.find(forUri) == m_ownModelUris.end()) {
 #ifdef DEBUG_SIMPLE_SPARQL_QUERY
-        std::cerr << "SimpleSPARQLQuery::freeModel: NOTE: Unknown or already-freed model (uri = \"" << forUri.toStdString() << "\")" << std::endl;
+        std::cerr << "SimpleSPARQLQuery::freeModel: NOTE: Unknown or already-freed model (uri = \"" << forUri << "\")" << std::endl;
 #endif
         return;
     }
 
     librdf_model *model = m_ownModelUris[forUri];

         errorString = "Failed to initialise Redland parser";
         return false;
     }
 
 #ifdef DEBUG_SIMPLE_SPARQL_QUERY    
-    std::cerr << "About to parse \"" << uri.toStdString() << "\"" << std::endl;
+    std::cerr << "About to parse \"" << uri << "\"" << std::endl;
 #endif
     
     Profiler p("SimpleSPARQLQuery: Parse URI into LIBRDF model");
     
     if (librdf_parser_parse_into_model(parser, luri, NULL, model)) {

     }
 
 #ifdef DEBUG_SIMPLE_SPARQL_QUERY
     if (m_errorString != "") {
         std::cerr << "SimpleSPARQLQuery::execute: error returned: \""
-                  << m_errorString.toStdString() << "\"" << std::endl;
+                  << m_errorString << "\"" << std::endl;
     }
 #endif
 }
 
 SimpleSPARQLQuery::ResultList
 SimpleSPARQLQuery::Impl::executeDirectParser()
 {
 #ifdef DEBUG_SIMPLE_SPARQL_QUERY
-    std::cerr << "SimpleSPARQLQuery::executeDirectParser: Query is: \"" << m_query.toStdString() << "\"" << std::endl;
+    std::cerr << "SimpleSPARQLQuery::executeDirectParser: Query is: \"" << m_query << "\"" << std::endl;
 #endif
 
     ResultList list;
 
     Profiler profiler("SimpleSPARQLQuery::executeDirectParser");

         return list;
     } else {
         fromUri = fromRE.cap(1);
 #ifdef DEBUG_SIMPLE_SPARQL_QUERY
         std::cerr << "SimpleSPARQLQuery::executeDirectParser: FROM URI is <"
-                  << fromUri.toStdString() << ">" << std::endl;
+                  << fromUri << ">" << std::endl;
 #endif
     }
 
     return executeFor(fromUri);
 }
 
 SimpleSPARQLQuery::ResultList
 SimpleSPARQLQuery::Impl::executeDatastore()
 {
 #ifdef DEBUG_SIMPLE_SPARQL_QUERY
-    std::cerr << "SimpleSPARQLQuery::executeDatastore: Query is: \"" << m_query.toStdString() << "\"" << std::endl;
+    std::cerr << "SimpleSPARQLQuery::executeDatastore: Query is: \"" << m_query << "\"" << std::endl;
 #endif
 
     ResultList list;
 
     Profiler profiler("SimpleSPARQLQuery::executeDatastore");

 #ifdef DEBUG_SIMPLE_SPARQL_QUERY
     static std::map<QString, int> counter;
     if (counter.find(m_query) == counter.end()) counter[m_query] = 1;
     else ++counter[m_query];
     std::cerr << "Counter for this query: " << counter[m_query] << std::endl;
-    std::cerr << "Base URI is: \"" << modelUri.toStdString() << "\"" << std::endl;
+    std::cerr << "Base URI is: \"" << modelUri << "\"" << std::endl;
 #endif
 
     {
         Profiler p("SimpleSPARQLQuery: Prepare LIBRDF query");
         query = librdf_new_query

 
             QString key = (const char *)name;
 
             if (!node) {
 #ifdef DEBUG_SIMPLE_SPARQL_QUERY
-                std::cerr << i << ". " << key.toStdString() << " -> (nil)" << std::endl;
+                std::cerr << i << ". " << key << " -> (nil)" << std::endl;
 #endif
                 resultmap[key] = Value();
                 continue;
             }
 

 
                 cerr << "SimpleSPARQLQuery: LIBRDF query returned unknown node type (not resource, literal, or blank)" << endl;
             }
 
 #ifdef DEBUG_SIMPLE_SPARQL_QUERY
-            cerr << i << ". " << key.toStdString() << " -> " << text.toStdString() << " (type " << type << ")" << endl;
+            cerr << i << ". " << key << " -> " << text << " (type " << type << ")" << endl;
 #endif
 
             resultmap[key] = Value(type, text);
 
 //            librdf_free_node(node);

         std::cerr << "SimpleSPARQLQuery::addSourceToModel: Failed to initialise Redland datastore" << std::endl;
         return false;
     }
 
     if (!m_redland->loadUriIntoDefaultModel(sourceUri, err)) {
-        std::cerr << "SimpleSPARQLQuery::addSourceToModel: Failed to add source URI \"" << sourceUri.toStdString() << ": " << err.toStdString() << std::endl;
+        std::cerr << "SimpleSPARQLQuery::addSourceToModel: Failed to add source URI \"" << sourceUri << ": " << err << std::endl;
         return false;
     }
     return true;
 }
 

 {
     SimpleSPARQLQuery q(type, query);
     ResultList results = q.execute();
     if (!q.isOK()) {
         cerr << "SimpleSPARQLQuery::singleResultQuery: ERROR: "
-             << q.getErrorString().toStdString() << endl;
+             << q.getErrorString() << endl;
         return Value();
     }
     if (results.empty()) {
         return Value();
     }