Dynamic Model

1. Introduction

The dynamic model is an abstract object-oriented programming method. It adheres to the object-oriented concept of "everything is an object", so the concept of dynamic model starts from "things".

2. Basic concepts

Model (Thing)
Models are structured data, and models can be used to represent various things, sometimes called models things. The structured data here refers to tree-structured data, such as XML and JSON.
Action
The dynamic model believes that any model can be transformed into an action, and the action is equivalent to the function and method in programming, and the action can be executed. Dynamic models assume that any model can be transformed into an action.
ActionContext
Sometimes also called variable context. Used to store variables and maintain execution state during action execution.
World
The container for the model. Generally, the model is obtained through World. Concepts correspond to things, and the container containing various things is called the world.

3. Object-oriented

The two concepts of things and actions are abstract. To be able to program, you need to use these two concepts to implement object-oriented programming methods.

3.1. Object

We need to use the model to represent the object, the following is the method to use the model to represent the object.

<Person name="zhangsan" age="40">
     <actions>
         <GroovyAction name="helloWorld" code="println &quote;hello world&quote"/>
     </actions>
</Person>

If the above XML is a model, it can be used as an object:

Properties of an object
Nodes in XML can have their own attributes and child nodes, which can be regarded as attributes of objects.
Object Behavior
In the dynamic model, each node in XML is regarded as an independent model, and the dynamic model stipulates that any model can be converted into actions for execution, so some sub-nodes of a model can be artificially specified as object behaviors.
For example, in the above XML, the sub-nodes under the actions sub-node are specified as the behavior of the object, then the object whose name is zhangsan has a behavior named helloWorld.

3.2. Type of object

A descriptor in a dynamic model is equivalent to a class in an object-oriented model.

In a dynamic model, a model can use any model as its descriptor, and the model inherits the behavior of the describer.

For example, the description of the <Person name="zhangsan.../> model below is the <thing name="Person".../> model

<?xml version='1.0' encoding='utf-8'?>

<Person name="Zhangsan" descriptors="xworker.doc.dyanmicmodel.examples.Person" age="40"
      sex="0">
     <Child name="Xiaoming" age="10" sex="0"/>
     <Child name="Lili" age="5" sex="1"/>
</Person>

<?xml version='1.0' encoding='utf-8'?>

<thing name="Person" descriptors="xworker.lang.MetaDescriptor3">
     <actions>
         <GroovyAction name="sayHello" descriptors="xworker.groovy.GroovyAction" code="println self.name + &quot; say hello world&quot;;"/>
     </actions>
     <attribute name="name"/>
     <attribute name="age"/>
     <attribute name="sex" inputtype="select">
         <value name="male" value="0"/>
         <value name="female" value="1"/>
     </attribute>
     <attribute name="description" inputtype="html"/>
     <thing name="Child" extends="xworker.doc.dyanmicmodel.examples.Person"/>
</thing>

In the above example, the describer of zhagnsan is Person. Person can be used to describe the behavior, attributes and child nodes of zhangsan.

Behavior
Person defines the sayHello behavior and Zhang San also inherits this behavior.
Attributes
The <attribute nam="xxx".../> child node of Person can be used to indicate which attributes zhangsan has.
Child nodes
The <thing name="xxx" .../> child node of Person can be used to indicate which child nodes zhagnsan has.

3.3. Inheritance

In a dynamic model, a model can inherit any other model except itself, thereby inheriting the behavior of the inherited model. If the model is used as a describer, it also inherits the description of attributes and child nodes.

Inheritance is useful for complex models and frameworks. For example, in the following model, the Child child node inherits the root node Person, so Child is also Person, and it also has the behaviors, attributes and child nodes described by Person.

<?xml version='1.0' encoding='utf-8'?>

<thing name="Person" descriptors="xworker.lang.MetaDescriptor3">
     <actions>
         <GroovyAction name="sayHello" descriptors="xworker.groovy.GroovyAction" code="println self.name + &quot; say hello world&quot;;"/>
     </actions>
     <attribute name="name"/>
     <attribute name="age"/>
     <attribute name="sex" inputtype="select">
         <value name="male" value="0"/>
         <value name="female" value="1"/>
     </attribute>
     <attribute name="description" inputtype="html"/>
     <thing name="Child" extends="xworker.doc.dyanmicmodel.examples.Person"/>
</thing>

The extends attribute in the above XML code is used to indicate inheritance, such as: extends="xworker.doc.dyanmicmodel.examples.Person".

4. How to run the model

4.1. Dynamic model engine, metalanguage and metasystem

The dynamic model needs to be realized by other programming languages. The realization of the dynamic model is called the dynamic model engine, and the language and system that realize the dynamic model are called meta-language and meta-system. For example, XWorker's dynamic model engine is implemented using Java, Java is a meta-language, and JVM is a meta-system.

4.2. How to run the model

The dynamic model is an object-oriented programming method. The model can be regarded as an object, and running a model can be regarded as executing the behavior of an object.

In the dynamic model, the behavior of the model is also a model. To execute the behavior of the model, it needs to be converted into an action for execution.
When the model is converted into an action execution, the behavior whose name is run is executed. To execute the behavior of the model named run, go back to step 1.
The above is an iterative process. To terminate the iteration, some models need to be executed directly by the engine instead of continuing to recursively execute the behavior named run.

For example, the dynamic model engine of XWorker is implemented in Java, and the model whose class name is JavaAction is directly executed by the engine. Among them, the function of JavaAction is to execute a certain Java method, or to compile and execute the code given in the model.

5. Metamodel

The metamodel is a data structure accidentally discovered in programming. It can solve the problem of model editing and also has a little philosophical meaning.

5.1. The principle of editing models

In XWorker, the model can be edited through the model editor, the principle is as follows.

In object-oriented, objects can be instantiated through classes. In the model editor, classes are used to dynamically generate an edit form, and users can edit a model through the form.
Take the class as an object, and you can edit it in the model editor through its (as an object) class.

The above is an iterative process. To terminate the iteration, an object is needed, which is its own class. It can edit itself or any other class by itself. This object is the metamodel.

5.2. Metamodel discovery process

In the dynamic model, objects are represented by tree-structured data. For example, XML can be used to represent an object, so an object can be represented as XML.

When using XML to represent an object, we define the structure of the object in the following way.

Use <thing name="xxx"/> to represent an XML node.
Use <attribute name="xxx"/> to represent an attribute in an XML node.

For example, the following XML.

<Person name="Zhangsan" age="40">
     <Child name="Xiaoming" age="10"/>
</Person>

The structure of this XML is as follows.

<thing name="Person">
     <attribute name="name"/>
     <attribute name="age"/>
     <thing name="Child">
         <attribute name="name"/>
         <attribute name="age"/>
     </thing>
</thing>

Through the above definition of XML structure, then we can calculate any XML structure, we can find that the calculated result is still XML, and then we can iterate the calculation, and finally find that it can be iterated to an XML, this The XML is as follows.

<thing name="thing"">
     <attribute name="name"/>
     <thing name="attribute">
         <attribute name="name"/>
     </thing>
     <thing name="thing">
         <attribute name="name/>
         <thing name="attribute">
             <attribute name="name"/>
         </thing>
         <thing name="thing">
         ....
         </thing>
     </thing>
</thing>

This is an XML with the same nodes at each layer and infinite layers.

Since this XML has infinite layers, it cannot be expressed directly. In order to be able to express it, we introduce the concept of inheritance, so that it can be simplified into the following XML.

<thing name="thing"">
     <attribute name="name"/>
     <attribute name="extends"/>
     <thing name="attribute">
         <attribute name="name"/>
     </thing>
     <thing name="thing" extends="_root"/>
</thing>

Here we add an extends attribute, in <thing name="thing" extends="_root"/> child node, extends="_root" attribute indicates this node Inherit the root node, so that this child node also has child nodes under the root node, so logically it is an XML with infinite layers.

Because it is a structure of any XML structure, in an XML editor that uses the structure of XML to edit XML, it can be used to directly or indirectly edit any other XML, so it can As the first model in the system, the metamodel.