Types
All types inherited directly from "type" are data types. Others
are for informational purposes and not used in coding tags.
Entity class tree
- root_type: -"-
- string: Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- uri: C equivalent roughly: for storing id name: char *, as pointer: void *
URI is Uniform Resource Locator.
For more about URI see
http://www.ics.uci.edu/pub/ietf/uri/
- id: C equivalent roughly: for storing id name: char *, as pointer: void *
- element_type: -"-
- interface: -"-
- loc: -"-
- refid: -"-
- from: -"-
- to: When client sends operation to it's character
in server, then you can omit this because server can assume
character can only control directly it's body.
- root_object: This usually has value "root", but can also have something like: "world45/root"
or even "atlas://other.server.org/world5/root"
- filename: -"-
- e_uri: -"-
- objtype: Examples of values: "op", "class", "type".
- specification: -"-
- name: -"-
- message: -"-
- say: -"-
- text: Text of objects like signs, posters, books, chess board letters, etc..: these are meant to be displayed as text in screen
- html: -"-
- password: -"-
- time_string: There can be variation in length of different fields if using some weird calendar
- e_string: -"-
- int: C equivalent: 32bit int
- float: C equivalent roughly: double
- stamp: Value should be reflect when something was
changed in this object. Any scheme is ok as long as newer numbers
are bigger than older stamps. For example, seconds since Jan 1st,
1970 or total game cycles would both be valid.
- stamp_inherit: Value should be reflect when something was changed in some object that inherits from this.
- stamp_contains: Value should be reflect when something was changed in some object that is contained by this object.
- seconds: -"-
- e_float: -"-
- list: C equivalent: void *[]
- map: C equivalent: struct map {char *;void *}; map*
root_type
Attribute list:
- children (encoding:list): Value: ['string', 'int', 'float', 'list', 'map'] C equivalent: char *[], void *[]
- description (inherited from root) (encoding:string): Value:
You can browse all definitions starting from here and
descending into childrens.
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- id (encoding:string): Value: root_type C equivalent roughly: for storing id name: char *, as pointer: void *
- interface (inherited from root) (encoding:string): Value: base_interface C equivalent roughly: for storing id name: char *, as pointer: void *
- name (inherited from root) (encoding:string): Value: Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- objtype (encoding:string): Value: meta Examples of values: "op", "class", "type".
- parents (encoding:list): Value: ['root'] C equivalent: char *[], void *[]
- specification (inherited from root) (encoding:string): Value: atlas Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- stamp (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was
changed in this object. Any scheme is ok as long as newer numbers
are bigger than older stamps. For example, seconds since Jan 1st,
1970 or total game cycles would both be valid.
- stamp_inherit (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was changed in some object that inherits from this.
- summary (encoding:string): Value:
Type hierarchy starts from here.
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Bach version:
{
children: ["string", "int", "float", "list", "map"],
id: "root_type",
objtype: "meta",
parents: ["root"],
summary: "Type hierarchy starts from here."
}
string
Attribute list:
- children (encoding:list): Value: ['uri', 'objtype', 'specification', 'name', 'message', 'html', 'password', 'time_string', 'e_string'] C equivalent: char *[], void *[]
- description (encoding:string): Value:
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- id (encoding:string): Value: string C equivalent roughly: for storing id name: char *, as pointer: void *
- interface (inherited from root) (encoding:string): Value: base_interface C equivalent roughly: for storing id name: char *, as pointer: void *
- name (inherited from root) (encoding:string): Value: Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- objtype (encoding:string): Value: data_type Examples of values: "op", "class", "type".
- parents (encoding:list): Value: ['root_type'] C equivalent: char *[], void *[]
- specification (inherited from root) (encoding:string): Value: atlas Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- stamp (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was
changed in this object. Any scheme is ok as long as newer numbers
are bigger than older stamps. For example, seconds since Jan 1st,
1970 or total game cycles would both be valid.
- stamp_inherit (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was changed in some object that inherits from this.
- summary (encoding:string): Value:
UTF-8 encoded string.
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Bach version:
{
children: ["uri", "objtype", "specification", "name", "message", "html", "password", "time_string", "e_string"],
description: "Any character is allowed, including 8 bit control characters and '\\0', C equivalent: {int len; char *data;}, C++: string",
id: "string",
objtype: "data_type",
parents: ["root_type"],
summary: "UTF-8 encoded string."
}
uri
Attribute list:
- children (encoding:list): Value: ['id', 'filename', 'e_uri'] C equivalent: char *[], void *[]
- description (encoding:string): Value:
C equivalent roughly: for storing id name: char *, as pointer: void *
URI is Uniform Resource Locator.
For more about URI see
http://www.ics.uci.edu/pub/ietf/uri/
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- id (encoding:string): Value: uri C equivalent roughly: for storing id name: char *, as pointer: void *
- interface (inherited from root) (encoding:string): Value: base_interface C equivalent roughly: for storing id name: char *, as pointer: void *
- name (inherited from root) (encoding:string): Value: Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- objtype (encoding:string): Value: type Examples of values: "op", "class", "type".
- parents (encoding:list): Value: ['string'] C equivalent: char *[], void *[]
- specification (inherited from root) (encoding:string): Value: atlas Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- stamp (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was
changed in this object. Any scheme is ok as long as newer numbers
are bigger than older stamps. For example, seconds since Jan 1st,
1970 or total game cycles would both be valid.
- stamp_inherit (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was changed in some object that inherits from this.
- summary (encoding:string): Value:
URI (URL) of object
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Bach version:
{
children: ["id", "filename", "e_uri"],
description: "C equivalent roughly: for storing id name: char *, as pointer: void *<br>
URI is Uniform Resource Locator.
For more about URI see
<a href=\"http://www.ics.uci.edu/pub/ietf/uri/\">http://www.ics.uci.edu/pub/ietf/uri/</a>",
id: "uri",
objtype: "type",
parents: ["string"],
summary: "URI (URL) of object"
}
id
Attribute list:
- children (encoding:list): Value: ['element_type', 'interface', 'loc', 'refid', 'from', 'to', 'root_object'] C equivalent: char *[], void *[]
- description (encoding:string): Value:
C equivalent roughly: for storing id name: char *, as pointer: void *
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- id (encoding:string): Value: id C equivalent roughly: for storing id name: char *, as pointer: void *
- interface (inherited from root) (encoding:string): Value: base_interface C equivalent roughly: for storing id name: char *, as pointer: void *
- name (inherited from root) (encoding:string): Value: Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- objtype (inherited from uri) (encoding:string): Value: type Examples of values: "op", "class", "type".
- parents (encoding:list): Value: ['uri'] C equivalent: char *[], void *[]
- specification (inherited from root) (encoding:string): Value: atlas Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- stamp (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was
changed in this object. Any scheme is ok as long as newer numbers
are bigger than older stamps. For example, seconds since Jan 1st,
1970 or total game cycles would both be valid.
- stamp_inherit (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was changed in some object that inherits from this.
- summary (encoding:string): Value:
Id of object
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Bach version:
{
children: ["element_type", "interface", "loc", "refid", "from", "to", "root_object"],
description: "C equivalent roughly: for storing id name: char *, as pointer: void *",
id: "id",
parents: ["uri"],
summary: "Id of object"
}
element_type
Attribute list:
- children (encoding:list): Value: [] C equivalent: char *[], void *[]
- description (inherited from id) (encoding:string): Value:
C equivalent roughly: for storing id name: char *, as pointer: void *
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- id (encoding:string): Value: element_type C equivalent roughly: for storing id name: char *, as pointer: void *
- interface (inherited from root) (encoding:string): Value: base_interface C equivalent roughly: for storing id name: char *, as pointer: void *
- name (inherited from root) (encoding:string): Value: Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- objtype (inherited from uri) (encoding:string): Value: type Examples of values: "op", "class", "type".
- parents (encoding:list): Value: ['id'] C equivalent: char *[], void *[]
- specification (inherited from root) (encoding:string): Value: atlas Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- stamp (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was
changed in this object. Any scheme is ok as long as newer numbers
are bigger than older stamps. For example, seconds since Jan 1st,
1970 or total game cycles would both be valid.
- stamp_inherit (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was changed in some object that inherits from this.
- summary (encoding:string): Value:
Element type for typed lists/mappings
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Bach version:
{
children: [],
id: "element_type",
parents: ["id"],
summary: "Element type for typed lists/mappings"
}
interface
Attribute list:
- children (encoding:list): Value: [] C equivalent: char *[], void *[]
- description (inherited from id) (encoding:string): Value:
C equivalent roughly: for storing id name: char *, as pointer: void *
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- id (encoding:string): Value: interface C equivalent roughly: for storing id name: char *, as pointer: void *
- interface (inherited from root) (encoding:string): Value: base_interface C equivalent roughly: for storing id name: char *, as pointer: void *
- name (inherited from root) (encoding:string): Value: Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- objtype (inherited from uri) (encoding:string): Value: type Examples of values: "op", "class", "type".
- parents (encoding:list): Value: ['id'] C equivalent: char *[], void *[]
- specification (inherited from root) (encoding:string): Value: atlas Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- stamp (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was
changed in this object. Any scheme is ok as long as newer numbers
are bigger than older stamps. For example, seconds since Jan 1st,
1970 or total game cycles would both be valid.
- stamp_inherit (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was changed in some object that inherits from this.
- summary (encoding:string): Value:
What kind of operations are legal for this object.
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Bach version:
{
children: [],
id: "interface",
parents: ["id"],
summary: "What kind of operations are legal for this object."
}
loc
Attribute list:
- children (encoding:list): Value: [] C equivalent: char *[], void *[]
- description (inherited from id) (encoding:string): Value:
C equivalent roughly: for storing id name: char *, as pointer: void *
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- id (encoding:string): Value: loc C equivalent roughly: for storing id name: char *, as pointer: void *
- interface (inherited from root) (encoding:string): Value: base_interface C equivalent roughly: for storing id name: char *, as pointer: void *
- name (encoding:string): Value: location Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- objtype (encoding:string): Value: type Examples of values: "op", "class", "type".
- parents (encoding:list): Value: ['id'] C equivalent: char *[], void *[]
- specification (inherited from root) (encoding:string): Value: atlas Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- stamp (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was
changed in this object. Any scheme is ok as long as newer numbers
are bigger than older stamps. For example, seconds since Jan 1st,
1970 or total game cycles would both be valid.
- stamp_inherit (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was changed in some object that inherits from this.
- summary (encoding:string): Value:
Reference object for coordinates (location).
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Bach version:
{
children: [],
id: "loc",
name: "location",
objtype: "type",
parents: ["id"],
summary: "Reference object for coordinates (location)."
}
refid
Attribute list:
- children (encoding:list): Value: [] C equivalent: char *[], void *[]
- description (inherited from id) (encoding:string): Value:
C equivalent roughly: for storing id name: char *, as pointer: void *
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- id (encoding:string): Value: refid C equivalent roughly: for storing id name: char *, as pointer: void *
- interface (inherited from root) (encoding:string): Value: base_interface C equivalent roughly: for storing id name: char *, as pointer: void *
- name (inherited from root) (encoding:string): Value: Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- objtype (inherited from uri) (encoding:string): Value: type Examples of values: "op", "class", "type".
- parents (encoding:list): Value: ['id'] C equivalent: char *[], void *[]
- specification (inherited from root) (encoding:string): Value: atlas Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- stamp (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was
changed in this object. Any scheme is ok as long as newer numbers
are bigger than older stamps. For example, seconds since Jan 1st,
1970 or total game cycles would both be valid.
- stamp_inherit (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was changed in some object that inherits from this.
- summary (encoding:string): Value:
Reference to id
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Bach version:
{
children: [],
id: "refid",
parents: ["id"],
summary: "Reference to id"
}
from
Attribute list:
- children (encoding:list): Value: [] C equivalent: char *[], void *[]
- description (inherited from id) (encoding:string): Value:
C equivalent roughly: for storing id name: char *, as pointer: void *
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- id (encoding:string): Value: from C equivalent roughly: for storing id name: char *, as pointer: void *
- interface (inherited from root) (encoding:string): Value: base_interface C equivalent roughly: for storing id name: char *, as pointer: void *
- name (inherited from root) (encoding:string): Value: Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- objtype (inherited from uri) (encoding:string): Value: type Examples of values: "op", "class", "type".
- parents (encoding:list): Value: ['id'] C equivalent: char *[], void *[]
- specification (inherited from root) (encoding:string): Value: atlas Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- stamp (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was
changed in this object. Any scheme is ok as long as newer numbers
are bigger than older stamps. For example, seconds since Jan 1st,
1970 or total game cycles would both be valid.
- stamp_inherit (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was changed in some object that inherits from this.
- summary (encoding:string): Value:
Source of message/operation.
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Bach version:
{
children: [],
id: "from",
parents: ["id"],
summary: "Source of message/operation."
}
to
Attribute list:
- children (encoding:list): Value: [] C equivalent: char *[], void *[]
- description (encoding:string): Value:
When client sends operation to it's character
in server, then you can omit this because server can assume
character can only control directly it's body.
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- id (encoding:string): Value: to C equivalent roughly: for storing id name: char *, as pointer: void *
- interface (inherited from root) (encoding:string): Value: base_interface C equivalent roughly: for storing id name: char *, as pointer: void *
- name (inherited from root) (encoding:string): Value: Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- objtype (inherited from uri) (encoding:string): Value: type Examples of values: "op", "class", "type".
- parents (encoding:list): Value: ['id'] C equivalent: char *[], void *[]
- specification (inherited from root) (encoding:string): Value: atlas Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- stamp (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was
changed in this object. Any scheme is ok as long as newer numbers
are bigger than older stamps. For example, seconds since Jan 1st,
1970 or total game cycles would both be valid.
- stamp_inherit (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was changed in some object that inherits from this.
- summary (encoding:string): Value:
Target of message/operation.
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Bach version:
{
children: [],
description: "When client sends operation to it's character
in server, then you can omit this because server can assume
character can only control directly it's body.",
id: "to",
parents: ["id"],
summary: "Target of message/operation."
}
root_object
Attribute list:
- children (encoding:list): Value: [] C equivalent: char *[], void *[]
- description (encoding:string): Value:
This usually has value "root", but can also have something like: "world45/root"
or even "atlas://other.server.org/world5/root"
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- id (encoding:string): Value: root_object C equivalent roughly: for storing id name: char *, as pointer: void *
- interface (inherited from root) (encoding:string): Value: base_interface C equivalent roughly: for storing id name: char *, as pointer: void *
- name (inherited from root) (encoding:string): Value: Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- objtype (inherited from uri) (encoding:string): Value: type Examples of values: "op", "class", "type".
- parents (encoding:list): Value: ['id'] C equivalent: char *[], void *[]
- specification (inherited from root) (encoding:string): Value: atlas Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- stamp (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was
changed in this object. Any scheme is ok as long as newer numbers
are bigger than older stamps. For example, seconds since Jan 1st,
1970 or total game cycles would both be valid.
- stamp_inherit (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was changed in some object that inherits from this.
- summary (encoding:string): Value:
Id of root object
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Bach version:
{
children: [],
description: "This usually has value \"root\", but can also have something like: \"world45/root\"
or even \"atlas://other.server.org/world5/root\"",
id: "root_object",
parents: ["id"],
summary: "Id of root object"
}
filename
Attribute list:
- children (encoding:list): Value: [] C equivalent: char *[], void *[]
- description (inherited from uri) (encoding:string): Value:
C equivalent roughly: for storing id name: char *, as pointer: void *
URI is Uniform Resource Locator.
For more about URI see
http://www.ics.uci.edu/pub/ietf/uri/
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- id (encoding:string): Value: filename C equivalent roughly: for storing id name: char *, as pointer: void *
- interface (inherited from root) (encoding:string): Value: base_interface C equivalent roughly: for storing id name: char *, as pointer: void *
- name (inherited from root) (encoding:string): Value: Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- objtype (inherited from uri) (encoding:string): Value: type Examples of values: "op", "class", "type".
- parents (encoding:list): Value: ['uri'] C equivalent: char *[], void *[]
- specification (inherited from root) (encoding:string): Value: atlas Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- stamp (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was
changed in this object. Any scheme is ok as long as newer numbers
are bigger than older stamps. For example, seconds since Jan 1st,
1970 or total game cycles would both be valid.
- stamp_inherit (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was changed in some object that inherits from this.
- summary (encoding:string): Value:
name of file (example: where object was specified)
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Bach version:
{
children: [],
id: "filename",
parents: ["uri"],
summary: "name of file (example: where object was specified)"
}
e_uri
Attribute list:
- children (encoding:list): Value: [] C equivalent: char *[], void *[]
- description (inherited from uri) (encoding:string): Value:
C equivalent roughly: for storing id name: char *, as pointer: void *
URI is Uniform Resource Locator.
For more about URI see
http://www.ics.uci.edu/pub/ietf/uri/
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- id (encoding:string): Value: e_uri C equivalent roughly: for storing id name: char *, as pointer: void *
- interface (inherited from root) (encoding:string): Value: base_interface C equivalent roughly: for storing id name: char *, as pointer: void *
- name (inherited from root) (encoding:string): Value: Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- objtype (inherited from uri) (encoding:string): Value: type Examples of values: "op", "class", "type".
- parents (encoding:list): Value: ['uri'] C equivalent: char *[], void *[]
- specification (inherited from root) (encoding:string): Value: atlas Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- stamp (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was
changed in this object. Any scheme is ok as long as newer numbers
are bigger than older stamps. For example, seconds since Jan 1st,
1970 or total game cycles would both be valid.
- stamp_inherit (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was changed in some object that inherits from this.
- summary (encoding:string): Value:
Root type for all uri type example attributes
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Bach version:
{
children: [],
id: "e_uri",
parents: ["uri"],
summary: "Root type for all uri type example attributes"
}
objtype
Attribute list:
- children (encoding:list): Value: [] C equivalent: char *[], void *[]
- description (encoding:string): Value:
Examples of values: "op", "class", "type".
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- id (encoding:string): Value: objtype C equivalent roughly: for storing id name: char *, as pointer: void *
- interface (inherited from root) (encoding:string): Value: base_interface C equivalent roughly: for storing id name: char *, as pointer: void *
- name (encoding:string): Value: object type Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- objtype (encoding:string): Value: type Examples of values: "op", "class", "type".
- parents (encoding:list): Value: ['string'] C equivalent: char *[], void *[]
- specification (inherited from root) (encoding:string): Value: atlas Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- stamp (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was
changed in this object. Any scheme is ok as long as newer numbers
are bigger than older stamps. For example, seconds since Jan 1st,
1970 or total game cycles would both be valid.
- stamp_inherit (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was changed in some object that inherits from this.
- summary (encoding:string): Value:
What kind of object this is.
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Bach version:
{
children: [],
description: "Examples of values: \"op\", \"class\", \"type\".",
id: "objtype",
name: "object type",
objtype: "type",
parents: ["string"],
summary: "What kind of object this is."
}
specification
Attribute list:
- children (encoding:list): Value: [] C equivalent: char *[], void *[]
- description (inherited from string) (encoding:string): Value:
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- id (encoding:string): Value: specification C equivalent roughly: for storing id name: char *, as pointer: void *
- interface (inherited from root) (encoding:string): Value: base_interface C equivalent roughly: for storing id name: char *, as pointer: void *
- name (inherited from root) (encoding:string): Value: Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- objtype (encoding:string): Value: type Examples of values: "op", "class", "type".
- parents (encoding:list): Value: ['string'] C equivalent: char *[], void *[]
- specification (inherited from root) (encoding:string): Value: atlas Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- stamp (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was
changed in this object. Any scheme is ok as long as newer numbers
are bigger than older stamps. For example, seconds since Jan 1st,
1970 or total game cycles would both be valid.
- stamp_inherit (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was changed in some object that inherits from this.
- summary (encoding:string): Value:
What specification this object is part of?
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Bach version:
{
children: [],
id: "specification",
objtype: "type",
parents: ["string"],
summary: "What specification this object is part of?"
}
name
Attribute list:
- children (encoding:list): Value: [] C equivalent: char *[], void *[]
- description (inherited from string) (encoding:string): Value:
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- id (encoding:string): Value: name C equivalent roughly: for storing id name: char *, as pointer: void *
- interface (inherited from root) (encoding:string): Value: base_interface C equivalent roughly: for storing id name: char *, as pointer: void *
- name (inherited from root) (encoding:string): Value: Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- objtype (encoding:string): Value: type Examples of values: "op", "class", "type".
- parents (encoding:list): Value: ['string'] C equivalent: char *[], void *[]
- specification (inherited from root) (encoding:string): Value: atlas Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- stamp (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was
changed in this object. Any scheme is ok as long as newer numbers
are bigger than older stamps. For example, seconds since Jan 1st,
1970 or total game cycles would both be valid.
- stamp_inherit (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was changed in some object that inherits from this.
- summary (encoding:string): Value:
Name of object.
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Bach version:
{
children: [],
id: "name",
objtype: "type",
parents: ["string"],
summary: "Name of object."
}
message
Attribute list:
- children (encoding:list): Value: ['say', 'text'] C equivalent: char *[], void *[]
- description (inherited from string) (encoding:string): Value:
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- id (encoding:string): Value: message C equivalent roughly: for storing id name: char *, as pointer: void *
- interface (inherited from root) (encoding:string): Value: base_interface C equivalent roughly: for storing id name: char *, as pointer: void *
- name (inherited from root) (encoding:string): Value: Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- objtype (encoding:string): Value: type Examples of values: "op", "class", "type".
- parents (encoding:list): Value: ['string'] C equivalent: char *[], void *[]
- specification (inherited from root) (encoding:string): Value: atlas Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- stamp (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was
changed in this object. Any scheme is ok as long as newer numbers
are bigger than older stamps. For example, seconds since Jan 1st,
1970 or total game cycles would both be valid.
- stamp_inherit (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was changed in some object that inherits from this.
- summary (encoding:string): Value:
Some message (for example error message)
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Bach version:
{
children: ["say", "text"],
id: "message",
objtype: "type",
parents: ["string"],
summary: "Some message (for example error message)"
}
say
Attribute list:
- children (encoding:list): Value: [] C equivalent: char *[], void *[]
- description (inherited from string) (encoding:string): Value:
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- id (encoding:string): Value: say C equivalent roughly: for storing id name: char *, as pointer: void *
- interface (inherited from root) (encoding:string): Value: base_interface C equivalent roughly: for storing id name: char *, as pointer: void *
- name (inherited from root) (encoding:string): Value: Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- objtype (inherited from message) (encoding:string): Value: type Examples of values: "op", "class", "type".
- parents (encoding:list): Value: ['message'] C equivalent: char *[], void *[]
- specification (inherited from root) (encoding:string): Value: atlas Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- stamp (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was
changed in this object. Any scheme is ok as long as newer numbers
are bigger than older stamps. For example, seconds since Jan 1st,
1970 or total game cycles would both be valid.
- stamp_inherit (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was changed in some object that inherits from this.
- summary (encoding:string): Value:
What something has said.
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Bach version:
{
children: [],
id: "say",
parents: ["message"],
summary: "What something has said."
}
text
Attribute list:
- children (encoding:list): Value: [] C equivalent: char *[], void *[]
- description (encoding:string): Value:
Text of objects like signs, posters, books, chess board letters, etc..: these are meant to be displayed as text in screen
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- id (encoding:string): Value: text C equivalent roughly: for storing id name: char *, as pointer: void *
- interface (inherited from root) (encoding:string): Value: base_interface C equivalent roughly: for storing id name: char *, as pointer: void *
- name (inherited from root) (encoding:string): Value: Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- objtype (inherited from message) (encoding:string): Value: type Examples of values: "op", "class", "type".
- parents (encoding:list): Value: ['message'] C equivalent: char *[], void *[]
- specification (inherited from root) (encoding:string): Value: atlas Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- stamp (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was
changed in this object. Any scheme is ok as long as newer numbers
are bigger than older stamps. For example, seconds since Jan 1st,
1970 or total game cycles would both be valid.
- stamp_inherit (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was changed in some object that inherits from this.
- summary (encoding:string): Value:
Text of textual object
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Bach version:
{
children: [],
description: "Text of objects like signs, posters, books, chess board letters, etc..: these are meant to be displayed as text in screen",
id: "text",
parents: ["message"],
summary: "Text of textual object"
}
html
Attribute list:
- children (encoding:list): Value: ['summary'] C equivalent: char *[], void *[]
- description (inherited from string) (encoding:string): Value:
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- id (encoding:string): Value: html C equivalent roughly: for storing id name: char *, as pointer: void *
- interface (inherited from root) (encoding:string): Value: base_interface C equivalent roughly: for storing id name: char *, as pointer: void *
- name (inherited from root) (encoding:string): Value: Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- objtype (encoding:string): Value: type Examples of values: "op", "class", "type".
- parents (encoding:list): Value: ['string'] C equivalent: char *[], void *[]
- specification (inherited from root) (encoding:string): Value: atlas Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- stamp (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was
changed in this object. Any scheme is ok as long as newer numbers
are bigger than older stamps. For example, seconds since Jan 1st,
1970 or total game cycles would both be valid.
- stamp_inherit (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was changed in some object that inherits from this.
- summary (encoding:string): Value:
String that is actually html.
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Bach version:
{
children: ["summary"],
id: "html",
objtype: "type",
parents: ["string"],
summary: "String that is actually html."
}
summary
Attribute list:
- children (encoding:list): Value: ['description'] C equivalent: char *[], void *[]
- description (inherited from string) (encoding:string): Value:
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- id (encoding:string): Value: summary C equivalent roughly: for storing id name: char *, as pointer: void *
- interface (inherited from root) (encoding:string): Value: base_interface C equivalent roughly: for storing id name: char *, as pointer: void *
- name (inherited from root) (encoding:string): Value: Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- objtype (inherited from html) (encoding:string): Value: type Examples of values: "op", "class", "type".
- parents (encoding:list): Value: ['html'] C equivalent: char *[], void *[]
- specification (inherited from root) (encoding:string): Value: atlas Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- stamp (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was
changed in this object. Any scheme is ok as long as newer numbers
are bigger than older stamps. For example, seconds since Jan 1st,
1970 or total game cycles would both be valid.
- stamp_inherit (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was changed in some object that inherits from this.
- summary (encoding:string): Value:
This gives short description of object, usually about 1 line.
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Bach version:
{
children: ["description"],
id: "summary",
parents: ["html"],
summary: "This gives short description of object, usually about 1 line."
}
description
Attribute list:
- children (encoding:list): Value: ['arg_description'] C equivalent: char *[], void *[]
- description (inherited from string) (encoding:string): Value:
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- id (encoding:string): Value: description C equivalent roughly: for storing id name: char *, as pointer: void *
- interface (inherited from root) (encoding:string): Value: base_interface C equivalent roughly: for storing id name: char *, as pointer: void *
- name (inherited from root) (encoding:string): Value: Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- objtype (inherited from html) (encoding:string): Value: type Examples of values: "op", "class", "type".
- parents (encoding:list): Value: ['summary'] C equivalent: char *[], void *[]
- specification (inherited from root) (encoding:string): Value: atlas Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- stamp (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was
changed in this object. Any scheme is ok as long as newer numbers
are bigger than older stamps. For example, seconds since Jan 1st,
1970 or total game cycles would both be valid.
- stamp_inherit (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was changed in some object that inherits from this.
- summary (encoding:string): Value:
This gives long description of object: few lines to few pages
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Bach version:
{
children: ["arg_description"],
id: "description",
parents: ["summary"],
summary: "This gives long description of object: few lines to few pages"
}
arg_description
Attribute list:
- children (encoding:list): Value: [] C equivalent: char *[], void *[]
- description (inherited from string) (encoding:string): Value:
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- id (encoding:string): Value: arg_description C equivalent roughly: for storing id name: char *, as pointer: void *
- interface (inherited from root) (encoding:string): Value: base_interface C equivalent roughly: for storing id name: char *, as pointer: void *
- name (inherited from root) (encoding:string): Value: Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- objtype (inherited from html) (encoding:string): Value: type Examples of values: "op", "class", "type".
- parents (encoding:list): Value: ['description'] C equivalent: char *[], void *[]
- specification (inherited from root) (encoding:string): Value: atlas Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- stamp (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was
changed in this object. Any scheme is ok as long as newer numbers
are bigger than older stamps. For example, seconds since Jan 1st,
1970 or total game cycles would both be valid.
- stamp_inherit (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was changed in some object that inherits from this.
- summary (encoding:string): Value:
This gives description about arguments.
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Bach version:
{
children: [],
id: "arg_description",
parents: ["description"],
summary: "This gives description about arguments."
}
password
Attribute list:
- children (encoding:list): Value: [] C equivalent: char *[], void *[]
- description (inherited from string) (encoding:string): Value:
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- id (encoding:string): Value: password C equivalent roughly: for storing id name: char *, as pointer: void *
- interface (inherited from root) (encoding:string): Value: base_interface C equivalent roughly: for storing id name: char *, as pointer: void *
- name (inherited from root) (encoding:string): Value: Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- objtype (encoding:string): Value: type Examples of values: "op", "class", "type".
- parents (encoding:list): Value: ['string'] C equivalent: char *[], void *[]
- specification (inherited from root) (encoding:string): Value: atlas Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- stamp (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was
changed in this object. Any scheme is ok as long as newer numbers
are bigger than older stamps. For example, seconds since Jan 1st,
1970 or total game cycles would both be valid.
- stamp_inherit (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was changed in some object that inherits from this.
- summary (encoding:string): Value:
Password for account usually
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Bach version:
{
children: [],
id: "password",
objtype: "type",
parents: ["string"],
summary: "Password for account usually"
}
time_string
Attribute list:
- children (encoding:list): Value: [] C equivalent: char *[], void *[]
- description (encoding:string): Value:
There can be variation in length of different fields if using some weird calendar
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- id (encoding:string): Value: time_string C equivalent roughly: for storing id name: char *, as pointer: void *
- interface (inherited from root) (encoding:string): Value: base_interface C equivalent roughly: for storing id name: char *, as pointer: void *
- name (inherited from root) (encoding:string): Value: Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- objtype (encoding:string): Value: type Examples of values: "op", "class", "type".
- parents (encoding:list): Value: ['string'] C equivalent: char *[], void *[]
- specification (inherited from root) (encoding:string): Value: atlas Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- stamp (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was
changed in this object. Any scheme is ok as long as newer numbers
are bigger than older stamps. For example, seconds since Jan 1st,
1970 or total game cycles would both be valid.
- stamp_inherit (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was changed in some object that inherits from this.
- summary (encoding:string): Value:
Time in string format: YYYY-MM-DD HH:MM:SS.ss
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Bach version:
{
children: [],
description: "There can be variation in length of different fields if using some weird calendar",
id: "time_string",
objtype: "type",
parents: ["string"],
summary: "Time in string format: YYYY-MM-DD HH:MM:SS.ss"
}
e_string
Attribute list:
- children (encoding:list): Value: ['e_msg', 'e_smell', 'e_surface_type', 'e_bar', 'e_sex'] C equivalent: char *[], void *[]
- description (inherited from string) (encoding:string): Value:
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- id (encoding:string): Value: e_string C equivalent roughly: for storing id name: char *, as pointer: void *
- interface (inherited from root) (encoding:string): Value: base_interface C equivalent roughly: for storing id name: char *, as pointer: void *
- name (inherited from root) (encoding:string): Value: Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- objtype (encoding:string): Value: type Examples of values: "op", "class", "type".
- parents (encoding:list): Value: ['string'] C equivalent: char *[], void *[]
- specification (inherited from root) (encoding:string): Value: atlas Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- stamp (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was
changed in this object. Any scheme is ok as long as newer numbers
are bigger than older stamps. For example, seconds since Jan 1st,
1970 or total game cycles would both be valid.
- stamp_inherit (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was changed in some object that inherits from this.
- summary (encoding:string): Value:
Root type for all string type example attributes
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Bach version:
{
children: ["e_msg", "e_smell", "e_surface_type", "e_bar", "e_sex"],
id: "e_string",
objtype: "type",
parents: ["string"],
summary: "Root type for all string type example attributes"
}
e_msg
Attribute list:
- children (encoding:list): Value: [] C equivalent: char *[], void *[]
- description (inherited from string) (encoding:string): Value:
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- id (encoding:string): Value: e_msg C equivalent roughly: for storing id name: char *, as pointer: void *
- interface (inherited from root) (encoding:string): Value: base_interface C equivalent roughly: for storing id name: char *, as pointer: void *
- name (inherited from root) (encoding:string): Value: Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- objtype (inherited from e_string) (encoding:string): Value: type Examples of values: "op", "class", "type".
- parents (encoding:list): Value: ['e_string'] C equivalent: char *[], void *[]
- specification (inherited from root) (encoding:string): Value: atlas Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- stamp (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was
changed in this object. Any scheme is ok as long as newer numbers
are bigger than older stamps. For example, seconds since Jan 1st,
1970 or total game cycles would both be valid.
- stamp_inherit (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was changed in some object that inherits from this.
- summary (inherited from e_string) (encoding:string): Value:
Root type for all string type example attributes
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Bach version:
{
children: [],
id: "e_msg",
parents: ["e_string"]
}
e_smell
Attribute list:
- children (encoding:list): Value: [] C equivalent: char *[], void *[]
- description (inherited from string) (encoding:string): Value:
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- id (encoding:string): Value: e_smell C equivalent roughly: for storing id name: char *, as pointer: void *
- interface (inherited from root) (encoding:string): Value: base_interface C equivalent roughly: for storing id name: char *, as pointer: void *
- name (inherited from root) (encoding:string): Value: Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- objtype (inherited from e_string) (encoding:string): Value: type Examples of values: "op", "class", "type".
- parents (encoding:list): Value: ['e_string'] C equivalent: char *[], void *[]
- specification (inherited from root) (encoding:string): Value: atlas Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- stamp (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was
changed in this object. Any scheme is ok as long as newer numbers
are bigger than older stamps. For example, seconds since Jan 1st,
1970 or total game cycles would both be valid.
- stamp_inherit (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was changed in some object that inherits from this.
- summary (inherited from e_string) (encoding:string): Value:
Root type for all string type example attributes
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Bach version:
{
children: [],
id: "e_smell",
parents: ["e_string"]
}
e_surface_type
Attribute list:
- children (encoding:list): Value: [] C equivalent: char *[], void *[]
- description (inherited from string) (encoding:string): Value:
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- id (encoding:string): Value: e_surface_type C equivalent roughly: for storing id name: char *, as pointer: void *
- interface (inherited from root) (encoding:string): Value: base_interface C equivalent roughly: for storing id name: char *, as pointer: void *
- name (inherited from root) (encoding:string): Value: Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- objtype (inherited from e_string) (encoding:string): Value: type Examples of values: "op", "class", "type".
- parents (encoding:list): Value: ['e_string'] C equivalent: char *[], void *[]
- specification (inherited from root) (encoding:string): Value: atlas Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- stamp (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was
changed in this object. Any scheme is ok as long as newer numbers
are bigger than older stamps. For example, seconds since Jan 1st,
1970 or total game cycles would both be valid.
- stamp_inherit (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was changed in some object that inherits from this.
- summary (inherited from e_string) (encoding:string): Value:
Root type for all string type example attributes
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Bach version:
{
children: [],
id: "e_surface_type",
parents: ["e_string"]
}
e_bar
Attribute list:
- children (encoding:list): Value: [] C equivalent: char *[], void *[]
- description (inherited from string) (encoding:string): Value:
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- id (encoding:string): Value: e_bar C equivalent roughly: for storing id name: char *, as pointer: void *
- interface (inherited from root) (encoding:string): Value: base_interface C equivalent roughly: for storing id name: char *, as pointer: void *
- name (inherited from root) (encoding:string): Value: Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- objtype (inherited from e_string) (encoding:string): Value: type Examples of values: "op", "class", "type".
- parents (encoding:list): Value: ['e_string'] C equivalent: char *[], void *[]
- specification (inherited from root) (encoding:string): Value: atlas Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- stamp (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was
changed in this object. Any scheme is ok as long as newer numbers
are bigger than older stamps. For example, seconds since Jan 1st,
1970 or total game cycles would both be valid.
- stamp_inherit (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was changed in some object that inherits from this.
- summary (inherited from e_string) (encoding:string): Value:
Root type for all string type example attributes
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Bach version:
{
children: [],
id: "e_bar",
parents: ["e_string"]
}
e_sex
Attribute list:
- children (encoding:list): Value: [] C equivalent: char *[], void *[]
- description (inherited from string) (encoding:string): Value:
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- id (encoding:string): Value: e_sex C equivalent roughly: for storing id name: char *, as pointer: void *
- interface (inherited from root) (encoding:string): Value: base_interface C equivalent roughly: for storing id name: char *, as pointer: void *
- name (inherited from root) (encoding:string): Value: Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- objtype (inherited from e_string) (encoding:string): Value: type Examples of values: "op", "class", "type".
- parents (encoding:list): Value: ['e_string'] C equivalent: char *[], void *[]
- specification (inherited from root) (encoding:string): Value: atlas Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- stamp (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was
changed in this object. Any scheme is ok as long as newer numbers
are bigger than older stamps. For example, seconds since Jan 1st,
1970 or total game cycles would both be valid.
- stamp_inherit (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was changed in some object that inherits from this.
- summary (inherited from e_string) (encoding:string): Value:
Root type for all string type example attributes
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Bach version:
{
children: [],
id: "e_sex",
parents: ["e_string"]
}
int
Attribute list:
- children (encoding:list): Value: ['bool', 'list_length', 'serialno', 'no', 'e_int'] C equivalent: char *[], void *[]
- description (encoding:string): Value:
C equivalent: 32bit int
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- id (encoding:string): Value: int C equivalent roughly: for storing id name: char *, as pointer: void *
- interface (inherited from root) (encoding:string): Value: base_interface C equivalent roughly: for storing id name: char *, as pointer: void *
- name (inherited from root) (encoding:string): Value: Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- objtype (encoding:string): Value: data_type Examples of values: "op", "class", "type".
- parents (encoding:list): Value: ['root_type'] C equivalent: char *[], void *[]
- specification (inherited from root) (encoding:string): Value: atlas Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- stamp (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was
changed in this object. Any scheme is ok as long as newer numbers
are bigger than older stamps. For example, seconds since Jan 1st,
1970 or total game cycles would both be valid.
- stamp_inherit (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was changed in some object that inherits from this.
- summary (encoding:string): Value:
Integer.
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Bach version:
{
children: ["bool", "list_length", "serialno", "no", "e_int"],
description: "C equivalent: 32bit int",
id: "int",
objtype: "data_type",
parents: ["root_type"],
summary: "Integer."
}
bool
Attribute list:
- children (encoding:list): Value: ['detailed_contents'] C equivalent: char *[], void *[]
- description (inherited from int) (encoding:string): Value:
C equivalent: 32bit int
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- id (encoding:string): Value: bool C equivalent roughly: for storing id name: char *, as pointer: void *
- interface (inherited from root) (encoding:string): Value: base_interface C equivalent roughly: for storing id name: char *, as pointer: void *
- name (inherited from root) (encoding:string): Value: Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- objtype (encoding:string): Value: meta Examples of values: "op", "class", "type".
- parents (encoding:list): Value: ['int'] C equivalent: char *[], void *[]
- specification (inherited from root) (encoding:string): Value: atlas Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- stamp (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was
changed in this object. Any scheme is ok as long as newer numbers
are bigger than older stamps. For example, seconds since Jan 1st,
1970 or total game cycles would both be valid.
- stamp_inherit (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was changed in some object that inherits from this.
- summary (encoding:string): Value:
Yes/No values (encoded as 1/0)
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Bach version:
{
children: ["detailed_contents"],
id: "bool",
objtype: "meta",
parents: ["int"],
summary: "Yes/No values (encoded as 1/0)"
}
detailed_contents
Attribute list:
- children (encoding:list): Value: [] C equivalent: char *[], void *[]
- description (inherited from int) (encoding:string): Value:
C equivalent: 32bit int
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- id (encoding:string): Value: detailed_contents C equivalent roughly: for storing id name: char *, as pointer: void *
- interface (inherited from root) (encoding:string): Value: base_interface C equivalent roughly: for storing id name: char *, as pointer: void *
- name (inherited from root) (encoding:string): Value: Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- objtype (encoding:string): Value: type Examples of values: "op", "class", "type".
- parents (encoding:list): Value: ['bool'] C equivalent: char *[], void *[]
- specification (inherited from root) (encoding:string): Value: atlas Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- stamp (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was
changed in this object. Any scheme is ok as long as newer numbers
are bigger than older stamps. For example, seconds since Jan 1st,
1970 or total game cycles would both be valid.
- stamp_inherit (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was changed in some object that inherits from this.
- summary (encoding:string): Value:
true if contents gives more details than this object
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Bach version:
{
children: [],
id: "detailed_contents",
objtype: "type",
parents: ["bool"],
summary: "true if contents gives more details than this object"
}
list_length
Attribute list:
- children (encoding:list): Value: [] C equivalent: char *[], void *[]
- description (inherited from int) (encoding:string): Value:
C equivalent: 32bit int
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- id (encoding:string): Value: list_length C equivalent roughly: for storing id name: char *, as pointer: void *
- interface (inherited from root) (encoding:string): Value: base_interface C equivalent roughly: for storing id name: char *, as pointer: void *
- name (inherited from root) (encoding:string): Value: Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- objtype (encoding:string): Value: type Examples of values: "op", "class", "type".
- parents (encoding:list): Value: ['int'] C equivalent: char *[], void *[]
- specification (inherited from root) (encoding:string): Value: atlas Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- stamp (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was
changed in this object. Any scheme is ok as long as newer numbers
are bigger than older stamps. For example, seconds since Jan 1st,
1970 or total game cycles would both be valid.
- stamp_inherit (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was changed in some object that inherits from this.
- summary (encoding:string): Value:
Length for lists
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Bach version:
{
children: [],
id: "list_length",
objtype: "type",
parents: ["int"],
summary: "Length for lists"
}
serialno
Attribute list:
- children (encoding:list): Value: ['refno', 'lineno'] C equivalent: char *[], void *[]
- description (inherited from int) (encoding:string): Value:
C equivalent: 32bit int
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- id (encoding:string): Value: serialno C equivalent roughly: for storing id name: char *, as pointer: void *
- interface (inherited from root) (encoding:string): Value: base_interface C equivalent roughly: for storing id name: char *, as pointer: void *
- name (inherited from root) (encoding:string): Value: Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- objtype (encoding:string): Value: type Examples of values: "op", "class", "type".
- parents (encoding:list): Value: ['int'] C equivalent: char *[], void *[]
- specification (inherited from root) (encoding:string): Value: atlas Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- stamp (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was
changed in this object. Any scheme is ok as long as newer numbers
are bigger than older stamps. For example, seconds since Jan 1st,
1970 or total game cycles would both be valid.
- stamp_inherit (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was changed in some object that inherits from this.
- summary (encoding:string): Value:
Serial number.
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Bach version:
{
children: ["refno", "lineno"],
id: "serialno",
objtype: "type",
parents: ["int"],
summary: "Serial number."
}
refno
Attribute list:
- children (encoding:list): Value: [] C equivalent: char *[], void *[]
- description (inherited from int) (encoding:string): Value:
C equivalent: 32bit int
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- id (encoding:string): Value: refno C equivalent roughly: for storing id name: char *, as pointer: void *
- interface (inherited from root) (encoding:string): Value: base_interface C equivalent roughly: for storing id name: char *, as pointer: void *
- name (inherited from root) (encoding:string): Value: Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- objtype (inherited from serialno) (encoding:string): Value: type Examples of values: "op", "class", "type".
- parents (encoding:list): Value: ['serialno'] C equivalent: char *[], void *[]
- specification (inherited from root) (encoding:string): Value: atlas Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- stamp (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was
changed in this object. Any scheme is ok as long as newer numbers
are bigger than older stamps. For example, seconds since Jan 1st,
1970 or total game cycles would both be valid.
- stamp_inherit (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was changed in some object that inherits from this.
- summary (encoding:string): Value:
Reference to serial number.
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Bach version:
{
children: [],
id: "refno",
parents: ["serialno"],
summary: "Reference to serial number."
}
lineno
Attribute list:
- children (encoding:list): Value: [] C equivalent: char *[], void *[]
- description (inherited from int) (encoding:string): Value:
C equivalent: 32bit int
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- id (encoding:string): Value: lineno C equivalent roughly: for storing id name: char *, as pointer: void *
- interface (inherited from root) (encoding:string): Value: base_interface C equivalent roughly: for storing id name: char *, as pointer: void *
- name (inherited from root) (encoding:string): Value: Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- objtype (inherited from serialno) (encoding:string): Value: type Examples of values: "op", "class", "type".
- parents (encoding:list): Value: ['serialno'] C equivalent: char *[], void *[]
- specification (inherited from root) (encoding:string): Value: atlas Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- stamp (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was
changed in this object. Any scheme is ok as long as newer numbers
are bigger than older stamps. For example, seconds since Jan 1st,
1970 or total game cycles would both be valid.
- stamp_inherit (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was changed in some object that inherits from this.
- summary (encoding:string): Value:
linenumber where something is
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Bach version:
{
children: [],
id: "lineno",
parents: ["serialno"],
summary: "linenumber where something is"
}
no
Attribute list:
- children (encoding:list): Value: [] C equivalent: char *[], void *[]
- description (inherited from int) (encoding:string): Value:
C equivalent: 32bit int
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- id (encoding:string): Value: no C equivalent roughly: for storing id name: char *, as pointer: void *
- interface (inherited from root) (encoding:string): Value: base_interface C equivalent roughly: for storing id name: char *, as pointer: void *
- name (inherited from root) (encoding:string): Value: Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- objtype (inherited from int) (encoding:string): Value: data_type Examples of values: "op", "class", "type".
- parents (encoding:list): Value: ['int'] C equivalent: char *[], void *[]
- specification (inherited from root) (encoding:string): Value: atlas Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- stamp (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was
changed in this object. Any scheme is ok as long as newer numbers
are bigger than older stamps. For example, seconds since Jan 1st,
1970 or total game cycles would both be valid.
- stamp_inherit (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was changed in some object that inherits from this.
- summary (encoding:string): Value:
Number (for example error number).
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Bach version:
{
children: [],
id: "no",
parents: ["int"],
summary: "Number (for example error number)."
}
e_int
Attribute list:
- children (encoding:list): Value: ['e_HP', 'e_attack', 'e_amount'] C equivalent: char *[], void *[]
- description (inherited from int) (encoding:string): Value:
C equivalent: 32bit int
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- id (encoding:string): Value: e_int C equivalent roughly: for storing id name: char *, as pointer: void *
- interface (inherited from root) (encoding:string): Value: base_interface C equivalent roughly: for storing id name: char *, as pointer: void *
- name (inherited from root) (encoding:string): Value: Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- objtype (encoding:string): Value: type Examples of values: "op", "class", "type".
- parents (encoding:list): Value: ['int'] C equivalent: char *[], void *[]
- specification (inherited from root) (encoding:string): Value: atlas Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- stamp (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was
changed in this object. Any scheme is ok as long as newer numbers
are bigger than older stamps. For example, seconds since Jan 1st,
1970 or total game cycles would both be valid.
- stamp_inherit (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was changed in some object that inherits from this.
- summary (encoding:string): Value:
Root type for all int type example attributes
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Bach version:
{
children: ["e_HP", "e_attack", "e_amount"],
id: "e_int",
objtype: "type",
parents: ["int"],
summary: "Root type for all int type example attributes"
}
e_HP
Attribute list:
- children (encoding:list): Value: [] C equivalent: char *[], void *[]
- description (inherited from int) (encoding:string): Value:
C equivalent: 32bit int
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- id (encoding:string): Value: e_HP C equivalent roughly: for storing id name: char *, as pointer: void *
- interface (inherited from root) (encoding:string): Value: base_interface C equivalent roughly: for storing id name: char *, as pointer: void *
- name (inherited from root) (encoding:string): Value: Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- objtype (inherited from e_int) (encoding:string): Value: type Examples of values: "op", "class", "type".
- parents (encoding:list): Value: ['e_int'] C equivalent: char *[], void *[]
- specification (inherited from root) (encoding:string): Value: atlas Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- stamp (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was
changed in this object. Any scheme is ok as long as newer numbers
are bigger than older stamps. For example, seconds since Jan 1st,
1970 or total game cycles would both be valid.
- stamp_inherit (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was changed in some object that inherits from this.
- summary (inherited from e_int) (encoding:string): Value:
Root type for all int type example attributes
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Bach version:
{
children: [],
id: "e_HP",
parents: ["e_int"]
}
e_attack
Attribute list:
- children (encoding:list): Value: [] C equivalent: char *[], void *[]
- description (inherited from int) (encoding:string): Value:
C equivalent: 32bit int
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- id (encoding:string): Value: e_attack C equivalent roughly: for storing id name: char *, as pointer: void *
- interface (inherited from root) (encoding:string): Value: base_interface C equivalent roughly: for storing id name: char *, as pointer: void *
- name (inherited from root) (encoding:string): Value: Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- objtype (inherited from e_int) (encoding:string): Value: type Examples of values: "op", "class", "type".
- parents (encoding:list): Value: ['e_int'] C equivalent: char *[], void *[]
- specification (inherited from root) (encoding:string): Value: atlas Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- stamp (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was
changed in this object. Any scheme is ok as long as newer numbers
are bigger than older stamps. For example, seconds since Jan 1st,
1970 or total game cycles would both be valid.
- stamp_inherit (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was changed in some object that inherits from this.
- summary (inherited from e_int) (encoding:string): Value:
Root type for all int type example attributes
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Bach version:
{
children: [],
id: "e_attack",
parents: ["e_int"]
}
e_amount
Attribute list:
- children (encoding:list): Value: [] C equivalent: char *[], void *[]
- description (inherited from int) (encoding:string): Value:
C equivalent: 32bit int
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- id (encoding:string): Value: e_amount C equivalent roughly: for storing id name: char *, as pointer: void *
- interface (inherited from root) (encoding:string): Value: base_interface C equivalent roughly: for storing id name: char *, as pointer: void *
- name (inherited from root) (encoding:string): Value: Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- objtype (inherited from e_int) (encoding:string): Value: type Examples of values: "op", "class", "type".
- parents (encoding:list): Value: ['e_int'] C equivalent: char *[], void *[]
- specification (inherited from root) (encoding:string): Value: atlas Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- stamp (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was
changed in this object. Any scheme is ok as long as newer numbers
are bigger than older stamps. For example, seconds since Jan 1st,
1970 or total game cycles would both be valid.
- stamp_inherit (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was changed in some object that inherits from this.
- summary (inherited from e_int) (encoding:string): Value:
Root type for all int type example attributes
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Bach version:
{
children: [],
id: "e_amount",
parents: ["e_int"]
}
float
Attribute list:
- children (encoding:list): Value: ['stamp', 'seconds', 'e_float'] C equivalent: char *[], void *[]
- description (encoding:string): Value:
C equivalent roughly: double
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- id (encoding:string): Value: float C equivalent roughly: for storing id name: char *, as pointer: void *
- interface (inherited from root) (encoding:string): Value: base_interface C equivalent roughly: for storing id name: char *, as pointer: void *
- name (inherited from root) (encoding:string): Value: Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- objtype (encoding:string): Value: data_type Examples of values: "op", "class", "type".
- parents (encoding:list): Value: ['root_type'] C equivalent: char *[], void *[]
- specification (inherited from root) (encoding:string): Value: atlas Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- stamp (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was
changed in this object. Any scheme is ok as long as newer numbers
are bigger than older stamps. For example, seconds since Jan 1st,
1970 or total game cycles would both be valid.
- stamp_inherit (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was changed in some object that inherits from this.
- summary (encoding:string): Value:
Floating point number.
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Bach version:
{
children: ["stamp", "seconds", "e_float"],
description: "C equivalent roughly: double",
id: "float",
objtype: "data_type",
parents: ["root_type"],
summary: "Floating point number."
}
stamp
Attribute list:
- children (encoding:list): Value: ['stamp_inherit', 'stamp_contains'] C equivalent: char *[], void *[]
- description (encoding:string): Value:
Value should be reflect when something was
changed in this object. Any scheme is ok as long as newer numbers
are bigger than older stamps. For example, seconds since Jan 1st,
1970 or total game cycles would both be valid.
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- id (encoding:string): Value: stamp C equivalent roughly: for storing id name: char *, as pointer: void *
- interface (inherited from root) (encoding:string): Value: base_interface C equivalent roughly: for storing id name: char *, as pointer: void *
- name (inherited from root) (encoding:string): Value: Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- objtype (encoding:string): Value: type Examples of values: "op", "class", "type".
- parents (encoding:list): Value: ['float'] C equivalent: char *[], void *[]
- specification (inherited from root) (encoding:string): Value: atlas Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- stamp (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was
changed in this object. Any scheme is ok as long as newer numbers
are bigger than older stamps. For example, seconds since Jan 1st,
1970 or total game cycles would both be valid.
- stamp_inherit (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was changed in some object that inherits from this.
- summary (encoding:string): Value:
Last time this object was modified.
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Bach version:
{
children: ["stamp_inherit", "stamp_contains"],
description: "Value should be reflect when something was
changed in this object. Any scheme is ok as long as newer numbers
are bigger than older stamps. For example, seconds since Jan 1st,
1970 or total game cycles would both be valid.",
id: "stamp",
objtype: "type",
parents: ["float"],
summary: "Last time this object was modified."
}
stamp_inherit
Attribute list:
- children (encoding:list): Value: [] C equivalent: char *[], void *[]
- description (encoding:string): Value:
Value should be reflect when something was changed in some object that inherits from this.
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- id (encoding:string): Value: stamp_inherit C equivalent roughly: for storing id name: char *, as pointer: void *
- interface (inherited from root) (encoding:string): Value: base_interface C equivalent roughly: for storing id name: char *, as pointer: void *
- name (inherited from root) (encoding:string): Value: Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- objtype (encoding:string): Value: type Examples of values: "op", "class", "type".
- parents (encoding:list): Value: ['stamp'] C equivalent: char *[], void *[]
- specification (inherited from root) (encoding:string): Value: atlas Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- stamp (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was
changed in this object. Any scheme is ok as long as newer numbers
are bigger than older stamps. For example, seconds since Jan 1st,
1970 or total game cycles would both be valid.
- stamp_inherit (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was changed in some object that inherits from this.
- summary (encoding:string): Value:
Last time any object that inherits from this has been modified
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Bach version:
{
children: [],
description: "Value should be reflect when something was changed in some object that inherits from this.",
id: "stamp_inherit",
objtype: "type",
parents: ["stamp"],
summary: "Last time any object that inherits from this has been modified"
}
stamp_contains
Attribute list:
- children (encoding:list): Value: [] C equivalent: char *[], void *[]
- description (encoding:string): Value:
Value should be reflect when something was changed in some object that is contained by this object.
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- id (encoding:string): Value: stamp_contains C equivalent roughly: for storing id name: char *, as pointer: void *
- interface (inherited from root) (encoding:string): Value: base_interface C equivalent roughly: for storing id name: char *, as pointer: void *
- name (inherited from root) (encoding:string): Value: Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- objtype (encoding:string): Value: type Examples of values: "op", "class", "type".
- parents (encoding:list): Value: ['stamp'] C equivalent: char *[], void *[]
- specification (inherited from root) (encoding:string): Value: atlas Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- stamp (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was
changed in this object. Any scheme is ok as long as newer numbers
are bigger than older stamps. For example, seconds since Jan 1st,
1970 or total game cycles would both be valid.
- stamp_inherit (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was changed in some object that inherits from this.
- summary (encoding:string): Value:
Last time any object that uses this as reference recursively has been modified
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Bach version:
{
children: [],
description: "Value should be reflect when something was changed in some object that is contained by this object.",
id: "stamp_contains",
objtype: "type",
parents: ["stamp"],
summary: "Last time any object that uses this as reference recursively has been modified"
}
seconds
Attribute list:
- children (encoding:list): Value: ['future_seconds'] C equivalent: char *[], void *[]
- description (inherited from float) (encoding:string): Value:
C equivalent roughly: double
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- id (encoding:string): Value: seconds C equivalent roughly: for storing id name: char *, as pointer: void *
- interface (inherited from root) (encoding:string): Value: base_interface C equivalent roughly: for storing id name: char *, as pointer: void *
- name (inherited from root) (encoding:string): Value: Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- objtype (encoding:string): Value: type Examples of values: "op", "class", "type".
- parents (encoding:list): Value: ['float'] C equivalent: char *[], void *[]
- specification (inherited from root) (encoding:string): Value: atlas Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- stamp (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was
changed in this object. Any scheme is ok as long as newer numbers
are bigger than older stamps. For example, seconds since Jan 1st,
1970 or total game cycles would both be valid.
- stamp_inherit (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was changed in some object that inherits from this.
- summary (encoding:string): Value:
Time in seconds
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Bach version:
{
children: ["future_seconds"],
id: "seconds",
objtype: "type",
parents: ["float"],
summary: "Time in seconds"
}
future_seconds
Attribute list:
- children (encoding:list): Value: [] C equivalent: char *[], void *[]
- description (inherited from float) (encoding:string): Value:
C equivalent roughly: double
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- id (encoding:string): Value: future_seconds C equivalent roughly: for storing id name: char *, as pointer: void *
- interface (inherited from root) (encoding:string): Value: base_interface C equivalent roughly: for storing id name: char *, as pointer: void *
- name (inherited from root) (encoding:string): Value: Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- objtype (inherited from seconds) (encoding:string): Value: type Examples of values: "op", "class", "type".
- parents (encoding:list): Value: ['seconds'] C equivalent: char *[], void *[]
- specification (inherited from root) (encoding:string): Value: atlas Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- stamp (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was
changed in this object. Any scheme is ok as long as newer numbers
are bigger than older stamps. For example, seconds since Jan 1st,
1970 or total game cycles would both be valid.
- stamp_inherit (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was changed in some object that inherits from this.
- summary (encoding:string): Value:
Time in seconds to add current time
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Bach version:
{
children: [],
id: "future_seconds",
parents: ["seconds"],
summary: "Time in seconds to add current time"
}
e_float
Attribute list:
- children (encoding:list): Value: ['e_height', 'e_width', 'e_drunkness', 'e_status'] C equivalent: char *[], void *[]
- description (inherited from float) (encoding:string): Value:
C equivalent roughly: double
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- id (encoding:string): Value: e_float C equivalent roughly: for storing id name: char *, as pointer: void *
- interface (inherited from root) (encoding:string): Value: base_interface C equivalent roughly: for storing id name: char *, as pointer: void *
- name (inherited from root) (encoding:string): Value: Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- objtype (encoding:string): Value: type Examples of values: "op", "class", "type".
- parents (encoding:list): Value: ['float'] C equivalent: char *[], void *[]
- specification (inherited from root) (encoding:string): Value: atlas Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- stamp (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was
changed in this object. Any scheme is ok as long as newer numbers
are bigger than older stamps. For example, seconds since Jan 1st,
1970 or total game cycles would both be valid.
- stamp_inherit (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was changed in some object that inherits from this.
- summary (encoding:string): Value:
Root type for all float type example attributes
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Bach version:
{
children: ["e_height", "e_width", "e_drunkness", "e_status"],
id: "e_float",
objtype: "type",
parents: ["float"],
summary: "Root type for all float type example attributes"
}
e_height
Attribute list:
- children (encoding:list): Value: [] C equivalent: char *[], void *[]
- description (inherited from float) (encoding:string): Value:
C equivalent roughly: double
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- id (encoding:string): Value: e_height C equivalent roughly: for storing id name: char *, as pointer: void *
- interface (inherited from root) (encoding:string): Value: base_interface C equivalent roughly: for storing id name: char *, as pointer: void *
- name (inherited from root) (encoding:string): Value: Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- objtype (inherited from e_float) (encoding:string): Value: type Examples of values: "op", "class", "type".
- parents (encoding:list): Value: ['e_float'] C equivalent: char *[], void *[]
- specification (inherited from root) (encoding:string): Value: atlas Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- stamp (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was
changed in this object. Any scheme is ok as long as newer numbers
are bigger than older stamps. For example, seconds since Jan 1st,
1970 or total game cycles would both be valid.
- stamp_inherit (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was changed in some object that inherits from this.
- summary (inherited from e_float) (encoding:string): Value:
Root type for all float type example attributes
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Bach version:
{
children: [],
id: "e_height",
parents: ["e_float"]
}
e_width
Attribute list:
- children (encoding:list): Value: [] C equivalent: char *[], void *[]
- description (inherited from float) (encoding:string): Value:
C equivalent roughly: double
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- id (encoding:string): Value: e_width C equivalent roughly: for storing id name: char *, as pointer: void *
- interface (inherited from root) (encoding:string): Value: base_interface C equivalent roughly: for storing id name: char *, as pointer: void *
- name (inherited from root) (encoding:string): Value: Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- objtype (inherited from e_float) (encoding:string): Value: type Examples of values: "op", "class", "type".
- parents (encoding:list): Value: ['e_float'] C equivalent: char *[], void *[]
- specification (inherited from root) (encoding:string): Value: atlas Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- stamp (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was
changed in this object. Any scheme is ok as long as newer numbers
are bigger than older stamps. For example, seconds since Jan 1st,
1970 or total game cycles would both be valid.
- stamp_inherit (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was changed in some object that inherits from this.
- summary (inherited from e_float) (encoding:string): Value:
Root type for all float type example attributes
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Bach version:
{
children: [],
id: "e_width",
parents: ["e_float"]
}
e_drunkness
Attribute list:
- children (encoding:list): Value: [] C equivalent: char *[], void *[]
- description (inherited from float) (encoding:string): Value:
C equivalent roughly: double
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- id (encoding:string): Value: e_drunkness C equivalent roughly: for storing id name: char *, as pointer: void *
- interface (inherited from root) (encoding:string): Value: base_interface C equivalent roughly: for storing id name: char *, as pointer: void *
- name (inherited from root) (encoding:string): Value: Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- objtype (inherited from e_float) (encoding:string): Value: type Examples of values: "op", "class", "type".
- parents (encoding:list): Value: ['e_float'] C equivalent: char *[], void *[]
- specification (inherited from root) (encoding:string): Value: atlas Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- stamp (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was
changed in this object. Any scheme is ok as long as newer numbers
are bigger than older stamps. For example, seconds since Jan 1st,
1970 or total game cycles would both be valid.
- stamp_inherit (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was changed in some object that inherits from this.
- summary (inherited from e_float) (encoding:string): Value:
Root type for all float type example attributes
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Bach version:
{
children: [],
id: "e_drunkness",
parents: ["e_float"]
}
e_status
Attribute list:
- children (encoding:list): Value: [] C equivalent: char *[], void *[]
- description (inherited from float) (encoding:string): Value:
C equivalent roughly: double
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- id (encoding:string): Value: e_status C equivalent roughly: for storing id name: char *, as pointer: void *
- interface (inherited from root) (encoding:string): Value: base_interface C equivalent roughly: for storing id name: char *, as pointer: void *
- name (inherited from root) (encoding:string): Value: Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- objtype (inherited from e_float) (encoding:string): Value: type Examples of values: "op", "class", "type".
- parents (encoding:list): Value: ['e_float'] C equivalent: char *[], void *[]
- specification (inherited from root) (encoding:string): Value: atlas Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- stamp (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was
changed in this object. Any scheme is ok as long as newer numbers
are bigger than older stamps. For example, seconds since Jan 1st,
1970 or total game cycles would both be valid.
- stamp_inherit (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was changed in some object that inherits from this.
- summary (inherited from e_float) (encoding:string): Value:
Root type for all float type example attributes
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Bach version:
{
children: [],
id: "e_status",
parents: ["e_float"]
}
list
Attribute list:
- added_attributes (encoding:list): Value: [] C equivalent: char *[], void *[]
- children (encoding:list): Value: ['string_list', 'int_list', 'float_list', 'rotation', 'args_source', 'args_destination', 'arg_names', 'example', 'triangle_list', 'tetrahedron_list', 'glue_ids', 'pos_list', 'e_list'] C equivalent: char *[], void *[]
- description (encoding:string): Value:
C equivalent: void *[]
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- id (encoding:string): Value: list C equivalent roughly: for storing id name: char *, as pointer: void *
- interface (inherited from root) (encoding:string): Value: base_interface C equivalent roughly: for storing id name: char *, as pointer: void *
- name (inherited from root) (encoding:string): Value: Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- objtype (encoding:string): Value: data_type Examples of values: "op", "class", "type".
- parents (encoding:list): Value: ['root_type'] C equivalent: char *[], void *[]
- specification (inherited from root) (encoding:string): Value: atlas Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- stamp (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was
changed in this object. Any scheme is ok as long as newer numbers
are bigger than older stamps. For example, seconds since Jan 1st,
1970 or total game cycles would both be valid.
- stamp_inherit (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was changed in some object that inherits from this.
- summary (encoding:string): Value:
List of objects
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Bach version:
{
added_attributes: [],
children: ["string_list", "int_list", "float_list", "rotation", "args_source", "args_destination", "arg_names", "example", "triangle_list", "tetrahedron_list", "glue_ids", "pos_list", "e_list"],
description: "C equivalent: void *[]",
id: "list",
objtype: "data_type",
parents: ["root_type"],
summary: "List of objects"
}
string_list
Attribute list:
- added_attributes (inherited from list) (encoding:list): Value: [] C equivalent: char *[], void *[]
- children (encoding:list): Value: ['uri_list'] C equivalent: char *[], void *[]
- description (inherited from list) (encoding:string): Value:
C equivalent: void *[]
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- element_type (encoding:string): Value: string C equivalent roughly: for storing id name: char *, as pointer: void *
- id (encoding:string): Value: string_list C equivalent roughly: for storing id name: char *, as pointer: void *
- interface (inherited from root) (encoding:string): Value: base_interface C equivalent roughly: for storing id name: char *, as pointer: void *
- name (inherited from root) (encoding:string): Value: Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- objtype (encoding:string): Value: type Examples of values: "op", "class", "type".
- parents (encoding:list): Value: ['list'] C equivalent: char *[], void *[]
- specification (inherited from root) (encoding:string): Value: atlas Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- stamp (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was
changed in this object. Any scheme is ok as long as newer numbers
are bigger than older stamps. For example, seconds since Jan 1st,
1970 or total game cycles would both be valid.
- stamp_inherit (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was changed in some object that inherits from this.
- summary (encoding:string): Value:
List of strings
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Bach version:
{
children: ["uri_list"],
element_type: "string",
id: "string_list",
objtype: "type",
parents: ["list"],
summary: "List of strings"
}
uri_list
Attribute list:
- added_attributes (inherited from list) (encoding:list): Value: [] C equivalent: char *[], void *[]
- children (encoding:list): Value: ['id_list'] C equivalent: char *[], void *[]
- description (encoding:string): Value:
C equivalent: char *[], void *[]
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- element_type (encoding:string): Value: uri C equivalent roughly: for storing id name: char *, as pointer: void *
- id (encoding:string): Value: uri_list C equivalent roughly: for storing id name: char *, as pointer: void *
- interface (inherited from root) (encoding:string): Value: base_interface C equivalent roughly: for storing id name: char *, as pointer: void *
- name (inherited from root) (encoding:string): Value: Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- objtype (inherited from string_list) (encoding:string): Value: type Examples of values: "op", "class", "type".
- parents (encoding:list): Value: ['string_list'] C equivalent: char *[], void *[]
- specification (inherited from root) (encoding:string): Value: atlas Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- stamp (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was
changed in this object. Any scheme is ok as long as newer numbers
are bigger than older stamps. For example, seconds since Jan 1st,
1970 or total game cycles would both be valid.
- stamp_inherit (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was changed in some object that inherits from this.
- summary (encoding:string): Value:
URI list
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Bach version:
{
children: ["id_list"],
description: "C equivalent: char *[], void *[]",
element_type: "uri",
id: "uri_list",
parents: ["string_list"],
summary: "URI list"
}
id_list
Attribute list:
- added_attributes (inherited from list) (encoding:list): Value: [] C equivalent: char *[], void *[]
- children (encoding:list): Value: ['parents', 'children', 'contains', 'operations', 'coord_id_list', 'glue', 'media_roots', 'attribute_order'] C equivalent: char *[], void *[]
- description (inherited from uri_list) (encoding:string): Value:
C equivalent: char *[], void *[]
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- element_type (inherited from uri_list) (encoding:string): Value: uri C equivalent roughly: for storing id name: char *, as pointer: void *
- id (encoding:string): Value: id_list C equivalent roughly: for storing id name: char *, as pointer: void *
- interface (inherited from root) (encoding:string): Value: base_interface C equivalent roughly: for storing id name: char *, as pointer: void *
- name (inherited from root) (encoding:string): Value: Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- objtype (inherited from string_list) (encoding:string): Value: type Examples of values: "op", "class", "type".
- parents (encoding:list): Value: ['uri_list'] C equivalent: char *[], void *[]
- specification (inherited from root) (encoding:string): Value: atlas Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- stamp (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was
changed in this object. Any scheme is ok as long as newer numbers
are bigger than older stamps. For example, seconds since Jan 1st,
1970 or total game cycles would both be valid.
- stamp_inherit (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was changed in some object that inherits from this.
- summary (encoding:string): Value:
List of ids
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Bach version:
{
children: ["parents", "children", "contains", "operations", "coord_id_list", "glue", "media_roots", "attribute_order"],
id: "id_list",
parents: ["uri_list"],
summary: "List of ids"
}
parents
Attribute list:
- added_attributes (inherited from list) (encoding:list): Value: [] C equivalent: char *[], void *[]
- children (encoding:list): Value: [] C equivalent: char *[], void *[]
- description (inherited from uri_list) (encoding:string): Value:
C equivalent: char *[], void *[]
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- element_type (inherited from uri_list) (encoding:string): Value: uri C equivalent roughly: for storing id name: char *, as pointer: void *
- id (encoding:string): Value: parents C equivalent roughly: for storing id name: char *, as pointer: void *
- interface (inherited from root) (encoding:string): Value: base_interface C equivalent roughly: for storing id name: char *, as pointer: void *
- name (inherited from root) (encoding:string): Value: Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- objtype (inherited from string_list) (encoding:string): Value: type Examples of values: "op", "class", "type".
- parents (encoding:list): Value: ['id_list'] C equivalent: char *[], void *[]
- specification (inherited from root) (encoding:string): Value: atlas Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- stamp (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was
changed in this object. Any scheme is ok as long as newer numbers
are bigger than older stamps. For example, seconds since Jan 1st,
1970 or total game cycles would both be valid.
- stamp_inherit (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was changed in some object that inherits from this.
- summary (encoding:string): Value:
List of objects this inherits attributes from.
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Bach version:
{
children: [],
id: "parents",
parents: ["id_list"],
summary: "List of objects this inherits attributes from."
}
children
Attribute list:
- added_attributes (inherited from list) (encoding:list): Value: [] C equivalent: char *[], void *[]
- children (encoding:list): Value: [] C equivalent: char *[], void *[]
- description (inherited from uri_list) (encoding:string): Value:
C equivalent: char *[], void *[]
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- element_type (inherited from uri_list) (encoding:string): Value: uri C equivalent roughly: for storing id name: char *, as pointer: void *
- id (encoding:string): Value: children C equivalent roughly: for storing id name: char *, as pointer: void *
- interface (inherited from root) (encoding:string): Value: base_interface C equivalent roughly: for storing id name: char *, as pointer: void *
- name (inherited from root) (encoding:string): Value: Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- objtype (inherited from string_list) (encoding:string): Value: type Examples of values: "op", "class", "type".
- parents (encoding:list): Value: ['id_list'] C equivalent: char *[], void *[]
- specification (inherited from root) (encoding:string): Value: atlas Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- stamp (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was
changed in this object. Any scheme is ok as long as newer numbers
are bigger than older stamps. For example, seconds since Jan 1st,
1970 or total game cycles would both be valid.
- stamp_inherit (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was changed in some object that inherits from this.
- summary (encoding:string): Value:
List of objects that inherit from this object.
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Bach version:
{
children: [],
id: "children",
parents: ["id_list"],
summary: "List of objects that inherit from this object."
}
contains
Attribute list:
- added_attributes (inherited from list) (encoding:list): Value: [] C equivalent: char *[], void *[]
- children (encoding:list): Value: ['added_attributes', 'characters'] C equivalent: char *[], void *[]
- description (inherited from uri_list) (encoding:string): Value:
C equivalent: char *[], void *[]
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- element_type (inherited from uri_list) (encoding:string): Value: uri C equivalent roughly: for storing id name: char *, as pointer: void *
- id (encoding:string): Value: contains C equivalent roughly: for storing id name: char *, as pointer: void *
- interface (inherited from root) (encoding:string): Value: base_interface C equivalent roughly: for storing id name: char *, as pointer: void *
- name (inherited from root) (encoding:string): Value: Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- objtype (inherited from string_list) (encoding:string): Value: type Examples of values: "op", "class", "type".
- parents (encoding:list): Value: ['id_list'] C equivalent: char *[], void *[]
- specification (inherited from root) (encoding:string): Value: atlas Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- stamp (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was
changed in this object. Any scheme is ok as long as newer numbers
are bigger than older stamps. For example, seconds since Jan 1st,
1970 or total game cycles would both be valid.
- stamp_inherit (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was changed in some object that inherits from this.
- summary (encoding:string): Value:
List of objects that use this object as reference system (usually same as what this object contains).
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Bach version:
{
children: ["added_attributes", "characters"],
id: "contains",
parents: ["id_list"],
summary: "List of objects that use this object as reference system (usually same as what this object contains)."
}
added_attributes
Attribute list:
- added_attributes (inherited from list) (encoding:list): Value: [] C equivalent: char *[], void *[]
- children (encoding:list): Value: [] C equivalent: char *[], void *[]
- description (inherited from uri_list) (encoding:string): Value:
C equivalent: char *[], void *[]
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- element_type (inherited from uri_list) (encoding:string): Value: uri C equivalent roughly: for storing id name: char *, as pointer: void *
- id (encoding:string): Value: added_attributes C equivalent roughly: for storing id name: char *, as pointer: void *
- interface (inherited from root) (encoding:string): Value: base_interface C equivalent roughly: for storing id name: char *, as pointer: void *
- name (inherited from root) (encoding:string): Value: Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- objtype (inherited from string_list) (encoding:string): Value: type Examples of values: "op", "class", "type".
- parents (encoding:list): Value: ['contains'] C equivalent: char *[], void *[]
- specification (inherited from root) (encoding:string): Value: atlas Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- stamp (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was
changed in this object. Any scheme is ok as long as newer numbers
are bigger than older stamps. For example, seconds since Jan 1st,
1970 or total game cycles would both be valid.
- stamp_inherit (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was changed in some object that inherits from this.
- summary (encoding:string): Value:
List of attributes that has been added to this object
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Bach version:
{
children: [],
id: "added_attributes",
parents: ["contains"],
summary: "List of attributes that has been added to this object"
}
characters
Attribute list:
- added_attributes (inherited from list) (encoding:list): Value: [] C equivalent: char *[], void *[]
- children (encoding:list): Value: [] C equivalent: char *[], void *[]
- description (inherited from uri_list) (encoding:string): Value:
C equivalent: char *[], void *[]
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- element_type (inherited from uri_list) (encoding:string): Value: uri C equivalent roughly: for storing id name: char *, as pointer: void *
- id (encoding:string): Value: characters C equivalent roughly: for storing id name: char *, as pointer: void *
- interface (inherited from root) (encoding:string): Value: base_interface C equivalent roughly: for storing id name: char *, as pointer: void *
- name (inherited from root) (encoding:string): Value: Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- objtype (inherited from string_list) (encoding:string): Value: type Examples of values: "op", "class", "type".
- parents (encoding:list): Value: ['contains'] C equivalent: char *[], void *[]
- specification (inherited from root) (encoding:string): Value: atlas Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- stamp (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was
changed in this object. Any scheme is ok as long as newer numbers
are bigger than older stamps. For example, seconds since Jan 1st,
1970 or total game cycles would both be valid.
- stamp_inherit (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was changed in some object that inherits from this.
- summary (encoding:string): Value:
List of characters account can control
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Bach version:
{
children: [],
id: "characters",
parents: ["contains"],
summary: "List of characters account can control"
}
operations
Attribute list:
- added_attributes (inherited from list) (encoding:list): Value: [] C equivalent: char *[], void *[]
- children (encoding:list): Value: [] C equivalent: char *[], void *[]
- description (encoding:string): Value:
Content ids can be either another interface or operation ids or both.
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- element_type (inherited from uri_list) (encoding:string): Value: uri C equivalent roughly: for storing id name: char *, as pointer: void *
- id (encoding:string): Value: operations C equivalent roughly: for storing id name: char *, as pointer: void *
- interface (inherited from root) (encoding:string): Value: base_interface C equivalent roughly: for storing id name: char *, as pointer: void *
- name (inherited from root) (encoding:string): Value: Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- objtype (inherited from string_list) (encoding:string): Value: type Examples of values: "op", "class", "type".
- parents (encoding:list): Value: ['id_list'] C equivalent: char *[], void *[]
- specification (inherited from root) (encoding:string): Value: atlas Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- stamp (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was
changed in this object. Any scheme is ok as long as newer numbers
are bigger than older stamps. For example, seconds since Jan 1st,
1970 or total game cycles would both be valid.
- stamp_inherit (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was changed in some object that inherits from this.
- summary (encoding:string): Value:
List of alloved operations
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Bach version:
{
children: [],
description: "Content ids can be either another interface or operation ids or both.",
id: "operations",
parents: ["id_list"],
summary: "List of alloved operations"
}
coord_id_list
Attribute list:
- added_attributes (inherited from list) (encoding:list): Value: [] C equivalent: char *[], void *[]
- children (encoding:list): Value: ['coord_id_list_length', 'polyline'] C equivalent: char *[], void *[]
- description (inherited from uri_list) (encoding:string): Value:
C equivalent: char *[], void *[]
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- element_type (inherited from uri_list) (encoding:string): Value: uri C equivalent roughly: for storing id name: char *, as pointer: void *
- id (encoding:string): Value: coord_id_list C equivalent roughly: for storing id name: char *, as pointer: void *
- interface (inherited from root) (encoding:string): Value: base_interface C equivalent roughly: for storing id name: char *, as pointer: void *
- name (inherited from root) (encoding:string): Value: Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- objtype (inherited from string_list) (encoding:string): Value: type Examples of values: "op", "class", "type".
- parents (encoding:list): Value: ['id_list'] C equivalent: char *[], void *[]
- specification (inherited from root) (encoding:string): Value: atlas Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- stamp (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was
changed in this object. Any scheme is ok as long as newer numbers
are bigger than older stamps. For example, seconds since Jan 1st,
1970 or total game cycles would both be valid.
- stamp_inherit (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was changed in some object that inherits from this.
- summary (encoding:string): Value:
Pointer to coordinates
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Bach version:
{
children: ["coord_id_list_length", "polyline"],
id: "coord_id_list",
parents: ["id_list"],
summary: "Pointer to coordinates"
}
coord_id_list_length
Attribute list:
- added_attributes (inherited from list) (encoding:list): Value: [] C equivalent: char *[], void *[]
- children (encoding:list): Value: ['triangle', 'tetrahedron'] C equivalent: char *[], void *[]
- description (inherited from uri_list) (encoding:string): Value:
C equivalent: char *[], void *[]
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- element_type (inherited from uri_list) (encoding:string): Value: uri C equivalent roughly: for storing id name: char *, as pointer: void *
- id (encoding:string): Value: coord_id_list_length C equivalent roughly: for storing id name: char *, as pointer: void *
- interface (inherited from root) (encoding:string): Value: base_interface C equivalent roughly: for storing id name: char *, as pointer: void *
- list_length (encoding:int): Value: 0 C equivalent: 32bit int
- name (inherited from root) (encoding:string): Value: Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- objtype (inherited from string_list) (encoding:string): Value: type Examples of values: "op", "class", "type".
- parents (encoding:list): Value: ['coord_id_list'] C equivalent: char *[], void *[]
- specification (inherited from root) (encoding:string): Value: atlas Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- stamp (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was
changed in this object. Any scheme is ok as long as newer numbers
are bigger than older stamps. For example, seconds since Jan 1st,
1970 or total game cycles would both be valid.
- stamp_inherit (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was changed in some object that inherits from this.
- summary (encoding:string): Value:
Fixed length coordinate pointer list
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Bach version:
{
children: ["triangle", "tetrahedron"],
id: "coord_id_list_length",
list_length: 0,
parents: ["coord_id_list"],
summary: "Fixed length coordinate pointer list"
}
triangle
Attribute list:
- added_attributes (inherited from list) (encoding:list): Value: [] C equivalent: char *[], void *[]
- children (encoding:list): Value: [] C equivalent: char *[], void *[]
- description (inherited from uri_list) (encoding:string): Value:
C equivalent: char *[], void *[]
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- element_type (inherited from uri_list) (encoding:string): Value: uri C equivalent roughly: for storing id name: char *, as pointer: void *
- id (encoding:string): Value: triangle C equivalent roughly: for storing id name: char *, as pointer: void *
- interface (inherited from root) (encoding:string): Value: base_interface C equivalent roughly: for storing id name: char *, as pointer: void *
- list_length (encoding:int): Value: 3 C equivalent: 32bit int
- name (inherited from root) (encoding:string): Value: Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- objtype (inherited from string_list) (encoding:string): Value: type Examples of values: "op", "class", "type".
- parents (encoding:list): Value: ['coord_id_list_length'] C equivalent: char *[], void *[]
- specification (inherited from root) (encoding:string): Value: atlas Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- stamp (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was
changed in this object. Any scheme is ok as long as newer numbers
are bigger than older stamps. For example, seconds since Jan 1st,
1970 or total game cycles would both be valid.
- stamp_inherit (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was changed in some object that inherits from this.
- summary (encoding:string): Value:
Pointers to triangle points
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Bach version:
{
children: [],
id: "triangle",
list_length: 3,
parents: ["coord_id_list_length"],
summary: "Pointers to triangle points"
}
tetrahedron
Attribute list:
- added_attributes (inherited from list) (encoding:list): Value: [] C equivalent: char *[], void *[]
- children (encoding:list): Value: [] C equivalent: char *[], void *[]
- description (inherited from uri_list) (encoding:string): Value:
C equivalent: char *[], void *[]
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- element_type (inherited from uri_list) (encoding:string): Value: uri C equivalent roughly: for storing id name: char *, as pointer: void *
- id (encoding:string): Value: tetrahedron C equivalent roughly: for storing id name: char *, as pointer: void *
- interface (inherited from root) (encoding:string): Value: base_interface C equivalent roughly: for storing id name: char *, as pointer: void *
- list_length (encoding:int): Value: 4 C equivalent: 32bit int
- name (inherited from root) (encoding:string): Value: Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- objtype (inherited from string_list) (encoding:string): Value: type Examples of values: "op", "class", "type".
- parents (encoding:list): Value: ['coord_id_list_length'] C equivalent: char *[], void *[]
- specification (inherited from root) (encoding:string): Value: atlas Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- stamp (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was
changed in this object. Any scheme is ok as long as newer numbers
are bigger than older stamps. For example, seconds since Jan 1st,
1970 or total game cycles would both be valid.
- stamp_inherit (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was changed in some object that inherits from this.
- summary (encoding:string): Value:
Pointers to tetrahedron points
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Bach version:
{
children: [],
id: "tetrahedron",
list_length: 4,
parents: ["coord_id_list_length"],
summary: "Pointers to tetrahedron points"
}
polyline
Attribute list:
- added_attributes (inherited from list) (encoding:list): Value: [] C equivalent: char *[], void *[]
- children (encoding:list): Value: [] C equivalent: char *[], void *[]
- description (encoding:string): Value:
see maps/semantic_maps.pdf for more info.
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- element_type (inherited from uri_list) (encoding:string): Value: uri C equivalent roughly: for storing id name: char *, as pointer: void *
- id (encoding:string): Value: polyline C equivalent roughly: for storing id name: char *, as pointer: void *
- interface (inherited from root) (encoding:string): Value: base_interface C equivalent roughly: for storing id name: char *, as pointer: void *
- name (inherited from root) (encoding:string): Value: Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- objtype (inherited from string_list) (encoding:string): Value: type Examples of values: "op", "class", "type".
- parents (encoding:list): Value: ['coord_id_list'] C equivalent: char *[], void *[]
- specification (inherited from root) (encoding:string): Value: atlas Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- stamp (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was
changed in this object. Any scheme is ok as long as newer numbers
are bigger than older stamps. For example, seconds since Jan 1st,
1970 or total game cycles would both be valid.
- stamp_inherit (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was changed in some object that inherits from this.
- summary (encoding:string): Value:
Ids of points that polyline consists of
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Bach version:
{
children: [],
description: "see maps/semantic_maps.pdf for more info.",
id: "polyline",
parents: ["coord_id_list"],
summary: "Ids of points that polyline consists of"
}
glue
Attribute list:
- added_attributes (inherited from list) (encoding:list): Value: [] C equivalent: char *[], void *[]
- children (encoding:list): Value: [] C equivalent: char *[], void *[]
- description (encoding:string): Value:
**not written yet**
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- element_type (inherited from uri_list) (encoding:string): Value: uri C equivalent roughly: for storing id name: char *, as pointer: void *
- id (encoding:string): Value: glue C equivalent roughly: for storing id name: char *, as pointer: void *
- interface (inherited from root) (encoding:string): Value: base_interface C equivalent roughly: for storing id name: char *, as pointer: void *
- name (inherited from root) (encoding:string): Value: Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- objtype (inherited from string_list) (encoding:string): Value: type Examples of values: "op", "class", "type".
- parents (encoding:list): Value: ['id_list'] C equivalent: char *[], void *[]
- specification (inherited from root) (encoding:string): Value: atlas Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- stamp (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was
changed in this object. Any scheme is ok as long as newer numbers
are bigger than older stamps. For example, seconds since Jan 1st,
1970 or total game cycles would both be valid.
- stamp_inherit (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was changed in some object that inherits from this.
- summary (encoding:string): Value:
Ids of glue objects that glue this to other objects
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Bach version:
{
children: [],
description: "**not written yet**",
id: "glue",
parents: ["id_list"],
summary: "Ids of glue objects that glue this to other objects"
}
media_roots
Attribute list:
- added_attributes (inherited from list) (encoding:list): Value: [] C equivalent: char *[], void *[]
- children (encoding:list): Value: [] C equivalent: char *[], void *[]
- description (encoding:string): Value:
List ids of root_media_info: can be on same server or at different server:
see root_object attribute definition for more info
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- element_type (inherited from uri_list) (encoding:string): Value: uri C equivalent roughly: for storing id name: char *, as pointer: void *
- id (encoding:string): Value: media_roots C equivalent roughly: for storing id name: char *, as pointer: void *
- interface (inherited from root) (encoding:string): Value: base_interface C equivalent roughly: for storing id name: char *, as pointer: void *
- name (inherited from root) (encoding:string): Value: Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- objtype (inherited from string_list) (encoding:string): Value: type Examples of values: "op", "class", "type".
- parents (encoding:list): Value: ['id_list'] C equivalent: char *[], void *[]
- specification (inherited from root) (encoding:string): Value: atlas Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- stamp (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was
changed in this object. Any scheme is ok as long as newer numbers
are bigger than older stamps. For example, seconds since Jan 1st,
1970 or total game cycles would both be valid.
- stamp_inherit (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was changed in some object that inherits from this.
- summary (encoding:string): Value:
List of media servers basically
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Bach version:
{
children: [],
description: "List ids of root_media_info: can be on same server or at different server:
see root_object attribute definition for more info",
id: "media_roots",
parents: ["id_list"],
summary: "List of media servers basically"
}
attribute_order
Attribute list:
- added_attributes (inherited from list) (encoding:list): Value: [] C equivalent: char *[], void *[]
- children (encoding:list): Value: [] C equivalent: char *[], void *[]
- description (inherited from uri_list) (encoding:string): Value:
C equivalent: char *[], void *[]
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- element_type (inherited from uri_list) (encoding:string): Value: uri C equivalent roughly: for storing id name: char *, as pointer: void *
- id (encoding:string): Value: attribute_order C equivalent roughly: for storing id name: char *, as pointer: void *
- interface (inherited from root) (encoding:string): Value: base_interface C equivalent roughly: for storing id name: char *, as pointer: void *
- name (inherited from root) (encoding:string): Value: Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- objtype (inherited from string_list) (encoding:string): Value: type Examples of values: "op", "class", "type".
- parents (encoding:list): Value: ['id_list'] C equivalent: char *[], void *[]
- specification (inherited from root) (encoding:string): Value: atlas Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- stamp (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was
changed in this object. Any scheme is ok as long as newer numbers
are bigger than older stamps. For example, seconds since Jan 1st,
1970 or total game cycles would both be valid.
- stamp_inherit (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was changed in some object that inherits from this.
- summary (encoding:string): Value:
order attributes was specified
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Bach version:
{
children: [],
id: "attribute_order",
parents: ["id_list"],
summary: "order attributes was specified"
}
int_list
Attribute list:
- added_attributes (inherited from list) (encoding:list): Value: [] C equivalent: char *[], void *[]
- children (encoding:list): Value: ['int_list_length'] C equivalent: char *[], void *[]
- description (encoding:string): Value:
C equivalent: int []
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- element_type (encoding:string): Value: int C equivalent roughly: for storing id name: char *, as pointer: void *
- id (encoding:string): Value: int_list C equivalent roughly: for storing id name: char *, as pointer: void *
- interface (inherited from root) (encoding:string): Value: base_interface C equivalent roughly: for storing id name: char *, as pointer: void *
- name (inherited from root) (encoding:string): Value: Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- objtype (encoding:string): Value: type Examples of values: "op", "class", "type".
- parents (encoding:list): Value: ['list'] C equivalent: char *[], void *[]
- specification (inherited from root) (encoding:string): Value: atlas Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- stamp (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was
changed in this object. Any scheme is ok as long as newer numbers
are bigger than older stamps. For example, seconds since Jan 1st,
1970 or total game cycles would both be valid.
- stamp_inherit (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was changed in some object that inherits from this.
- summary (encoding:string): Value:
List of integers
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Bach version:
{
children: ["int_list_length"],
description: "C equivalent: int []",
element_type: "int",
id: "int_list",
objtype: "type",
parents: ["list"],
summary: "List of integers"
}
int_list_length
Attribute list:
- added_attributes (inherited from list) (encoding:list): Value: [] C equivalent: char *[], void *[]
- children (encoding:list): Value: [] C equivalent: char *[], void *[]
- description (encoding:string): Value:
Inherit required object from this and set length attribute to suitable value.
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- element_type (inherited from int_list) (encoding:string): Value: int C equivalent roughly: for storing id name: char *, as pointer: void *
- id (encoding:string): Value: int_list_length C equivalent roughly: for storing id name: char *, as pointer: void *
- interface (inherited from root) (encoding:string): Value: base_interface C equivalent roughly: for storing id name: char *, as pointer: void *
- list_length (encoding:int): Value: 0 C equivalent: 32bit int
- name (inherited from root) (encoding:string): Value: Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- objtype (encoding:string): Value: meta Examples of values: "op", "class", "type".
- parents (encoding:list): Value: ['int_list'] C equivalent: char *[], void *[]
- specification (inherited from root) (encoding:string): Value: atlas Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- stamp (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was
changed in this object. Any scheme is ok as long as newer numbers
are bigger than older stamps. For example, seconds since Jan 1st,
1970 or total game cycles would both be valid.
- stamp_inherit (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was changed in some object that inherits from this.
- summary (encoding:string): Value:
List of ints with constant length
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Bach version:
{
children: [],
description: "Inherit required object from this and set length attribute to suitable value.",
id: "int_list_length",
list_length: 0,
objtype: "meta",
parents: ["int_list"],
summary: "List of ints with constant length"
}
float_list
Attribute list:
- added_attributes (inherited from list) (encoding:list): Value: [] C equivalent: char *[], void *[]
- children (encoding:list): Value: ['float_list_length'] C equivalent: char *[], void *[]
- description (encoding:string): Value:
C equivalent: double []
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- element_type (encoding:string): Value: float C equivalent roughly: for storing id name: char *, as pointer: void *
- id (encoding:string): Value: float_list C equivalent roughly: for storing id name: char *, as pointer: void *
- interface (inherited from root) (encoding:string): Value: base_interface C equivalent roughly: for storing id name: char *, as pointer: void *
- name (inherited from root) (encoding:string): Value: Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- objtype (encoding:string): Value: type Examples of values: "op", "class", "type".
- parents (encoding:list): Value: ['list'] C equivalent: char *[], void *[]
- specification (inherited from root) (encoding:string): Value: atlas Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- stamp (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was
changed in this object. Any scheme is ok as long as newer numbers
are bigger than older stamps. For example, seconds since Jan 1st,
1970 or total game cycles would both be valid.
- stamp_inherit (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was changed in some object that inherits from this.
- summary (encoding:string): Value:
List of floats
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Bach version:
{
children: ["float_list_length"],
description: "C equivalent: double []",
element_type: "float",
id: "float_list",
objtype: "type",
parents: ["list"],
summary: "List of floats"
}
float_list_length
Attribute list:
- added_attributes (inherited from list) (encoding:list): Value: [] C equivalent: char *[], void *[]
- children (encoding:list): Value: ['float_list3'] C equivalent: char *[], void *[]
- description (encoding:string): Value:
Inherit required object from this and set length attribute to suitable value.
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- element_type (inherited from float_list) (encoding:string): Value: float C equivalent roughly: for storing id name: char *, as pointer: void *
- id (encoding:string): Value: float_list_length C equivalent roughly: for storing id name: char *, as pointer: void *
- interface (inherited from root) (encoding:string): Value: base_interface C equivalent roughly: for storing id name: char *, as pointer: void *
- list_length (encoding:int): Value: 0 C equivalent: 32bit int
- name (inherited from root) (encoding:string): Value: Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- objtype (encoding:string): Value: meta Examples of values: "op", "class", "type".
- parents (encoding:list): Value: ['float_list'] C equivalent: char *[], void *[]
- specification (inherited from root) (encoding:string): Value: atlas Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- stamp (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was
changed in this object. Any scheme is ok as long as newer numbers
are bigger than older stamps. For example, seconds since Jan 1st,
1970 or total game cycles would both be valid.
- stamp_inherit (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was changed in some object that inherits from this.
- summary (encoding:string): Value:
List of floats with constant length
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Bach version:
{
children: ["float_list3"],
description: "Inherit required object from this and set length attribute to suitable value.",
id: "float_list_length",
list_length: 0,
objtype: "meta",
parents: ["float_list"],
summary: "List of floats with constant length"
}
float_list3
Attribute list:
- added_attributes (inherited from list) (encoding:list): Value: [] C equivalent: char *[], void *[]
- children (encoding:list): Value: ['pos', 'velocity'] C equivalent: char *[], void *[]
- description (encoding:string): Value:
Used in 3D world for various things
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- element_type (inherited from float_list) (encoding:string): Value: float C equivalent roughly: for storing id name: char *, as pointer: void *
- id (encoding:string): Value: float_list3 C equivalent roughly: for storing id name: char *, as pointer: void *
- interface (inherited from root) (encoding:string): Value: base_interface C equivalent roughly: for storing id name: char *, as pointer: void *
- list_length (encoding:int): Value: 3 C equivalent: 32bit int
- name (inherited from root) (encoding:string): Value: Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- objtype (inherited from float_list_length) (encoding:string): Value: meta Examples of values: "op", "class", "type".
- parents (encoding:list): Value: ['float_list_length'] C equivalent: char *[], void *[]
- specification (inherited from root) (encoding:string): Value: atlas Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- stamp (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was
changed in this object. Any scheme is ok as long as newer numbers
are bigger than older stamps. For example, seconds since Jan 1st,
1970 or total game cycles would both be valid.
- stamp_inherit (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was changed in some object that inherits from this.
- summary (encoding:string): Value:
Float list with length of 3
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Bach version:
{
children: ["pos", "velocity"],
description: "Used in 3D world for various things",
id: "float_list3",
list_length: 3,
parents: ["float_list_length"],
summary: "Float list with length of 3"
}
pos
Attribute list:
- added_attributes (inherited from list) (encoding:list): Value: [] C equivalent: char *[], void *[]
- children (encoding:list): Value: [] C equivalent: char *[], void *[]
- description (inherited from float_list3) (encoding:string): Value:
Used in 3D world for various things
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- element_type (inherited from float_list) (encoding:string): Value: float C equivalent roughly: for storing id name: char *, as pointer: void *
- id (encoding:string): Value: pos C equivalent roughly: for storing id name: char *, as pointer: void *
- interface (inherited from root) (encoding:string): Value: base_interface C equivalent roughly: for storing id name: char *, as pointer: void *
- list_length (inherited from float_list3) (encoding:int): Value: 3 C equivalent: 32bit int
- name (encoding:string): Value: position Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- objtype (encoding:string): Value: type Examples of values: "op", "class", "type".
- parents (encoding:list): Value: ['float_list3'] C equivalent: char *[], void *[]
- specification (inherited from root) (encoding:string): Value: atlas Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- stamp (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was
changed in this object. Any scheme is ok as long as newer numbers
are bigger than older stamps. For example, seconds since Jan 1st,
1970 or total game cycles would both be valid.
- stamp_inherit (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was changed in some object that inherits from this.
- summary (encoding:string): Value:
Position coordinates, usually world is 3D
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Bach version:
{
children: [],
id: "pos",
name: "position",
objtype: "type",
parents: ["float_list3"],
summary: "Position coordinates, usually world is 3D"
}
velocity
Attribute list:
- added_attributes (inherited from list) (encoding:list): Value: [] C equivalent: char *[], void *[]
- children (encoding:list): Value: [] C equivalent: char *[], void *[]
- description (inherited from float_list3) (encoding:string): Value:
Used in 3D world for various things
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- element_type (inherited from float_list) (encoding:string): Value: float C equivalent roughly: for storing id name: char *, as pointer: void *
- id (encoding:string): Value: velocity C equivalent roughly: for storing id name: char *, as pointer: void *
- interface (inherited from root) (encoding:string): Value: base_interface C equivalent roughly: for storing id name: char *, as pointer: void *
- list_length (encoding:int): Value: 3 C equivalent: 32bit int
- name (inherited from root) (encoding:string): Value: Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- objtype (encoding:string): Value: type Examples of values: "op", "class", "type".
- parents (encoding:list): Value: ['float_list3'] C equivalent: char *[], void *[]
- specification (inherited from root) (encoding:string): Value: atlas Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- stamp (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was
changed in this object. Any scheme is ok as long as newer numbers
are bigger than older stamps. For example, seconds since Jan 1st,
1970 or total game cycles would both be valid.
- stamp_inherit (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was changed in some object that inherits from this.
- summary (encoding:string): Value:
Velocity object is moving, usually world is 3D
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Bach version:
{
children: [],
id: "velocity",
list_length: 3,
objtype: "type",
parents: ["float_list3"],
summary: "Velocity object is moving, usually world is 3D"
}
rotation
Attribute list:
- added_attributes (inherited from list) (encoding:list): Value: [] C equivalent: char *[], void *[]
- children (encoding:list): Value: [] C equivalent: char *[], void *[]
- description (encoding:string): Value:
From forge/libs/wfmath/wfmath/rotmatrix.h:
Elements of this class represent rotation matrices. The NxN dimensional
rotation matrices form a group called O(N), the orthogonal
matrices. They satisfy the following condition:
A general N dimensional matrix of this type has N(N-1)/2 degrees of freedom.
This gives one rotation angle in 2D, the three Euler angles in 3D, etc.
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- element_type (encoding:string): Value: float_list3 C equivalent roughly: for storing id name: char *, as pointer: void *
- id (encoding:string): Value: rotation C equivalent roughly: for storing id name: char *, as pointer: void *
- interface (inherited from root) (encoding:string): Value: base_interface C equivalent roughly: for storing id name: char *, as pointer: void *
- list_length (encoding:int): Value: 3 C equivalent: 32bit int
- name (inherited from root) (encoding:string): Value: Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- objtype (encoding:string): Value: type Examples of values: "op", "class", "type".
- parents (encoding:list): Value: ['list'] C equivalent: char *[], void *[]
- specification (inherited from root) (encoding:string): Value: atlas Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- stamp (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was
changed in this object. Any scheme is ok as long as newer numbers
are bigger than older stamps. For example, seconds since Jan 1st,
1970 or total game cycles would both be valid.
- stamp_inherit (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was changed in some object that inherits from this.
- summary (encoding:string): Value:
Rotation matrix in 3D world
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Bach version:
{
children: [],
description: "From forge/libs/wfmath/wfmath/rotmatrix.h:
Elements of this class represent rotation matrices. The NxN dimensional
rotation matrices form a group called O(N), the orthogonal
matrices. They satisfy the following condition:
<p>
A general N dimensional matrix of this type has N(N-1)/2 degrees of freedom.
This gives one rotation angle in 2D, the three Euler angles in 3D, etc.
",
element_type: "float_list3",
id: "rotation",
list_length: 3,
objtype: "type",
parents: ["list"],
summary: "Rotation matrix in 3D world"
}
args_source
Attribute list:
- added_attributes (inherited from list) (encoding:list): Value: [] C equivalent: char *[], void *[]
- children (encoding:list): Value: [] C equivalent: char *[], void *[]
- description (inherited from list) (encoding:string): Value:
C equivalent: void *[]
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- id (encoding:string): Value: args_source C equivalent roughly: for storing id name: char *, as pointer: void *
- interface (inherited from root) (encoding:string): Value: base_interface C equivalent roughly: for storing id name: char *, as pointer: void *
- name (inherited from root) (encoding:string): Value: Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- objtype (encoding:string): Value: type Examples of values: "op", "class", "type".
- parents (encoding:list): Value: ['list'] C equivalent: char *[], void *[]
- specification (inherited from root) (encoding:string): Value: atlas Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- stamp (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was
changed in this object. Any scheme is ok as long as newer numbers
are bigger than older stamps. For example, seconds since Jan 1st,
1970 or total game cycles would both be valid.
- stamp_inherit (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was changed in some object that inherits from this.
- summary (encoding:string): Value:
List of source arguments (for combine and similar operations)
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Bach version:
{
children: [],
id: "args_source",
objtype: "type",
parents: ["list"],
summary: "List of source arguments (for combine and similar operations)"
}
args_destination
Attribute list:
- added_attributes (inherited from list) (encoding:list): Value: [] C equivalent: char *[], void *[]
- children (encoding:list): Value: [] C equivalent: char *[], void *[]
- description (inherited from list) (encoding:string): Value:
C equivalent: void *[]
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- id (encoding:string): Value: args_destination C equivalent roughly: for storing id name: char *, as pointer: void *
- interface (inherited from root) (encoding:string): Value: base_interface C equivalent roughly: for storing id name: char *, as pointer: void *
- name (inherited from root) (encoding:string): Value: Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- objtype (encoding:string): Value: type Examples of values: "op", "class", "type".
- parents (encoding:list): Value: ['list'] C equivalent: char *[], void *[]
- specification (inherited from root) (encoding:string): Value: atlas Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- stamp (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was
changed in this object. Any scheme is ok as long as newer numbers
are bigger than older stamps. For example, seconds since Jan 1st,
1970 or total game cycles would both be valid.
- stamp_inherit (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was changed in some object that inherits from this.
- summary (encoding:string): Value:
List of destination arguments (for divide and similar operations)
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Bach version:
{
children: [],
id: "args_destination",
objtype: "type",
parents: ["list"],
summary: "List of destination arguments (for divide and similar operations)"
}
arg_names
Attribute list:
- added_attributes (inherited from list) (encoding:list): Value: [] C equivalent: char *[], void *[]
- children (encoding:list): Value: [] C equivalent: char *[], void *[]
- description (inherited from list) (encoding:string): Value:
C equivalent: void *[]
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- id (encoding:string): Value: arg_names C equivalent roughly: for storing id name: char *, as pointer: void *
- interface (inherited from root) (encoding:string): Value: base_interface C equivalent roughly: for storing id name: char *, as pointer: void *
- name (inherited from root) (encoding:string): Value: Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- objtype (encoding:string): Value: type Examples of values: "op", "class", "type".
- parents (encoding:list): Value: ['list'] C equivalent: char *[], void *[]
- specification (inherited from root) (encoding:string): Value: atlas Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- stamp (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was
changed in this object. Any scheme is ok as long as newer numbers
are bigger than older stamps. For example, seconds since Jan 1st,
1970 or total game cycles would both be valid.
- stamp_inherit (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was changed in some object that inherits from this.
- summary (encoding:string): Value:
List argument attribute names
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Bach version:
{
children: [],
id: "arg_names",
objtype: "type",
parents: ["list"],
summary: "List argument attribute names"
}
example
Attribute list:
- added_attributes (inherited from list) (encoding:list): Value: [] C equivalent: char *[], void *[]
- children (encoding:list): Value: [] C equivalent: char *[], void *[]
- description (inherited from list) (encoding:string): Value:
C equivalent: void *[]
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- id (encoding:string): Value: example C equivalent roughly: for storing id name: char *, as pointer: void *
- interface (inherited from root) (encoding:string): Value: base_interface C equivalent roughly: for storing id name: char *, as pointer: void *
- name (inherited from root) (encoding:string): Value: Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- objtype (encoding:string): Value: type Examples of values: "op", "class", "type".
- parents (encoding:list): Value: ['list'] C equivalent: char *[], void *[]
- specification (inherited from root) (encoding:string): Value: atlas Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- stamp (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was
changed in this object. Any scheme is ok as long as newer numbers
are bigger than older stamps. For example, seconds since Jan 1st,
1970 or total game cycles would both be valid.
- stamp_inherit (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was changed in some object that inherits from this.
- summary (encoding:string): Value:
Gives some examples usage
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Bach version:
{
children: [],
id: "example",
objtype: "type",
parents: ["list"],
summary: "Gives some examples usage"
}
triangle_list
Attribute list:
- added_attributes (inherited from list) (encoding:list): Value: [] C equivalent: char *[], void *[]
- children (encoding:list): Value: ['area'] C equivalent: char *[], void *[]
- description (inherited from list) (encoding:string): Value:
C equivalent: void *[]
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- element_type (encoding:string): Value: triangle C equivalent roughly: for storing id name: char *, as pointer: void *
- id (encoding:string): Value: triangle_list C equivalent roughly: for storing id name: char *, as pointer: void *
- interface (inherited from root) (encoding:string): Value: base_interface C equivalent roughly: for storing id name: char *, as pointer: void *
- name (inherited from root) (encoding:string): Value: Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- objtype (encoding:string): Value: type Examples of values: "op", "class", "type".
- parents (encoding:list): Value: ['list'] C equivalent: char *[], void *[]
- specification (inherited from root) (encoding:string): Value: atlas Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- stamp (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was
changed in this object. Any scheme is ok as long as newer numbers
are bigger than older stamps. For example, seconds since Jan 1st,
1970 or total game cycles would both be valid.
- stamp_inherit (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was changed in some object that inherits from this.
- summary (encoding:string): Value:
List of triangles
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Bach version:
{
children: ["area"],
element_type: "triangle",
id: "triangle_list",
objtype: "type",
parents: ["list"],
summary: "List of triangles"
}
area
Attribute list:
- added_attributes (inherited from list) (encoding:list): Value: [] C equivalent: char *[], void *[]
- children (encoding:list): Value: [] C equivalent: char *[], void *[]
- description (encoding:string): Value:
see maps/semantic_maps.pdf for more info.
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- element_type (inherited from triangle_list) (encoding:string): Value: triangle C equivalent roughly: for storing id name: char *, as pointer: void *
- id (encoding:string): Value: area C equivalent roughly: for storing id name: char *, as pointer: void *
- interface (inherited from root) (encoding:string): Value: base_interface C equivalent roughly: for storing id name: char *, as pointer: void *
- name (inherited from root) (encoding:string): Value: Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- objtype (inherited from triangle_list) (encoding:string): Value: type Examples of values: "op", "class", "type".
- parents (encoding:list): Value: ['triangle_list'] C equivalent: char *[], void *[]
- specification (inherited from root) (encoding:string): Value: atlas Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- stamp (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was
changed in this object. Any scheme is ok as long as newer numbers
are bigger than older stamps. For example, seconds since Jan 1st,
1970 or total game cycles would both be valid.
- stamp_inherit (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was changed in some object that inherits from this.
- summary (encoding:string): Value:
triangles area consist of
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Bach version:
{
children: [],
description: "see maps/semantic_maps.pdf for more info.",
id: "area",
parents: ["triangle_list"],
summary: "triangles area consist of"
}
tetrahedron_list
Attribute list:
- added_attributes (inherited from list) (encoding:list): Value: [] C equivalent: char *[], void *[]
- children (encoding:list): Value: ['volume'] C equivalent: char *[], void *[]
- description (inherited from list) (encoding:string): Value:
C equivalent: void *[]
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- element_type (encoding:string): Value: tetrahedron C equivalent roughly: for storing id name: char *, as pointer: void *
- id (encoding:string): Value: tetrahedron_list C equivalent roughly: for storing id name: char *, as pointer: void *
- interface (inherited from root) (encoding:string): Value: base_interface C equivalent roughly: for storing id name: char *, as pointer: void *
- name (inherited from root) (encoding:string): Value: Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- objtype (encoding:string): Value: type Examples of values: "op", "class", "type".
- parents (encoding:list): Value: ['list'] C equivalent: char *[], void *[]
- specification (inherited from root) (encoding:string): Value: atlas Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- stamp (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was
changed in this object. Any scheme is ok as long as newer numbers
are bigger than older stamps. For example, seconds since Jan 1st,
1970 or total game cycles would both be valid.
- stamp_inherit (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was changed in some object that inherits from this.
- summary (encoding:string): Value:
List of tetrahedrons
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Bach version:
{
children: ["volume"],
element_type: "tetrahedron",
id: "tetrahedron_list",
objtype: "type",
parents: ["list"],
summary: "List of tetrahedrons"
}
volume
Attribute list:
- added_attributes (inherited from list) (encoding:list): Value: [] C equivalent: char *[], void *[]
- children (encoding:list): Value: [] C equivalent: char *[], void *[]
- description (encoding:string): Value:
see maps/semantic_maps.pdf for more info.
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- element_type (inherited from tetrahedron_list) (encoding:string): Value: tetrahedron C equivalent roughly: for storing id name: char *, as pointer: void *
- id (encoding:string): Value: volume C equivalent roughly: for storing id name: char *, as pointer: void *
- interface (inherited from root) (encoding:string): Value: base_interface C equivalent roughly: for storing id name: char *, as pointer: void *
- name (inherited from root) (encoding:string): Value: Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- objtype (inherited from tetrahedron_list) (encoding:string): Value: type Examples of values: "op", "class", "type".
- parents (encoding:list): Value: ['tetrahedron_list'] C equivalent: char *[], void *[]
- specification (inherited from root) (encoding:string): Value: atlas Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- stamp (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was
changed in this object. Any scheme is ok as long as newer numbers
are bigger than older stamps. For example, seconds since Jan 1st,
1970 or total game cycles would both be valid.
- stamp_inherit (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was changed in some object that inherits from this.
- summary (encoding:string): Value:
tetrahedrons volume consist of
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Bach version:
{
children: [],
description: "see maps/semantic_maps.pdf for more info.",
id: "volume",
parents: ["tetrahedron_list"],
summary: "tetrahedrons volume consist of"
}
glue_ids
Attribute list:
- added_attributes (inherited from list) (encoding:list): Value: [] C equivalent: char *[], void *[]
- children (encoding:list): Value: [] C equivalent: char *[], void *[]
- description (encoding:string): Value:
See glue_geometry for more info
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- id (encoding:string): Value: glue_ids C equivalent roughly: for storing id name: char *, as pointer: void *
- interface (inherited from root) (encoding:string): Value: base_interface C equivalent roughly: for storing id name: char *, as pointer: void *
- name (inherited from root) (encoding:string): Value: Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- objtype (inherited from list) (encoding:string): Value: data_type Examples of values: "op", "class", "type".
- parents (encoding:list): Value: ['list'] C equivalent: char *[], void *[]
- specification (inherited from root) (encoding:string): Value: atlas Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- stamp (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was
changed in this object. Any scheme is ok as long as newer numbers
are bigger than older stamps. For example, seconds since Jan 1st,
1970 or total game cycles would both be valid.
- stamp_inherit (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was changed in some object that inherits from this.
- summary (encoding:string): Value:
List ids that glue objects together
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Bach version:
{
children: [],
description: "See glue_geometry for more info",
id: "glue_ids",
parents: ["list"],
summary: "List ids that glue objects together"
}
pos_list
Attribute list:
- added_attributes (inherited from list) (encoding:list): Value: [] C equivalent: char *[], void *[]
- children (encoding:list): Value: ['p'] C equivalent: char *[], void *[]
- description (inherited from list) (encoding:string): Value:
C equivalent: void *[]
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- element_type (encoding:string): Value: pos C equivalent roughly: for storing id name: char *, as pointer: void *
- id (encoding:string): Value: pos_list C equivalent roughly: for storing id name: char *, as pointer: void *
- interface (inherited from root) (encoding:string): Value: base_interface C equivalent roughly: for storing id name: char *, as pointer: void *
- name (inherited from root) (encoding:string): Value: Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- objtype (encoding:string): Value: type Examples of values: "op", "class", "type".
- parents (encoding:list): Value: ['list'] C equivalent: char *[], void *[]
- specification (inherited from root) (encoding:string): Value: atlas Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- stamp (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was
changed in this object. Any scheme is ok as long as newer numbers
are bigger than older stamps. For example, seconds since Jan 1st,
1970 or total game cycles would both be valid.
- stamp_inherit (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was changed in some object that inherits from this.
- summary (encoding:string): Value:
list of coordinates
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Bach version:
{
children: ["p"],
element_type: "pos",
id: "pos_list",
objtype: "type",
parents: ["list"],
summary: "list of coordinates"
}
p
Attribute list:
- added_attributes (inherited from list) (encoding:list): Value: [] C equivalent: char *[], void *[]
- children (encoding:list): Value: [] C equivalent: char *[], void *[]
- description (inherited from list) (encoding:string): Value:
C equivalent: void *[]
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- element_type (inherited from pos_list) (encoding:string): Value: pos C equivalent roughly: for storing id name: char *, as pointer: void *
- id (encoding:string): Value: p C equivalent roughly: for storing id name: char *, as pointer: void *
- interface (inherited from root) (encoding:string): Value: base_interface C equivalent roughly: for storing id name: char *, as pointer: void *
- name (inherited from root) (encoding:string): Value: Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- objtype (inherited from pos_list) (encoding:string): Value: type Examples of values: "op", "class", "type".
- parents (encoding:list): Value: ['pos_list'] C equivalent: char *[], void *[]
- specification (inherited from root) (encoding:string): Value: atlas Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- stamp (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was
changed in this object. Any scheme is ok as long as newer numbers
are bigger than older stamps. For example, seconds since Jan 1st,
1970 or total game cycles would both be valid.
- stamp_inherit (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was changed in some object that inherits from this.
- summary (inherited from pos_list) (encoding:string): Value:
list of coordinates
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Bach version:
{
children: [],
id: "p",
parents: ["pos_list"]
}
e_list
Attribute list:
- added_attributes (inherited from list) (encoding:list): Value: [] C equivalent: char *[], void *[]
- children (encoding:list): Value: [] C equivalent: char *[], void *[]
- description (inherited from list) (encoding:string): Value:
C equivalent: void *[]
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- id (encoding:string): Value: e_list C equivalent roughly: for storing id name: char *, as pointer: void *
- interface (inherited from root) (encoding:string): Value: base_interface C equivalent roughly: for storing id name: char *, as pointer: void *
- name (inherited from root) (encoding:string): Value: Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- objtype (encoding:string): Value: type Examples of values: "op", "class", "type".
- parents (encoding:list): Value: ['list'] C equivalent: char *[], void *[]
- specification (inherited from root) (encoding:string): Value: atlas Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- stamp (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was
changed in this object. Any scheme is ok as long as newer numbers
are bigger than older stamps. For example, seconds since Jan 1st,
1970 or total game cycles would both be valid.
- stamp_inherit (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was changed in some object that inherits from this.
- summary (encoding:string): Value:
Root type for all list type example attributes
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Bach version:
{
children: [],
id: "e_list",
objtype: "type",
parents: ["list"],
summary: "Root type for all list type example attributes"
}
map
Attribute list:
- added_attributes (encoding:list): Value: [] C equivalent: char *[], void *[]
- children (encoding:list): Value: ['arg', 'op', 'specification_file'] C equivalent: char *[], void *[]
- description (encoding:string): Value:
C equivalent: struct map {char *;void *}; map*
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- id (encoding:string): Value: map C equivalent roughly: for storing id name: char *, as pointer: void *
- interface (inherited from root) (encoding:string): Value: base_interface C equivalent roughly: for storing id name: char *, as pointer: void *
- name (encoding:string): Value: mapping Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- objtype (encoding:string): Value: data_type Examples of values: "op", "class", "type".
- parents (encoding:list): Value: ['root_type'] C equivalent: char *[], void *[]
- specification (inherited from root) (encoding:string): Value: atlas Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- stamp (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was
changed in this object. Any scheme is ok as long as newer numbers
are bigger than older stamps. For example, seconds since Jan 1st,
1970 or total game cycles would both be valid.
- stamp_inherit (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was changed in some object that inherits from this.
- summary (encoding:string): Value:
Mapping between string key and value object
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Bach version:
{
added_attributes: [],
children: ["arg", "op", "specification_file"],
description: "C equivalent: struct map {char *;void *}; map*",
id: "map",
name: "mapping",
objtype: "data_type",
parents: ["root_type"],
summary: "Mapping between string key and value object"
}
arg
Attribute list:
- added_attributes (inherited from map) (encoding:list): Value: [] C equivalent: char *[], void *[]
- children (encoding:list): Value: [] C equivalent: char *[], void *[]
- description (inherited from map) (encoding:string): Value:
C equivalent: struct map {char *;void *}; map*
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- id (encoding:string): Value: arg C equivalent roughly: for storing id name: char *, as pointer: void *
- interface (inherited from root) (encoding:string): Value: base_interface C equivalent roughly: for storing id name: char *, as pointer: void *
- name (inherited from map) (encoding:string): Value: mapping Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- objtype (encoding:string): Value: type Examples of values: "op", "class", "type".
- parents (encoding:list): Value: ['map'] C equivalent: char *[], void *[]
- specification (inherited from root) (encoding:string): Value: atlas Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- stamp (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was
changed in this object. Any scheme is ok as long as newer numbers
are bigger than older stamps. For example, seconds since Jan 1st,
1970 or total game cycles would both be valid.
- stamp_inherit (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was changed in some object that inherits from this.
- summary (encoding:string): Value:
Argument for operation
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Bach version:
{
children: [],
id: "arg",
objtype: "type",
parents: ["map"],
summary: "Argument for operation"
}
op
Attribute list:
- added_attributes (inherited from map) (encoding:list): Value: [] C equivalent: char *[], void *[]
- children (encoding:list): Value: [] C equivalent: char *[], void *[]
- description (inherited from map) (encoding:string): Value:
C equivalent: struct map {char *;void *}; map*
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- id (encoding:string): Value: op C equivalent roughly: for storing id name: char *, as pointer: void *
- interface (inherited from root) (encoding:string): Value: base_interface C equivalent roughly: for storing id name: char *, as pointer: void *
- name (inherited from map) (encoding:string): Value: mapping Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- objtype (encoding:string): Value: type Examples of values: "op", "class", "type".
- parents (encoding:list): Value: ['map'] C equivalent: char *[], void *[]
- specification (inherited from root) (encoding:string): Value: atlas Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- stamp (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was
changed in this object. Any scheme is ok as long as newer numbers
are bigger than older stamps. For example, seconds since Jan 1st,
1970 or total game cycles would both be valid.
- stamp_inherit (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was changed in some object that inherits from this.
- summary (encoding:string): Value:
Opertion that caused error as argument to error operation
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Bach version:
{
children: [],
id: "op",
objtype: "type",
parents: ["map"],
summary: "Opertion that caused error as argument to error operation"
}
specification_file
Attribute list:
- added_attributes (inherited from map) (encoding:list): Value: [] C equivalent: char *[], void *[]
- children (encoding:list): Value: [] C equivalent: char *[], void *[]
- description (inherited from map) (encoding:string): Value:
C equivalent: struct map {char *;void *}; map*
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- id (encoding:string): Value: specification_file C equivalent roughly: for storing id name: char *, as pointer: void *
- interface (inherited from root) (encoding:string): Value: base_interface C equivalent roughly: for storing id name: char *, as pointer: void *
- name (inherited from map) (encoding:string): Value: mapping Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- objtype (encoding:string): Value: type Examples of values: "op", "class", "type".
- parents (encoding:list): Value: ['map'] C equivalent: char *[], void *[]
- specification (inherited from root) (encoding:string): Value: atlas Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
- stamp (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was
changed in this object. Any scheme is ok as long as newer numbers
are bigger than older stamps. For example, seconds since Jan 1st,
1970 or total game cycles would both be valid.
- stamp_inherit (inherited from root) (encoding:float): Value: 0.0 Value should be reflect when something was changed in some object that inherits from this.
- summary (encoding:string): Value:
various info about object and its specification file
Any character is allowed, including 8 bit control characters and '\0', C equivalent: {int len; char *data;}, C++: string
Bach version:
{
children: [],
id: "specification_file",
objtype: "type",
parents: ["map"],
summary: "various info about object and its specification file"
}
Aloril
Last modified: Sat Nov 13 15:46:56 EET 1999