1.Major Classes of X-Meta Engines

2.2.1.Attribute

    The attributes of a thing are stored in the form of key-value, where the name of the attribute is a string and the value of the attribute can be any Java object.

//--------Related operations of attributes-----------
//Set attribute, where set and put methods work the same way
thing.set(String name, Object value);
thing.put(String name, Object value);

//get attribute
Object value = thing.get(String name)
//Getting attributes: A method with type conversion
String value =thing.getString(String name);
int value = thing.getInt(String name);
int value = thing.getInt(String name, int defualtValue);
double value = thing.getDouble(String name);
double value = thing.getDouble(String name, double defualtValue);
//Other similar approaches
xxxx value = thing.getXxx(String name);
xxxx value = thing.getXxx(String name, xxxx, defualtValue);

2.2.2.Child Thing

    Child thing is a child node of a thing, stored in a List.

//--------Relevant Operation of Subthings-----------
//Add child nodes
thing.addChild(Thing child);
thing.addChild(Thing child, int index);

//Get a list of all child nodes
List<Thing> childs = thing.getChilds();
//Get the corresponding list of child nodes according to the name of the object
List<Thing> childs = thing.getChilds(String thingName);

2.4.1.The thing name and name of thing

    The value of a thing's name attribute is its name, and the name of the descriptor of a thing is its thing name.

    In this case, the object name corresponds to the class name of the object. For example, the object A is the descriptor of the object B, and the object name of the object B is A.

2.4.2.Descriptive behavior

    In the dynamic model, the descriptor can describe the behavior. For example, if thing A is the descriptor of thing B, then part or all of the behavior of thing B can be known by thing A.

    The concrete realization method is that things inherit the behavior of their descriptors. For example, thing A is the descriptor of thing B. If thing A has an action named sayHello, then thing B also has an action named sayHello. Although thing B itself does not define an action named sayHello, sayHello behavior is inherited from thing A.

2.4.3.Describing attributes and sub-things

    In dynamic models, descriptors can describe attributes and sub-things. For example, if thing A is the descriptor of thing B, then part or all of the attributes and sub-things of thing B can be known by thing A.

2.4.4.Descriptor's limitations

    A thing can regard any thing as its descriptor, even its own, the number is unlimited, and the descriptor of a thing can be modified at any time.

    If there are multiple descriptors of a thing, their paths are separated by English commas in the descriptors attribute, and the order of inheritance of actions is the order in which the descriptors attribute appears.

2.5.1.Extend

    In the dynamic model, a thing can inherit other things besides itself, thus possessing the behavior of the inherited thing. For example, if thing B inherits thing A, then thing B has the behavior of thing A.

2.5.2.Representation of inheritance

    The inheritance relationship between things is expressed by attribute extends. If thing B inherits thing A, then the path of thing A is set in the attribute of thing B.

Thing a = new Thing();
Thing b = new Thing();

//Set things B to inherit things a, where "a" is the path of things a
b.put("extends", "a");

//Get an inheritance list of things defined by themselves
List<Thing> extendThings = b.getExtends();
//Get all inheritance lists of things, including inheritance of inherited things
List<Thing> extendThings = b.getAllExtends();

2.5.3.Inheritance between descriptors

    If a thing is a descriptor, then it plays the role of describing the structure (attributes and sub-things) and behavior of other things, and if it also inherits other things, it also inherits the structure and behavior described by the inherited things.

    For example, Person is a model, which inherits the Animal model, while Tom is an instance of Person. If the Animal defines an attribute named age, then Tom also has the attribute of age, where Person inherits the definition of the age attribute of Animal.   

2.5.4.Restrictions on inheritance

    A thing can inherit many things, the number is not limited, because inheriting oneself is meaningless, so one thing can not inherit oneself. If one thing inherits many things, then it is separated by English commas in the extends attribute, and the order of inheritance behavior is priority according to the order appearing in extends.

3.4.1Calling effect of functions and methods

    ActionContext and action can be used to achieve the effect of calling functions and methods, that is, when an action is executed, a Bindings can be pushed into a stack, then parameters and temporary variables can be stored in Bindings, and then the stack pops up when the action is completed.

3.4.2Implementation of Control Statement Model

    The control statement can be realized by status of ActionContext. The optional values of status are RUNNING, RETURN, CANCEL, BREAK, CONTINUE and EXCEPTION. Using status, the return, break, continue and exception throwing and handling in programming language can be realized by using the object model.

3.5.1Execute the behaviour of thing

    From the definition of things, we can know that a thing's behavior is a child of its node, or inherited from its descriptor and inheritor, in which the behavior of things is defined by things, so we can get the definition of things by things, and then execute it.

    The behavior of things is performed through the doAction method, such as:

//Execute the behaviour xxx
thing.doAction("xxx" , actionContext);

    The implementation core code of doAction:

Thing actionThing = getActionThing(name);
Action action = actionThing.getAction();

Bindings bindings = context.push(null);
bindings.caller = this;
bindings.put("self", this);
		
try{
	return action.run(context);
}finally{
	context.pop();
}

    Here you can see that in doAction, the object model is placed in the context of the variable with the name of the self variable, so when the action is executed, you can know who is calling it.

4.2.1ThingManager

    The Java interface corresponding to the ThingManager is org.xmeta.ThingManager. ThingManager is an interface that stores things in different media, such as file system, Jar and class path, database and memory. Each medium corresponds to its own ThingManager implementation.

    Since the Thing Manager is the first level grouping of things, the Thing Manager has an additional function that can be used as a project.

4.2.2Category

    The Java corresponding to the directory interface is org.xmeta.Category. The directory is the specific grouping under the Things Manager. For example, the file directory corresponding to the directory under the file system can put things in different file directories to distinguish.

4.3.1Path Rules of Things

    The path of things is <directory>+the name of things, such as xworker.lang.MetaThing, which is saved in the file system, xworker.lang is the relative directory xworker/lang, and the encoding type of MetaThing+is the file name, such as MetaThing.xer.txt or MetaThing.xml.

4.3.2Path Rules of Attributes and Subthings

    The sub-path rules are as follows:

/                :Separator for child things.
@xxx             ：Find sub-things with ID XXX
@?xxx            ：Find by comparing the ID or name attributes of the child.
@n               :N is a number, if no sub-things identified as the corresponding number are found, then look for the nth sub-things.
xxx@             ：Look for a list of sub-items named xxx, if no empty list is returned, not null.
xxx@n            :Find a child of the nth thing named xxx, and return it first if it is identified as n.     
#xxx             :Find an attribute named XXX。
$n                :The same @n is used to distinguish @xx, $n is only used to find the nth child.

4.3.3Examples of paths

World world = World.getInstance();

//Get things
Thing thing = world.getThing("xworker.lang.MetaThing");

//Getting Subthings Directly
Thing child = world.getThing("xworker.lang.MetaThing/@thing");

//get attribute
Object value = thing.get("#name");

//Get the first child named thing
Thing child = thing.getThing("thing@0");