File indexing completed on 2023-09-24 04:15:35

 /*
     This file is part of the syndication library
     SPDX-FileCopyrightText: 2006 Frank Osterfeld <osterfeld@kde.org>
 
     SPDX-License-Identifier: LGPL-2.0-or-later
 */
 
 #include "modelmaker.h"
 #include "literal.h"
 #include "model.h"
 #include "property.h"
 #include "rdfvocab.h"
 #include "resource.h"
 #include "sequence.h"
 #include "statement.h"
 
 #include <QDomElement>
 #include <QString>
 
 namespace Syndication
 {
 namespace RDF
 {
 Model ModelMaker::createFromXML(const QDomDocument &doc)
 {
     Model model;
 
     if (doc.isNull()) {
         return model;
     }
 
     const QDomElement rdfNode = doc.documentElement();
 
     const QDomNodeList list = rdfNode.childNodes();
 
     for (int i = 0; i < list.length(); ++i) {
         if (list.item(i).isElement()) {
             const QDomElement el = list.item(i).toElement();
             readResource(model, el);
         }
     }
 
     return model;
 }
 
 ResourcePtr ModelMaker::readResource(Model &model, const QDomElement &el)
 {
     QString about = QStringLiteral("about");
     QString resource = QStringLiteral("resource");
 
     ResourcePtr res;
 
     ResourcePtr type = model.createResource(el.namespaceURI() + el.localName());
 
     if (*type == *(RDFVocab::self()->seq())) {
         SequencePtr seq = model.createSequence(el.attribute(about));
 
         res = seq;
     } else {
         res = model.createResource(el.attribute(about));
     }
 
     model.addStatement(res, RDFVocab::self()->type(), type);
 
     const QDomNodeList children = el.childNodes();
 
     bool isSeq = res->isSequence();
 
     for (int i = 0; i < children.length(); ++i) {
         if (children.item(i).isElement()) {
             QDomElement ce = children.item(i).toElement();
 
             PropertyPtr pred = model.createProperty(ce.namespaceURI() + ce.localName());
 
             if (ce.hasAttribute(resource)) { // referenced Resource via (rdf:)resource
                 NodePtr obj = model.createResource(ce.attribute(resource));
 
                 if (isSeq && *pred == *(RDFVocab::self()->li())) {
                     SequencePtr tseq = res.staticCast<Sequence>();
                     tseq->append(obj);
                 } else {
                     model.addStatement(res, pred, obj);
                 }
             } else if (!ce.text().isEmpty() && ce.lastChildElement().isNull()) { // Literal
                 NodePtr obj = model.createLiteral(ce.text());
 
                 if (isSeq && *pred == *(RDFVocab::self()->li())) {
                     SequencePtr tseq = res.staticCast<Sequence>();
                     tseq->append(obj);
                 } else {
                     model.addStatement(res, pred, obj);
                 }
             } else { // embedded description
                 QDomElement re = ce.lastChildElement();
 
                 // QString uri = re.attribute(about);
 
                 // read recursively
                 NodePtr obj = readResource(model, re);
 
                 if (isSeq && *pred == *(RDFVocab::self()->li())) {
                     SequencePtr tseq = res.staticCast<Sequence>();
                     tseq->append(obj);
                 } else {
                     model.addStatement(res, pred, obj);
                 }
             }
 
             // TODO: bag, reification (nice to have, but not important for basic RSS 1.0)
         }
     }
 
     return res;
 }
 
 } // namespace RDF
 } // namespace Syndication