summaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/core/XML.cpp7
-rw-r--r--src/core/XML.hpp23
-rw-r--r--src/core/managed/Manager.cpp8
-rw-r--r--src/core/model/Document.cpp157
-rw-r--r--src/core/model/Document.hpp109
-rw-r--r--src/plugins/html/DemoOutput.cpp36
6 files changed, 52 insertions, 288 deletions
diff --git a/src/core/XML.cpp b/src/core/XML.cpp
index 7f03b35..affa75f 100644
--- a/src/core/XML.cpp
+++ b/src/core/XML.cpp
@@ -45,4 +45,11 @@ void Text::doSerialize(std::ostream &out, unsigned int tabdepth)
out << text << '\n';
}
}
+
+namespace RttiTypes {
+const Rtti<xml::Node> XMLNode = RttiBuilder("XMLNode");
+const Rtti<xml::Element> XMLElement =
+ RttiBuilder("XMLElement").parent(&XMLNode).composedOf(&XMLNode);
+const Rtti<xml::Text> XMLText = RttiBuilder("XMLText").parent(&XMLNode);
+}
}
diff --git a/src/core/XML.hpp b/src/core/XML.hpp
index b4b803d..25c8dae 100644
--- a/src/core/XML.hpp
+++ b/src/core/XML.hpp
@@ -45,6 +45,7 @@
#include <ostream>
#include <vector>
+#include <core/common/Rtti.hpp>
#include <core/managed/Managed.hpp>
#include <core/managed/ManagedContainer.hpp>
@@ -101,19 +102,22 @@ public:
* Additionally it might have other Nodes as children.
*/
class Element : public Node {
+private:
+ ManagedVector<Node> children;
+
public:
const std::string name;
std::map<std::string, std::string> attributes;
- ManagedVector<Node> children;
Element(Manager &mgr, Handle<Element> parent, std::string name)
- : Node(mgr, parent), name(std::move(name))
+ : Node(mgr, parent), children(this), name(std::move(name))
{
}
Element(Manager &mgr, Handle<Element> parent, std::string name,
std::map<std::string, std::string> attributes)
: Node(mgr, parent),
+ children(this),
name(std::move(name)),
attributes(std::move(attributes))
{
@@ -127,6 +131,15 @@ public:
*
*/
void doSerialize(std::ostream &out, unsigned int tabdepth) override;
+
+ const ManagedVector<Node> &getChildren() const { return children; }
+
+ void addChild(Handle<Node> child) { children.push_back(child); }
+
+ void addChildren(std::vector<Handle<Node>> c)
+ {
+ children.insert(children.end(), c.begin(), c.end());
+ }
};
class Text : public Node {
@@ -145,5 +158,11 @@ public:
void doSerialize(std::ostream &out, unsigned int tabdepth) override;
};
}
+
+namespace RttiTypes {
+extern const Rtti<xml::Node> XMLNode;
+extern const Rtti<xml::Element> XMLElement;
+extern const Rtti<xml::Text> XMLText;
+}
}
#endif
diff --git a/src/core/managed/Manager.cpp b/src/core/managed/Manager.cpp
index 5428ea1..3950ce2 100644
--- a/src/core/managed/Manager.cpp
+++ b/src/core/managed/Manager.cpp
@@ -26,8 +26,9 @@
#if defined(MANAGER_DEBUG_PRINT) || defined(MANAGER_GRAPHVIZ_EXPORT)
#include <iostream>
#include <fstream>
-#include "core/common/Rtti.hpp"
-#include "core/model/Node.hpp"
+#include <core/common/Rtti.hpp>
+#include <core/model/Node.hpp>
+#include <core/XML.hpp>
#endif
namespace ousia {
@@ -598,6 +599,9 @@ void Manager::exportGraphviz(const char *filename)
if (type.isa(RttiTypes::Node)) {
name = dynamic_cast<const Node *>(objectPtr)->getName();
}
+ if (type.isa(RttiTypes::XMLElement)) {
+ name = dynamic_cast<const xml::Element *>(objectPtr)->name;
+ }
// Print the node
uintptr_t p = reinterpret_cast<uintptr_t>(objectPtr);
diff --git a/src/core/model/Document.cpp b/src/core/model/Document.cpp
index 5386525..912a04e 100644
--- a/src/core/model/Document.cpp
+++ b/src/core/model/Document.cpp
@@ -89,163 +89,6 @@ NodeVector<StructuredEntity> &DocumentEntity::getField(
"node.");
}
-/* Class StructuredEntity */
-
-static Rooted<Descriptor> resolveDescriptor(std::vector<Handle<Domain>> domains,
- const std::string &className,
- const RttiBase &type)
-{
- // iterate over all domains.
- for (auto &d : domains) {
- // use the actual resolve method.
- std::vector<ResolutionResult> resolved = d->resolve(className, type);
- // if we don't find anything, continue.
- if (resolved.size() == 0) {
- continue;
- }
- // Otherwise take the first valid result.
- for (auto &r : resolved) {
- return r.node.cast<Descriptor>();
- }
- }
- return {nullptr};
-}
-
-Rooted<StructuredEntity> StructuredEntity::buildRootEntity(
- Handle<Document> document, std::vector<Handle<Domain>> domains,
- const std::string &className, Variant attributes, std::string name)
-{
- // If the parent is not set, we can not build the entity.
- if (document == nullptr) {
- return {nullptr};
- }
- // If we can not find the correct descriptor, we can not build the entity
- // either.
- Rooted<Descriptor> descriptor =
- resolveDescriptor(domains, className, RttiTypes::StructuredClass);
- if (descriptor == nullptr) {
- return {nullptr};
- }
- // Then construct the StructuredEntity itself.
- Rooted<StructuredEntity> root{new StructuredEntity(
- document->getManager(), document, descriptor.cast<StructuredClass>(),
- attributes, std::move(name))};
- // append it to the document.
- document->setRoot(root);
- // and return it.
- return root;
-}
-
-Rooted<StructuredEntity> StructuredEntity::buildEntity(
- Handle<DocumentEntity> parent, std::vector<Handle<Domain>> domains,
- const std::string &className, const std::string &fieldName,
- Variant attributes, std::string name)
-{
- // If the parent is not set, we can not build the entity.
- if (parent == nullptr) {
- return {nullptr};
- }
- // If we can not find the correct descriptor, we can not build the entity
- // either.
- Rooted<Descriptor> descriptor =
- resolveDescriptor(domains, className, RttiTypes::StructuredClass);
- if (descriptor == nullptr) {
- return {nullptr};
- }
- // Then construct the StructuredEntity itself.
- Rooted<StructuredEntity> entity{new StructuredEntity(
- parent->getManager(), parent, descriptor.cast<StructuredClass>(),
- attributes, std::move(name))};
- // if the field does not exist, return null handle as well.
- if (!parent->hasField(fieldName)) {
- return {nullptr};
- }
- // append the new entity to the right field.
- if (!parent->hasField(fieldName)) {
- return {nullptr};
- }
- NodeVector<StructuredEntity> &field = parent->getField(fieldName);
- field.push_back(entity);
-
- // and return it.
- return entity;
-}
-
-/* Class DocumentPrimitive */
-
-Rooted<DocumentPrimitive> DocumentPrimitive::buildEntity(
- Handle<DocumentEntity> parent, Variant content,
- const std::string &fieldName)
-{
- // If the parent is not set, we can not build the entity.
- if (parent == nullptr) {
- return {nullptr};
- }
- // Then construct the StructuredEntity itself.
- Rooted<DocumentPrimitive> entity{
- new DocumentPrimitive(parent->getManager(), parent, content)};
- // if the field does not exist, return null handle as well.
- if (!parent->hasField(fieldName)) {
- return {nullptr};
- }
- // append the new entity to the right field.
- if (!parent->hasField(fieldName)) {
- return {nullptr};
- }
- NodeVector<StructuredEntity> &field = parent->getField(fieldName);
- field.push_back(entity);
- // and return it.
- return entity;
-}
-
-/* Class AnnotationEntity */
-
-Rooted<AnnotationEntity::Anchor> AnnotationEntity::buildAnchor(
- Handle<DocumentEntity> parent, std::string id, const std::string &fieldName)
-{
- // If the parent is not set, we can not build the anchor.
- if (parent == nullptr) {
- return {nullptr};
- }
- // Then construct the Anchor itself
- Rooted<Anchor> anchor{
- new AnnotationEntity::Anchor(parent->getManager(), parent, id)};
- // append the new entity to the right field.
- if (!parent->hasField(fieldName)) {
- return {nullptr};
- }
- NodeVector<StructuredEntity> &field = parent->getField(fieldName);
- field.push_back(anchor);
- // and return it.
- return anchor;
-}
-
-Rooted<AnnotationEntity> AnnotationEntity::buildEntity(
- Handle<Document> parent, std::vector<Handle<Domain>> domains,
- const std::string &className, Handle<AnnotationEntity::Anchor> start,
- Handle<AnnotationEntity::Anchor> end, Variant attributes, std::string name)
-{
- // If the parent is not set, we can not build the AnnotationEntity.
- if (parent == nullptr) {
- return {nullptr};
- }
- // If we can not find the correct descriptor, we can not build the entity
- // either.
- Rooted<Descriptor> descriptor =
- resolveDescriptor(domains, className, RttiTypes::AnnotationClass);
- if (descriptor == nullptr) {
- return {nullptr};
- }
- // Then construct the AnnotationEntity itself
- Rooted<AnnotationEntity> anno{new AnnotationEntity(
- parent->getManager(), parent, descriptor.cast<AnnotationClass>(),
- attributes, start, end, name)};
- // append the new entity to the document
- parent->getAnnotations().push_back(anno);
- // and return it.
- return anno;
-}
-
/* Class Document */
void Document::continueResolve(ResolutionState &state)
diff --git a/src/core/model/Document.hpp b/src/core/model/Document.hpp
index 466185b..c367e50 100644
--- a/src/core/model/Document.hpp
+++ b/src/core/model/Document.hpp
@@ -215,57 +215,6 @@ public:
std::move(name))
{
}
-
- /**
- * This builds the root StructuredEntity for the given document. It
- * automatically appends the newly build entity to the given document.
- *
- * @param document is the document this entity shall be build for. The
- * resulting entity will automatically be appended to that
- * document. Also the manager of that document will be
- * used to register the new node.
- * @param domains are the domains that are used to find the
- * StructuredClass for the new node. The domains will be
- * searched in the given order.
- * @param className is the name of the StructuredClass.
- * @param attributes are the attributes of the new node in terms of a Struct
- * variant (empty per default).
- * @param name is the name of this StructuredEntity (empty per
- * default).
- * @return the newly created StructuredEntity or a nullptr if some
- * input handle was empty or the given domains did not
- * contain a StructuredClass with the given name.
- */
- static Rooted<StructuredEntity> buildRootEntity(
- Handle<Document> document, std::vector<Handle<Domain>> domains,
- const std::string &className, Variant attributes = Variant(),
- std::string name = "");
-
- /**
- * This builds a StructuredEntity as child of the given DocumentEntity. It
- * automatically appends the newly build entity to its parent.
- *
- * @param parent is the parent DocumentEntity. The newly constructed
- * StructuredEntity will automatically be appended to it.
- * @param domains are the domains that are used to find the
- * StructuredClass for the new node. The domains will be
- * searched in the given order.
- * @param className is the name of the StructuredClass.
- * @param fieldName is the name of the field where the newly constructed
- * StructuredEntity shall be appended.
- * @param attributes are the attributes of the new node in terms of a Struct
- * variant (empty per default).
- * @param name is the name of this StructuredEntity (empty per
- * default).
- *
- * @return the newly created StructuredEntity or a nullptr if some
- * input handle was empty or the given domains did not
- * contain a StructuredClass with the given name.
- */
- static Rooted<StructuredEntity> buildEntity(
- Handle<DocumentEntity> parent, std::vector<Handle<Domain>> domains,
- const std::string &className, const std::string &fieldName = "",
- Variant attributes = Variant(), std::string name = "");
};
/**
@@ -284,25 +233,6 @@ public:
Variant getContent() const { return getAttributes(); }
// TODO: Override such methods like "getField" to disable them?
-
- /**
- * This builds a DocumentPrimitive as child of the given DocumentEntity. It
- * automatically appends the newly build entity to its parent.
- *
- * @param parent is the parent DocumentEntity. The newly constructed
- * DocumentPrimitive will automatically be appended to it.
- * @param content is the primitive content of the new node in terms of a
- * Struct variant.
- * @param fieldName is the name of the field where the newly constructed
- * StructuredEntity shall be appended.
- *
- * @return the newly created StructuredEntity or a nullptr if some
- * input handle was empty or the given domains did not
- * contain a StructuredClass with the given name.
- */
- static Rooted<DocumentPrimitive> buildEntity(
- Handle<DocumentEntity> parent, Variant content,
- const std::string &fieldName = "");
};
/**
@@ -365,45 +295,6 @@ public:
Rooted<Anchor> getStart() { return start; }
Rooted<Anchor> getEnd() { return end; }
-
- /**
- * This builds an Anchor as child of the given DocumentEntity. It
- * automatically appends the newly build Anchor to its parent.
- *
- * @param parent is the parent DocumentEntity. The newly constructed
- * Anchor will automatically be appended to it.
- * @param id is the id of this Anchor.
- * @param fieldName is the name of the field where the newly constructed
- * Anchor shall be appended.
- *
- * @return the newly created Anchor or a nullptr if some
- * input handle was empty.
- */
- static Rooted<Anchor> buildAnchor(Handle<DocumentEntity> parent,
- std::string id,
- const std::string &fieldName = "");
- /**
- * This builds an AnnotationEntity as child of the given DocumentEntity. It
- * automatically appends the newly build entity to its parent.
- *
- * @param parent is the document the newly constructed AnnotationEntity
- * will be appended to.
- * @param domains are the domains that are used to find the
- * AnnotationClass for the new node. The domains will be
- * searched in the given order.
- * @param className is the name of the AnnotationClass.
- * @param attributes are the attributes of the new node in terms of a Struct
- * variant (empty per default).
- * @param name is the name of this AnnotationEntity (empty per
- * default).
- * @return the newly created AnnotationEntity or a nullptr if some
- * input handle was empty or the given domains did not
- * contain a AnnotationClass with the given name.
- */
- static Rooted<AnnotationEntity> buildEntity(Handle<Document> parent, std::vector<Handle<Domain>> domains,
- const std::string &className,
- Handle<Anchor> start, Handle<Anchor> end,
- Variant attributes = Variant(), std::string name = "");
};
/**
diff --git a/src/plugins/html/DemoOutput.cpp b/src/plugins/html/DemoOutput.cpp
index 3bd5918..5413b1f 100644
--- a/src/plugins/html/DemoOutput.cpp
+++ b/src/plugins/html/DemoOutput.cpp
@@ -37,7 +37,7 @@ void DemoHTMLTransformer::writeHTML(Handle<model::Document> doc,
mgr, {nullptr}, "html", {{"xlmns", "http://www.w3.org/1999/xhtml"}}}};
// add the head Element
Rooted<xml::Element> head{new xml::Element{mgr, html, "head"}};
- html->children.push_back(head);
+ html->addChild(head);
// add the meta element.
Rooted<xml::Element> meta{
new xml::Element{mgr,
@@ -45,15 +45,15 @@ void DemoHTMLTransformer::writeHTML(Handle<model::Document> doc,
"meta",
{{"http-equiv", "Content-Type"},
{"content", "text/html; charset=utf-8"}}}};
- head->children.push_back(meta);
+ head->addChild(meta);
// add the title Element with Text
Rooted<xml::Element> title{new xml::Element{mgr, head, "title"}};
- head->children.push_back(title);
- title->children.push_back(
+ head->addChild(title);
+ title->addChild(
new xml::Text(mgr, title, "Test HTML Output for " + doc->getName()));
// add the body Element
Rooted<xml::Element> body{new xml::Element{mgr, html, "body"}};
- html->children.push_back(body);
+ html->addChild(body);
// So far was the "preamble". No we have to get to the document content.
@@ -75,7 +75,7 @@ void DemoHTMLTransformer::writeHTML(Handle<model::Document> doc,
// transform the book node.
Rooted<xml::Element> book = transformSection(body, root, startMap, endMap);
// add it as child to the body node.
- body->children.push_back(book);
+ body->addChild(book);
// After the content has been transformed, we serialize it.
html->serialize(
@@ -138,14 +138,14 @@ Rooted<xml::Element> DemoHTMLTransformer::transformSection(
break;
}
Rooted<xml::Element> h{new xml::Element{mgr, sec, headingclass}};
- sec->children.push_back(h);
+ sec->addChild(h);
// extract the heading text, enveloped in a paragraph Element.
Rooted<xml::Element> h_content =
transformParagraph(h, heading, startMap, endMap);
// We omit the paragraph Element and add the children directly to the
// heading Element
- for (auto &n : h_content->children) {
- h->children.push_back(n);
+ for (auto &n : h_content->getChildren()) {
+ h->addChild(n);
}
}
@@ -169,7 +169,7 @@ Rooted<xml::Element> DemoHTMLTransformer::transformSection(
child = transformSection(sec, n, startMap, endMap);
}
if (!child.isNull()) {
- sec->children.push_back(child);
+ sec->addChild(child);
}
}
return sec;
@@ -189,14 +189,14 @@ Rooted<xml::Element> DemoHTMLTransformer::transformList(
if (itDescrName == "item") {
// create the list item.
Rooted<xml::Element> li{new xml::Element{mgr, l, "li"}};
- l->children.push_back(li);
+ l->addChild(li);
// extract the item text, enveloped in a paragraph Element.
Rooted<xml::Element> li_content =
transformParagraph(li, item, startMap, endMap);
// We omit the paragraph Element and add the children directly to
// the list item
- for (auto &n : li_content->children) {
- li->children.push_back(n);
+ for (auto &n : li_content->getChildren()) {
+ li->addChild(n);
}
}
}
@@ -220,7 +220,7 @@ static Rooted<xml::Element> openAnnotation(
}
// create the new XML element representing the annotation
Rooted<xml::Element> tmp{new xml::Element{mgr, current, elemName}};
- current->children.push_back(tmp);
+ current->addChild(tmp);
// and return it.
return tmp;
}
@@ -265,14 +265,14 @@ Rooted<xml::Element> DemoHTMLTransformer::transformParagraph(
Rooted<model::StructuredEntity> heading = par->getField("heading")[0];
// put the heading in a strong xml::Element.
Rooted<xml::Element> strong{new xml::Element{mgr, p, "strong"}};
- p->children.push_back(strong);
+ p->addChild(strong);
// extract the heading text, enveloped in a paragraph Element.
Rooted<xml::Element> h_content =
transformParagraph(strong, heading, startMap, endMap);
// We omit the paragraph Element and add the children directly to the
// heading Element
- for (auto &n : h_content->children) {
- strong->children.push_back(n);
+ for (auto &n : h_content->getChildren()) {
+ strong->addChild(n);
}
}
@@ -346,7 +346,7 @@ Rooted<xml::Element> DemoHTMLTransformer::transformParagraph(
// here we need to do some escaping with the string content.
std::string escaped =
escapePredefinedEntities(primitive->getContent().asString());
- current->children.push_back(new xml::Text(mgr, current, escaped));
+ current->addChild(new xml::Text(mgr, current, escaped));
}
}
return p;
generated by cgit v1.2.3 (git 2.39.1) at 2025-05-01 07:26:56 +0000