comparison rdf/RDFImporter.cpp @ 687:06f13a3b9e9e debug-output

Convert many cerrs to DEBUGs

     for (int i = 0; i < (int)results.size(); ++i) {
 
         QString signal = results[i]["signal"].value;
         QString source = results[i]["source"].value;
 
-        std::cerr << "NOTE: Seeking signal source \"" << source.toStdString()
-                  << "\"..." << std::endl;
+        DEBUG << "NOTE: Seeking signal source \"" << source                  << "\"..." << endl;
 
         FileSource *fs = new FileSource(source, reporter);
         if (fs->isAvailable()) {
-            std::cerr << "NOTE: Source is available: Local filename is \""
-                      << fs->getLocalFilename().toStdString()
-                      << "\"..." << std::endl;
+            DEBUG << "NOTE: Source is available: Local filename is \""
+                      << fs->getLocalFilename()                      << "\"..." << endl;
         }
             
 #ifdef NO_SV_GUI
         if (!fs->isAvailable()) {
             m_errorString = QString("Signal source \"%1\" is not available").arg(source);
             delete fs;
             continue;
         }
 #else
         if (!fs->isAvailable()) {
-            std::cerr << "NOTE: Signal source \"" << source.toStdString()
-                      << "\" is not available, using file finder..." << std::endl;
+            DEBUG << "NOTE: Signal source \"" << source                      << "\" is not available, using file finder..." << endl;
             FileFinder *ff = FileFinder::getInstance();
             if (ff) {
                 QString path = ff->find(FileFinder::AudioFile,
                                         fs->getLocation(),
                                         m_uristring);

         (SimpleSPARQLQuery::QueryFromSingleSource,
          titleQuery.arg(featureUri),
          "title");
 
     if (v.value != "") {
-        std::cerr << "RDFImporterImpl::getDenseModelTitle: Title (from signal) \"" << v.value << "\"" << std::endl;
+        DEBUG << "RDFImporterImpl::getDenseModelTitle: Title (from signal) \"" << v.value << "\"" << endl;
         m->setObjectName(v.value);
         return;
     }
 
     v = SimpleSPARQLQuery::singleResultQuery
         (SimpleSPARQLQuery::QueryFromSingleSource,
          titleQuery.arg(featureTypeUri),
          "title");
     
     if (v.value != "") {
-        std::cerr << "RDFImporterImpl::getDenseModelTitle: Title (from signal type) \"" << v.value << "\"" << std::endl;
+        DEBUG << "RDFImporterImpl::getDenseModelTitle: Title (from signal type) \"" << v.value << "\"" << endl;
         m->setObjectName(v.value);
         return;
     }
 
-    std::cerr << "RDFImporterImpl::getDenseModelTitle: No title available for feature <" << featureUri << ">" << std::endl;
+    DEBUG << "RDFImporterImpl::getDenseModelTitle: No title available for feature <" << featureUri << ">" << endl;
 }
 
 void
 RDFImporterImpl::getDenseFeatureProperties(QString featureUri,
                                            int &sampleRate, int &windowLength,

             haveTime = true;
             haveDuration = true;
         } else {
             QString timestring = SimpleSPARQLQuery::singleResultQuery
                 (s, timeQueryString.arg(thinguri), "time").value;
-//            std::cerr << "timestring = " << timestring << std::endl;
+//            DEBUG << "timestring = " << timestring << endl;
             if (timestring != "") {
                 time = RealTime::fromXsdDuration(timestring.toStdString());
                 haveTime = true;
             }
         }

 
         if (modelMap[timeline][type][dimensions].find(haveDuration) ==
             modelMap[timeline][type][dimensions].end()) {
 
 /*
-            std::cerr << "Creating new model: source = " << source.toStdString()
-                      << ", type = " << type << ", dimensions = "
+            DEBUG << "Creating new model: source = " << source                      << ", type = " << type << ", dimensions = "
                       << dimensions << ", haveDuration = " << haveDuration
                       << ", time = " << time << ", duration = " << duration
-                      << std::endl;
+                      << endl;
 */
             
             if (!haveDuration) {
 
                 if (dimensions == 1) {

                            long fduration,
                            bool haveDuration,
                            std::vector<float> &values,
                            QString label)
 {
-//    std::cerr << "RDFImporterImpl::fillModel: adding point at frame " << ftime << std::endl;
+//    DEBUG << "RDFImporterImpl::fillModel: adding point at frame " << ftime << endl;
 
     SparseOneDimensionalModel *sodm =
         dynamic_cast<SparseOneDimensionalModel *>(model);
     if (sodm) {
         SparseOneDimensionalModel::Point point(ftime, label);

         if (value.type == SimpleSPARQLQuery::URIValue) {
             haveAudio = true;
         }
     }
 
-    std::cerr << "NOTE: RDFImporter::identifyDocumentType: haveAudio = "
-              << haveAudio << std::endl;
+    DEBUG << "NOTE: RDFImporter::identifyDocumentType: haveAudio = "
+              << haveAudio << endl;
 
     value =
         SimpleSPARQLQuery::singleResultQuery
         (SimpleSPARQLQuery::QueryFromSingleSource,
          QString

         if (value.type == SimpleSPARQLQuery::URIValue) {
             haveAnnotations = true;
         }
     }
 
-    std::cerr << "NOTE: RDFImporter::identifyDocumentType: haveAnnotations = "
-              << haveAnnotations << std::endl;
+    DEBUG << "NOTE: RDFImporter::identifyDocumentType: haveAnnotations = "
+              << haveAnnotations << endl;
 
     SimpleSPARQLQuery::closeSingleSource(url);
 
     if (haveAudio) {
         if (haveAnnotations) {