Multi-level modeling o ers substantial advantages when expressing complex domain concepts, and it comes with the promise to allow a ne-grained reuse and extensibility of (domain-speci c) modeling languages on di erent levels of conceptual abstractions. A small number of tooling environments have been proposed that support multilevel modeling. However, in order to be able to unleash the potential of multi-level models as widely accepted means to formally de ne complex concepts, and to realize the promises of reusability and extensibility, a representation format for multi-level models is required, which is easy to understand for modeling experts, and is independent from any speci c tooling environment. This paper proposes design principles of an XML format for representing multi-level models as XML documents. The approach is realized as a lightweight extension to the XML Schema De nition (XSD) standard, using built-in XML language extension mechanisms. The implementation of a multi-level schema validator is provided as a proof of concept.
XML documents with multiple levels of type abstractions Multi-level modeling is an extension to the well-known object-oriented modeling paradigm. In multi-level modeling, it is possible to de ne a hierarchy of concepts in which instances of higher-level types can describe types, from which again instances can be derived, and so forth. In other words, objects that are instantiated out of classes can also serve as class-descriptions, and can further be instantiated to objects, which themselves can serve as class-descriptions from which objects can be instantiated. This supports type hierarchies across multiple levels of type-instance relationships. For example, when speaking of Vehicle, Car, Volvo, Volvo MX 7, and Peter's new Volvo MX 7, in this list, Car, Volvo, and Volvo MX 7 both act as instances of the concept directly mentioned before, and as types of the concept directly mentioned afterwards.
Especially when it comes to reconstructing domains of discourse that re ect
socio-technical systems with concepts that are described in human
understandable natural language, the multi-level modeling paradigm has been evaluated to
enable a potentially large gain in expressivity, and to allow the reuse of modeling
language concepts on multiple levels of conceptual abstraction [
Some tooling environments support modeling languages with multi-level
capabilities, such as the Flexible Meta-Modeling and Execution
Language (FMMLx) [
However, one assumed reason why the multi-level modeling paradigm has not yet found wider support in science and practice, is the lack of a standardized representation of multi-level models, independent from particular modeling tools, and based on a widespread implementation language. Such a representation could serve as a means of communication among modeling experts to mutually exchange and evaluate multi-level models, and to o er collections of multi-level models in central places. In addition, a standardized representation could serve as an exchange format for multi-level models, and could foster the integration of di erent multi-level modeling tools to become part of an interoperable tooling environment.
One of the most widespread meta-modeling languages is XML, which
provides a standard syntax to represent content, a schema de nition and validation
mechanism provided by the XML Schema De nition (XSD) language [
This paper introduces fundamental principles for specifying multi-level models in XML that make use of existing XML technology in the described way. The elaboration provides a backward compatible schema validation mechanism to validate the formal semantics of multi-level models, i. e., to determine whether all entities in a multi-level model are valid according to the multi-level type de nitions provided by their ancestor entities. The introduced design principles can serve as a basis for specifying an implementation-independent representation format for multi-level models that is readable by human experts, and an exchange format between di erent tooling environments for multi-level modeling.
Two central research questions are examined in this paper, which are to be answered as prerequisites for enhancing XML with multi-level modeling capabilities. These research questions are: Q1: How can XML be extended in a way that both instance characteristics and type speci cation characteristics can be represented by XML entity elements? Q2: How can the central mechanism of schema validation of XML documents be adapted to multi-level XML?
The questions are addressed by extending the existing XML language speci cation and validation mechanisms to express a core set of multi-level characteristics, which are supported by selected multi-level modeling approaches.
The key idea of the proposed approach lies in merging XML document
instances with XML schema de nitions, and add a notion of delayed instantiation
semantics, also known as \intrinsic" features [
The remainder of the paper is structured as follows: Sect. 2 elaborates modi cations to the original XML declaration mechanisms that allow for the implementation of multi-level model characteristics in XML, and it introduces the prototype implementation of a multi-level schema validator. An example that demonstrates the presented approach is shown in Sect. 3. The nal Sect. 4 concludes the work. 2 2.1
To represent multi-level models in an XML document format, a number of essential requirements guide the design of the representation language. The central requirements and design decisions proposed for MXML, which is the prototypical language developed here, are stated in the following.
Req. 1 Combine type de nitions and instance entity de nitions This is the most important requirement to be ful lled for realizing multilevel modeling with XML. In XML, instances and types can be mixed by allowing a <xsd:complexType> ... </xsd:complexType> element to occur as an optional child element in any XML element of a multi-level XML document. Like any cleanly de ned XML dialect, XSD is de ned in its own namespace. Mixing it with content from other namespaces will thus not in uence the processing of any other document content, which is an inherent extensibility feature of XML.
Req. 2 Provide multi-level features: abstraction levels, intrinsic features Additional information that is required for specifying multi-level models is provided through the use of attributes with the ml: namespace pre x. They integrate with existing document content in the same orthogonal manner as inserted XSD schema fragments. The attributes currently suggested as multi-level extensions to any XML entity element are: ml:level (optional) The absolute abstraction level of the entity. If a metaentity is speci ed using ml:of, this defaults to level-1 of the meta-class. ml:of (optional) The meta-entity of the entity. If not speci ed, the entity is considered to instantiate the default XML entity meta-type. ml:abstract (optional) Flag to indicate whether the entity should be considered abstract. In this case, any attributes, children elements, or text-content will be ignored by the schema validator and the entity serves as a class declaration only.
The following attributes are suggested as extensions to the <xsd:element> and <xsd:attribute> elements: ml:intrinsic (optional) Absolute level on which the declaration should be instantiated. ml:potency (optional) Relative level, counting from the current, on which the declaration should be instantiated.
The former two attributes are mutually exclusive. If none of these attributes is provided, the type declaration element, like in conventional XSD, takes e ect immediately during the next instantiation, i. e., it becomes e ective for the element it is declared in.
The ml:intrinsic / ml:potency attributes are representatives for fundamental multi-level model characteristics that provide delayed instantation. This set of attributes can be re ned in later versions to also cover range and leap potency, with a more ne-grained speci cation of min, max, and depth values.
Req. 3 Design with minimal invasive changes to existing standards In order to provide a lean integration into existing XML standards, which allows an easy adaption and also keeps the implementation more e cient through reusability, the design should opt for as few modi cations to the original XML language mechanisms as possible. This requirement is ful lled in the proposed solution by reusing parts of the XSD language for specifying type characteristics of multi-level entities. When validating, XSD fragments from a multi-level document will be transformed to a standard XSD document, which is then used for validation.
Req. 4 Implement with recursion to existing schema validation To implement a schema validator for MXML documents, the approach should reuse a standard XSD schema validator. This is desirable both in order to formally prove the backward compatibility of the approach, as well as for an e cient development of the MXML schema validator. The suggested approach realizes this by using a two-phase validation process, in which rst the MXML document is transformed to a temporary XSD schema document and a plain XML representation, and then an existing XSD validator is invoked which applies the schema to the plain XML.
A few additional conventions apply to this proposed language design. If multiple element instances of the same name contain schema de nitions, the de nition statements are syntactically merged together in the same way as if they were all given in only one schema de nition. No element instance has priority over another in specifying schema de nitions. It may, however, turn out to be a good notation style to locate an element's schema de nition in only the rst element by convention, which can be expected to increase the readability and maintainability of manually edited MXML documents.
On the top nesting level of the element hierarchy in MXML documents, any regular XSD fragment may be placed. This allows to include auxiliary non-multilevel schema declarations, e. g., an enumeration type for de ning the value range of an attribute used by a multi-level entity. 2.2
A syntax for interweaving XML instance content with XSD schema declarations in MXML is proposed in the following. According to common grammar notation conventions, parts enclosed in [...] are optional, parts in f...g can occur zero to any times, and a vertical bar j indicates a choice between either the left- or the right-hand side. The syntax of any XML element is rede ned as follows: <element { attrN="..." } [ ml:level="level" ] [ ml:of="parent" ] [ ml:abstract="[true]" ] > [ <xsd:complexType>
... schema declarations ...
</xsd:complexType> ] { <child {attrN="..."} > ... </child> } [ text content ] </element>
This means, any XML element can at rst act as a regular element instance with the ability to have attributes, nested children elements, and text content. In addition, any XML element can also contain a schema de nition fragment, which de nes the formal semantics of instances of the element. The proposed syntax of XSD schema de nition fragments to be included in any multi-level XML element is shown in the following: <xsd:complexType> <xsd:sequence> { <xsd:element { attrN="..." }
[ ml:intrinsic="level" | ml:potency="levels" ] > ...
</xsd:element> } </xsd:sequence> { <xsd:attribute { attrN="..." }
[ ml:intrinsic="level" | ml:potency="levels" ] > ...
</xsd:attribute> } </xsd:complexType>
The structure-descriptor <xsd:sequence> ... </xsd:sequence> around the children element type declarations is included for compatibility with XSD, but does not carry meaning in the current version of MXML. Any structuredescriptor will internally be treated equivalent to <xsd:choice minOccurs="0" maxOccurs="unbounded"> ... </xsd:choice>, which means that children elements may occur in any order and for an arbitrary number of times. This is syntactically compatible to any available structure-descriptor in XSD, i. e., children elements can be arranged in any structure, but the desired structure must be enforced by convention and will not formally be validated. 2.3
As a proof of concept, a schema validator that takes into account the multi-level nature of MXML documents has been developed.∗ According to Req. 4, the implementation of the schema validator is kept as lean as possible and reuses existing XSD schema validation functionality.
The multi-level approach allows documents to mix instance content and schema de nitions. Existing XML validation approaches, however, assume that instance content (.xml) and schema de nitions (.xsd) are stored in separate documents. To trace back multi-level document validation to traditional schema validation, it is thus required to separate the schema information in a multi-level document from the instance content. This is done by using two XSLT transformations that take as input an MXML document, and temporarily generate one XML instance document and one XML Schema De nition document out of it. The instance document can then be validated against the schema document using an existing XSD validator.
The documents involved in an MXML application and their interrelationships are shown in Fig. 1. To validate an MXML document doc.xml, the XSLT transformation mlschema.xsl is applied to it, which generates a temporary XML Schema De nition document doc-schema.xsd. The mlinstance.xsl transformation is applied to generate a plain XML instance document without multilevel speci cation parts. This document is then validated against the generated schema.
A fundamental advantage of this validation approach is that it proves the backward compatibility of MXML by construction, because the relationships between the original MXML document and the temporary non-MXML instance and schema documents are formally de ned by the mlschema.xsl and mlinstance.xsl transformations. One disadvantage, however, is that in case a validation error occurs, it might be challenging to trace an error message that was issued for the transformed documents, back to the origin of an error in the MXML document. A solution to this would be to supplement the schema validator with another XSLT transformation that checks additional validity constraints on the MXML document. An example of such a constraint would be to ensure that an entity on level m must not contain intrinsic attributes with an instantiation level greater than m. This option is not implemented yet, which is why the transformation mlvalidate.xsl is displayed with a dashed border in Fig. 1. 2.4
The fundamental idea behind multi-level modeling is based on the combined notion of entities carrying instance properties and type declarations at the same time. This kind of entities has been discussed in several works on extensions ∗The schema validator implementation and the example artifacts are available at https://www.wi-inf.uni-due.de/FGFrank/download/mxml-0.1.0.zip. doc.xml schema validator + mlvalidate.xsl rveasliudlattion mlinstance.xsl
doc(t-einmsptaonracrey.x)ml
to the object-oriented modeling paradigm, e. g., by [
Modeling approaches that incorporate the notion of such entities into a
multilevel modeling language are proposed by, e. g., [
An approach which combines the XML Metadata Interchange (XMI)
format with Ecore representations of meta-models is MultEcore [
One should be aware that the term \multi-level XML document" is sometimes used in XML teaching literature with a di erent meaning. Several web pages about XML basics use the term \multi-level" to refer to XML documents with a nesting depth of children elements greater than one. That means, whenever an element that is a direct child of the document root element has at least one more child element nested inside, the XML document is considered to be \multilevel". This, of course, has nothing to do with the notion of multiple abstraction levels for type descriptions as it is addressed in this work.
The following listing shows an MXML document that speci es ingredients of a cooking recipe. A general type Ingredient is re ned into the types VegetarianIngredient and Spice, the latter of which gets further re ned into Salt and Pepper. <ingredients xmlns:ml="urn:ml" xmlns:xs="http://www.w3.org/2001/XMLSchema"> <ingredient ml:abstract="yes"> <xs:complexType> <xs:sequence> <!-- <xs:element ref="name"/> (implicit by language) --> <xs:element name="price" type="xs:string" ml:potency="-1"/> <xs:element name="tasteDescription" type="xs:string" ml:potency="2"/> </xs:sequence> <xs:attribute name="healthy" type="xs:boolean" ml:potency="1"/> </xs:complexType> </ingredient> <vegetarianIngredient ml:of="ingredient" healthy="true"> <xs:complexType> <xs:sequence>
<xs:attribute name="healthy" type="xs:boolean"/> </xs:sequence> </xs:complexType> </vegetarianIngredient> <spice ml:of="ingredient"> <xs:complexType> <xs:attribute name="appetizing" type="xs:boolean"/> <xs:attribute name="sudatory" type="xs:boolean"/> <!-- makes you sweat --> <xs:attribute name="digestive" type="xs:boolean"/> </xs:complexType> </spice> <pepper ml:of="spice" color="red"> <xs:complexType>
<xs:attribute name="color" type="pepperColor"/> </xs:complexType> <tasteDescription>very tasty!</tasteDescription> </pepper> <!-- this is a regular level-agnostic auxiliary XML Schema definition --> <xs:simpleType name="pepperColor" final="restriction"> <xs:restriction base="xs:string"> <xs:enumeration value="green" /> <xs:enumeration value="black" /> <xs:enumeration value="white" /> <xs:enumeration value="red" /> </xs:restriction> </xs:simpleType> <salt ml:of="spice"> <xs:complexType>
<xs:attribute name="avgLifetime" type="xs:double"/> </xs:complexType> <tasteDescription>very tasty!</tasteDescription> </salt> <pepper ml:of="spice" color="green"/> </ingredients>
This document can be validated using the run-validator.xml script from the example implementation package, which produces both a temporary .xsd le and a temporary .xml le. The former is subsequently applied as the validating schema to the latter, using a standard XSD schema validator. When run with the example, the output of the run-validator.xml script is empty, which indicates that no error during validation has been found and the MXML document is considered to be formally valid. 4
This work has suggested fundamental design principles to extend XML with multi-level modeling capabilities. It includes a lean language implementation that integrates well with existing XML concepts and tools. As the language is independent from any tooling environment, it can potentially serve as an exchange format for experts to communicate about multi-level models, build shared libraries of multi-level models, and achieve interoperability between different multi-level modeling tools on the technical level.
Two research questions had initially been asked, the rst about how XML can be extended in a way that both instance and type characteristics of multilevel model entities can be represented by XML elements (Q1 ), and the second on how a schema validation mechanism for multi-level XML documents can be provided, based on the existing XSD language (Q2 ). Both questions have been answered by designing an XML dialect which ful lls 4 main requirements: Req. 1 demanded for the ability to combine type de nitions and instance entity de nitions in the representation format. This has been achieved by interweaving regular XML content with XSD fragments. Req. 2 demanded for multi-level type characteristics, such as delayed instantiation, to be expressable by the language, which has been achieved by de ning attributes using the ml: namespace pre x for describing multi-level characteristics of XML entities. These attributes extend the semantics of <xsd:element> and <xsd:attribute> declarations. This lean set of proposed language extensions also adheres to Req. 3, which demanded for applying minimal invasive changes to the existing XML language mechanisms. The last requirement Req. 4 suggested to reuse existing schema validation components to implement a multi-level schema validator, which has been realized by a prototypical schema validator implementation (see Sect. 2.3).
The presented work is intended to elaborate fundamental design principles for representing multi-level models with XML. It does not claim to o er a complete exchange format for tool integration, which would require a set of signi cantly longer standardization documents. As a consequence, several limitations apply to the current elaboration of MXML. At rst, the range of supported multi-level features is limited to a set of concepts provided by selected multi-level modeling approaches. Extending the range of supported approaches will be subject to future work. On the implementation level, the next step to improve the schema validator will be to support the use of the ml:intrinsic attribute to specify an absolute intrinsic level attached to <xsd:element> and <xsd:attribute> declarations. Currently, only relative level distances speci ed by ml:potency are supported.
Behavior-related aspects, e. g., the adaptation of the XPath query language
[
Future work should also cover the extension of MXML to a uni ed representation of language features from all representative multi-level modeling approaches. This could be done by assembling meta-models of the respective languages, and create a uni ed meta-model for MXML that incorporates all individual language approaches. To exemplify the integration capabilities of the exchange format, a set of importers and exporters should be provided for existing multi-level modeling tools, e. g., in the form of model transformations that convert between the internal representation formats of the tools and MXML.