comparison rdf/RDFTransformFactory.cpp @ 493:3931711b5671

* RDF importer: add model titles where possible
* RDF transform factory: report whether something appears to be RDF or
not (so we can avoid trying to load it as something else if the RDF
query fails)

 {
 public:
     RDFTransformFactoryImpl(QString url);
     virtual ~RDFTransformFactoryImpl();
     
+    bool isRDF();
     bool isOK();
     QString getErrorString() const;
 
     std::vector<Transform> getTransforms(ProgressReporter *);
 
 protected:
     QString m_urlString;
     QString m_errorString;
+    bool m_isRDF;
     bool setOutput(Transform &, QString);
     bool setParameters(Transform &, QString);
 };
 
 

 {
     delete m_d;
 }
 
 bool
+RDFTransformFactory::isRDF()
+{
+    return m_d->isRDF();
+}
+
+bool
 RDFTransformFactory::isOK()
 {
     return m_d->isOK();
 }
 

 {
     return m_d->getTransforms(r);
 }
 
 RDFTransformFactoryImpl::RDFTransformFactoryImpl(QString url) :
-    m_urlString(url)
+    m_urlString(url),
+    m_isRDF(false)
 {
 }
 
 RDFTransformFactoryImpl::~RDFTransformFactoryImpl()
 {
     SimpleSPARQLQuery::closeSingleSource(m_urlString);
+}
+
+bool
+RDFTransformFactoryImpl::isRDF()
+{
+    return m_isRDF;
 }
 
 bool
 RDFTransformFactoryImpl::isOK()
 {

 
     if (!transformsQuery.isOK()) {
         m_errorString = transformsQuery.getErrorString();
         return transforms;
     }
+
+    m_isRDF = true;
 
     if (transformResults.empty()) {
         cerr << "RDFTransformFactory: NOTE: No RDF/TTL transform descriptions found in document at <" << m_urlString.toStdString() << ">" << endl;
         return transforms;
     }

     if (outputValue.type == SimpleSPARQLQuery::NoValue) {
         return true;
     }
 
     if (outputValue.type != SimpleSPARQLQuery::URIValue) {
-        m_errorString = "No vamp:output given, or not a URI";
+        m_errorString = QString("vamp:output given for transform <%1> is not a URI").arg(transformUri);
         return false;
     }
 
     SimpleSPARQLQuery::Value outputIdValue =
         SimpleSPARQLQuery::singleResultQuery

              )
          .arg(outputValue.value),
          "output_id");
     
     if (outputIdValue.type != SimpleSPARQLQuery::LiteralValue) {
-        m_errorString = "No output vamp:identifier available, or not a literal";
+        m_errorString = QString("No vamp:identifier found for output <%1>, or vamp:identifier is not a literal").arg(outputValue.value);
         return false;
     }
 
     transform.setOutput(outputIdValue.value);