Home /Modules/xml/SLXmlDocument.sleela

SLXmlDocument.sleela

lib/xml/SLXmlDocument.sleela · 213 line(s) · sleela

<< lib/xml/SLXmlDocument.sleela
   SLeeLa Standard Library Definition.
   Definition: Defines SLXmlDocument -- the DOM document. It owns the single root
     element, carries the XML declaration (version/encoding/standalone), acts as
     the factory for new nodes (createElement/createTextNode/...), and offers the
     document-level queries getElementById-style lookup and getElementsByTagName. >>
#sleela 2.5
material;
< Family: xml. The DOM Document: the owner and factory for a tree of SLXmlNode. >
< A document has exactly one root element (the "document element") plus the XML >
< declaration it emits first. The create* methods are the DOM node factory; a >
< GUI or application builds a tree by asking the document for nodes and appending >
< them. The serializer is held as a field and drives toXml()/toPrettyXml(), so a >
< caller drives one object end to end. >
class SLXmlDocument {
  < ---- Descriptive metadata (version 1.11 nested-friendly accessors) ---- >
  << Eleven catalogued attributes with getter/setter pairs, so a GUI, loader,
     or catalog can read and (where appropriate) override this record.
     Values are faithful to the subject's real origin where publicly known. >>
  String metaVersion = "1.0.0";
  int metaId = 7926;
  String metaAuthor = "Kiro Agent";
  String metaDate = "2026-10-28";
  String metaCopyright = "SLeeLa project";
  String metaTrademark = "none";
  String metaCorporation = "none";
  < metaOrigin: National | <nation> | International | Galactic >
  String metaOrigin = "International";
  String metaBirthDate = "2026-10-28";
  < metaScienceRating: maturity/robustness on a 1..10 scale >
  int metaScienceRating = 9;
  < metaNationalSchedule: a real, citable instrument. >
  String metaNationalSchedule = "W3C DOM Level 1 Document interface";

  String getMetaVersion() { return metaVersion; }
  void setMetaVersion(String v) { metaVersion = v; }
  int getMetaId() { return metaId; }
  void setMetaId(int v) { metaId = v; }
  String getAuthor() { return metaAuthor; }
  void setAuthor(String v) { metaAuthor = v; }
  String getDate() { return metaDate; }
  void setDate(String v) { metaDate = v; }
  String getCopyright() { return metaCopyright; }
  void setCopyright(String v) { metaCopyright = v; }
  String getTrademark() { return metaTrademark; }
  void setTrademark(String v) { metaTrademark = v; }
  String getCorporation() { return metaCorporation; }
  void setCorporation(String v) { metaCorporation = v; }
  String getOrigin() { return metaOrigin; }
  void setOrigin(String v) { metaOrigin = v; }
  String getBirthDate() { return metaBirthDate; }
  void setBirthDate(String v) { metaBirthDate = v; }
  int getScienceRating() { return metaScienceRating; }
  void setScienceRating(int v) { metaScienceRating = v; }
  String getNationalSchedule() { return metaNationalSchedule; }
  void setNationalSchedule(String v) { metaNationalSchedule = v; }

  < ---- XML declaration + root ---- >
  String xmlVersion = "1.0";
  String encoding = "UTF-8";
  boolean standalone = true;
  SLXmlNode root;
  SLXmlSerializer writer;

  < Build an empty document with a default declaration and a wired serializer. >
  void create() {
    xmlVersion = "1.0";
    encoding = "UTF-8";
    standalone = true;
    root = null;
    writer = new SLXmlSerializer();
  }

  String getXmlVersion() { return xmlVersion; }
  void setXmlVersion(String v) { xmlVersion = v; }
  String getEncoding() { return encoding; }
  void setEncoding(String v) { encoding = v; }
  boolean getStandalone() { return standalone; }
  void setStandalone(boolean v) { standalone = v; }

  < ---- node factory (DOM Document.create*) ---- >

  SLXmlNode createElement(String tag) {
    SLXmlNode n = new SLXmlNode();
    n.asElement(tag);
    return n;
  }
  SLXmlNode createTextNode(String value) {
    SLXmlNode n = new SLXmlNode();
    n.asText(value);
    return n;
  }
  SLXmlNode createCDataSection(String value) {
    SLXmlNode n = new SLXmlNode();
    n.asCData(value);
    return n;
  }
  SLXmlNode createComment(String value) {
    SLXmlNode n = new SLXmlNode();
    n.asComment(value);
    return n;
  }
  SLXmlNode createProcessingInstruction(String target, String value) {
    SLXmlNode n = new SLXmlNode();
    n.asProcessingInstruction(target, value);
    return n;
  }

  < ---- root management ---- >

  < Install `element` as the single document element and return it. >
  SLXmlNode setDocumentElement(SLXmlNode element) {
    root = element;
    return element;
  }
  < Create, install, and return a root element named `tag`. >
  SLXmlNode newRoot(String tag) {
    return setDocumentElement(createElement(tag));
  }
  SLXmlNode documentElement() { return root; }
  boolean hasRoot() { return root != null; }

  < ---- document-level queries ---- >

  < Every element in the document with tag `tag` (document order), collected >
  < into a throwaway element whose children are the matches. "*" matches all. >
  < Returns an element node acting as a NodeList; read it with childCount()/ >
  < childAt(). Returns an empty collection when there is no root. >
  SLXmlNode getElementsByTagName(String tag) {
    SLXmlNode list = new SLXmlNode();
    list.asElement("#node-list");
    if (root == null) { return list; }
    if (tag == "*" || root.name() == tag) { list.appendChild(root); }
    root.collectByTag(tag, list);
    return list;
  }

  < The first element whose "id" attribute equals `id`, or null (DOM-style >
  < getElementById; this DOM treats the literal attribute name "id"). >
  SLXmlNode getElementById(String id) {
    if (root == null) { return null; }
    return findById(root, id);
  }
  SLXmlNode findById(SLXmlNode e, String id) {
    if (e == null) { return null; }
    if (e.isElement()) {
      String got = e.getAttribute("id");
      if (got != null && got == id) { return e; }
      int cn = e.childCount();
      for (int i = 0; i < cn; i = i + 1) {
        SLXmlNode c = e.childAt(i);
        SLXmlNode hit = findById(c, id);
        if (hit != null) { return hit; }
      }
    }
    return null;
  }

  < Total number of element nodes in the document (root included). >
  int elementCount() {
    if (root == null) { return 0; }
    return 1 + root.descendantElementCount();
  }
  < Nesting depth of the document element (0 when empty). >
  int depth() {
    if (root == null) { return 0; }
    return root.depth();
  }

  < ---- serialization ---- >

  < The XML declaration line (<?xml version="1.0" encoding="UTF-8" ...?>). >
  String declaration() {
    String sa = "no";
    if (standalone) { sa = "yes"; }
    return "<?xml version=\"" + xmlVersion + "\" encoding=\"" + encoding
         + "\" standalone=\"" + sa + "\"?>";
  }

  < The whole document as compact well-formed XML (declaration + tree). >
  String toXml() {
    if (writer == null) { writer = new SLXmlSerializer(); }
    if (root == null) { return declaration(); }
    return declaration() + writer.toXml(root);
  }
  < The whole document, pretty-printed (declaration on its own line). >
  String toPrettyXml() {
    if (writer == null) { writer = new SLXmlSerializer(); }
    if (root == null) { return declaration(); }
    return declaration() + "\n" + writer.toPrettyXml(root);
  }

  << ---- equality (the same three-rung tie, at document scope) ----
     Tier 1 identity is the native == on the document objects. Beyond that a
     document IS its tree, so structural equality defers to the root elements'
     SLXmlNode.equals (the recursive Tier 3 tie). Two empty documents (no root)
     are structurally equal; an empty and a non-empty document are not.
     Reflexive, symmetric, and deterministic. >>
  boolean sameReference(SLXmlDocument other) { return this == other; }

  boolean equals(SLXmlDocument other) {
    if (other == null) { return false; }
    if (this == other) { return true; }
    SLXmlNode mine = root;
    SLXmlNode theirs = other.documentElement();
    if (mine == null) { return theirs == null; }
    if (theirs == null) { return false; }
    return mine.equals(theirs);
  }
  < Alias reading as "the same structure". >
  boolean sameStructure(SLXmlDocument other) { return equals(other); }
}