CGScript - Coding guideline - Revision history

Nguyentrantri at 04:45, 18 October 2013

2013-10-18T04:45:58Z

← Older revision		Revision as of 04:45, 18 October 2013
Line 1:		Line 1:
	<accesscontrol>Main:MyGroup</accesscontrol>		<accesscontrol>Main:MyGroup</accesscontrol>
	= Objects =		= Objects =

	Objects in cgscript can be created by doing following this guideline.		Objects in cgscript can be created by doing following this guideline.
Line 9:		Line 9:

	For example, here is the absolute minimal class:		For example, here is the absolute minimal class:
			<pre><code>
	<~~code~~><~~pre~~>
	[Cg(OBJECT_TYPE_NAME, "write the documentation for the class here")]		[Cg(OBJECT_TYPE_NAME, "write the documentation for the class here")]
	internal class MyObjectCGO : CgScriptObject		internal class MyObjectCGO : CgScriptObject
	{		{
	private const string OBJECT_TYPE_NAME = "MyObject";		private const string OBJECT_TYPE_NAME = "MyObject";
Line 20:		Line 19:
	}		}
	}		}
	</~~pre~~></~~code~~>		</code></pre>
			The class must be internal or public, and non-abstract, and must not play with generics. The exception is that it may inherit from a generic baseclass (which then inherits from CgScriptObject), or implement a generic interface.
	The class must be internal or public, and non-abstract, and must not play with generics.
	The exception is that it may inherit from a generic baseclass (which then inherits from CgScriptObject), or implement a generic interface.

	=== Inheritance ===		=== Inheritance ===
Line 38:		Line 35:

	Example:		Example:
			<pre><code>
	<~~code~~><~~pre~~>
	[Cg("ContainsKey", "Determines whether the dictionary contains the specified key with type is a string.")]		[Cg("ContainsKey", "Determines whether the dictionary contains the specified key with type is a string.")]
	public bool ContainsKey([Cg("key", "Check with specific key")]string key)		public bool ContainsKey([Cg("key", "Check with specific key")]string key)
Line 45:		Line 41:
	return _dict.ContainsKey(key);		return _dict.ContainsKey(key);
	}		}
	</~~pre~~></~~code~~>		</code></pre>

	A function may be static, but from inside cgscript it will be exposed as a member function.		A function may be static, but from inside cgscript it will be exposed as a member function.

Line 54:		Line 49:

	Example:		Example:
			<pre><code>
	<~~code~~><~~pre~~>
	[Cg("Count", "Gets the number of key/value pairs contained in the dictionary.")]		[Cg("Count", "Gets the number of key/value pairs contained in the dictionary.")]
	public int Count		public int Count
Line 61:		Line 55:
	get { return _dict.Count; }		get { return _dict.Count; }
	}		}
	</~~pre~~></~~code~~>		</code></pre>

	The getter and setter may have different visibility, e.g. the getter may be public and the setter may be private. In that case, only the getter is accessible from CgScript.		The getter and setter may have different visibility, e.g. the getter may be public and the setter may be private. In that case, only the getter is accessible from CgScript.

	However, note that this alternative marking of the getter/setter may not do what you expect:		However, note that this alternative marking of the getter/setter may not do what you expect:
			<pre><code>
	<~~code~~><~~pre~~>
	public int Count		public int Count
	{		{
Line 73:		Line 65:
	get { return _dict.Count; }		get { return _dict.Count; }
	}		}
	</~~pre~~></~~code~~>		</code></pre>

	This will register the getter as a function (ie. from cgscript you would have to call o.Count() instead of o.Count)		This will register the getter as a function (ie. from cgscript you would have to call o.Count() instead of o.Count)

Line 84:		Line 75:

	Example:		Example:
	<~~code~~><~~pre~~>		<pre><code>
	public IConstant this[[Cg("key", "The key used to lookup the value.")] string key]		public IConstant this[[Cg("key", "The key used to lookup the value.")] string key]
	{		{
Line 93:		Line 84:
	set { _dict[key] = value; }		set { _dict[key] = value; }
	}		}
	</~~pre~~></~~code~~>		</code></pre>

	== Parameters ==		== Parameters ==

	CgScript objects support a number of types, that are automatically converted when calling the function and returning from the function:		CgScript objects support a number of types, that are automatically converted when calling the function and returning from the function:

	* Void (For return values only) - Constant.Empty is returned		*Void (For return values only) - Constant.Empty is returned
	* string - Automatically converted to and from a StringConstant		*string - Automatically converted to and from a StringConstant
	* double - Automatically converted to and from a NumberConstant		*double - Automatically converted to and from a NumberConstant
	* int - Automatically converted to and from a NumberConstant		*int - Automatically converted to and from a NumberConstant
	* bool - Automatically converted to and from a BooleanConstant		*bool - Automatically converted to and from a BooleanConstant
	* CGDateTime - Automatically converted to and from a DateTimeConstant		*CGDateTime - Automatically converted to and from a DateTimeConstant
	* Any type that implement IConstant - No conversion is done		*Any type that implement IConstant - No conversion is done

	Example:		Example:
	<~~code~~><~~pre~~>		<pre><code>
	[Cg("Add", "Adds the specified key and value to the dictionary with type of key is a string.")]		[Cg("Add", "Adds the specified key and value to the dictionary with type of key is a string.")]
	public bool Add([Cg("key", "Add with specific key")] string key,		public bool Add([Cg("key", "Add with specific key")] string key,
	[Cg("value", "Add with specific value")] IConstant constant)		[Cg("value", "Add with specific value")] IConstant constant)
	</~~pre~~></~~code~~>		</code></pre>

	There are some special parameter types, that must all NOT be marked with a CgAttribute:		There are some special parameter types, that must all NOT be marked with a CgAttribute:

	* <code>Interpreter</code> - If you require the interpreter to do something, you can get it by adding a Interpreter parameter. You are probably doing something wrong if you need this. If you do need it, then you should be aware that your object may be shared among several interpreters, and you should therefore NOT store the value anywhere.		*<code>Interpreter</code> - If you require the interpreter to do something, you can get it by adding a Interpreter parameter. You are probably doing something wrong if you need this. If you do need it, then you should be aware that your object may be shared among several interpreters, and you should therefore NOT store the value anywhere.
	* <code>IList<IConstant></code> - This is roughly equivalent to a normal C# method that takes a <code>"params object[]"</code>. This enables you to do advanced scenarios where the parameters from cgscript cannot be predicted. For obvious reasons there can be no other parameters marked with CgAttribute.		*<code>IList<IConstant></code> - This is roughly equivalent to a normal C# method that takes a <code>"params object[]"</code>. This enables you to do advanced scenarios where the parameters from cgscript cannot be predicted. For obvious reasons there can be no other parameters marked with CgAttribute.
	* other - If a parameter is not marked with a CgAttribute, it is presumed it is a IoC type that must be resolved when calling the function. This works for Constructors, Methods and Properties.		*other - If a parameter is not marked with a CgAttribute, it is presumed it is a IoC type that must be resolved when calling the function. This works for Constructors, Methods and Properties.

	== Overload resolution ==		== Overload resolution ==

Wikicatglobe at 03:29, 18 October 2013

2013-10-18T03:29:15Z

← Older revision		Revision as of 03:29, 18 October 2013
Line 1:		Line 1:
	<accesscontrol>~~Administrators,,Cem,,Maysunshine~~</accesscontrol>		<accesscontrol>Main:MyGroup</accesscontrol>
	= Objects =		= Objects =

Cg_pham at 09:26, 4 October 2011

2011-10-04T09:26:41Z

← Older revision		Revision as of 09:26, 4 October 2011
Line 1:		Line 1:
			<accesscontrol>Administrators,,Cem,,Maysunshine</accesscontrol>
	= Objects =		= Objects =

Catglobe at 10:07, 21 July 2010

2010-07-21T10:07:00Z

← Older revision		Revision as of 10:07, 21 July 2010
Line 128:		Line 128:

	Due to the automapping some constructs may have the same overload. For example a function x that has two overloads, one takes an NumberConstant and another that takes an int. These are considered equivalent, and it is totally random which is called.		Due to the automapping some constructs may have the same overload. For example a function x that has two overloads, one takes an NumberConstant and another that takes an int. These are considered equivalent, and it is totally random which is called.

			= Namespace =

			Objects as such do not have a namespace, but we decided to simulate it by having namespace objects.

			In the symbol table a variable called "Catglobe" is registered, this is an instance of GlobalNamespace.

			If you want to add some global function, then implement another class in <code>CatGlobe.Framework.Runtime.Library.GlobalFunctions</code>. It must be a normal <code>CgScriptObject</code>. The class must have no member variables since the instance is shared among all interpreters, and only static getters/setters/methods (although if you forgot to mark them static they will still work).

			You then register the class in the namespace you want it to appear. For instance here is the registration of Json in the GlobalNamespace:

			<code><pre>
			private static readonly JsonNamespace JsonNamespace = new JsonNamespace();
			[Cg("Json", "The json namespace")]
			public static JsonNamespace Json { get { return JsonNamespace; } }
			</pre></code>

			Now you can call the functions in this namespace:

			<code><pre>
			return Catglobe.Json.Parse(Catglobe.Json.Encode({1, ""Hejsa""}));
			</pre></code>

			And because they are objects, you can also do this:

			<code><pre>
			object n = Catglobe.Json;
			return n.Parse(n.Encode({1, ""Hejsa""}));
			</pre></code>


	= Functions =		= Functions =

Catglobe: /* Parameters */

2010-07-20T08:15:19Z

Parameters

← Older revision		Revision as of 08:15, 20 July 2010
Line 115:		Line 115:
	There are some special parameter types, that must all NOT be marked with a CgAttribute:		There are some special parameter types, that must all NOT be marked with a CgAttribute:

	* Interpreter - If you require the interpreter to do something, you can get it by adding a Interpreter parameter. You are probably doing something wrong if you need this.		* <code>Interpreter</code> - If you require the interpreter to do something, you can get it by adding a Interpreter parameter. You are probably doing something wrong if you need this. If you do need it, then you should be aware that your object may be shared among several interpreters, and you should therefore NOT store the value anywhere.
	* <code>IList<IConstant></code> - This is roughly equivalent to a normal C# method that takes a <code>"params object[]"</code>. This enables you to do advanced scenarios where the parameters from cgscript cannot be predicted. For obvious reasons there can be no other parameters marked with CgAttribute.		* <code>IList<IConstant></code> - This is roughly equivalent to a normal C# method that takes a <code>"params object[]"</code>. This enables you to do advanced scenarios where the parameters from cgscript cannot be predicted. For obvious reasons there can be no other parameters marked with CgAttribute.
	* other - If a parameter is not marked with a CgAttribute, it is presumed it is a IoC type that must be resolved when calling the function. This works for Constructors, Methods and Properties.		* other - If a parameter is not marked with a CgAttribute, it is presumed it is a IoC type that must be resolved when calling the function. This works for Constructors, Methods and Properties.

Catglobe: /* Objects */

2010-07-16T08:05:07Z

Objects

← Older revision		Revision as of 08:05, 16 July 2010
Line 23:		Line 23:
	The class must be internal or public, and non-abstract, and must not play with generics.		The class must be internal or public, and non-abstract, and must not play with generics.
	The exception is that it may inherit from a generic baseclass (which then inherits from CgScriptObject), or implement a generic interface.		The exception is that it may inherit from a generic baseclass (which then inherits from CgScriptObject), or implement a generic interface.

			=== Inheritance ===

			A CgScriptObject may utilize inheritance as a normal .NET object. CgScript will not be aware of this, it just sees all inherited methods, properties, etc. as belonging to the class.

	== Object functions ==		== Object functions ==

Catglobe at 07:41, 16 July 2010

2010-07-16T07:41:58Z

← Older revision		Revision as of 07:41, 16 July 2010
Line 112:		Line 112:

	* Interpreter - If you require the interpreter to do something, you can get it by adding a Interpreter parameter. You are probably doing something wrong if you need this.		* Interpreter - If you require the interpreter to do something, you can get it by adding a Interpreter parameter. You are probably doing something wrong if you need this.
	* IList<~~IConstant~~> - This is roughly equivalent to a normal C# method that takes a <code>"params object[]"</code>. This enables you to do advanced scenarios where the parameters from cgscript cannot be predicted. For obvious reasons there can be no other parameters marked with CgAttribute.		* <code>IList<IConstant></code> - This is roughly equivalent to a normal C# method that takes a <code>"params object[]"</code>. This enables you to do advanced scenarios where the parameters from cgscript cannot be predicted. For obvious reasons there can be no other parameters marked with CgAttribute.
	* other - If a parameter is not marked with a CgAttribute, it is presumed it is a IoC type that must be resolved when calling the function. This works for Constructors, Methods and Properties.		* other - If a parameter is not marked with a CgAttribute, it is presumed it is a IoC type that must be resolved when calling the function. This works for Constructors, Methods and Properties.

			== Overload resolution ==

			To find the right overload, a score is calculated.

			A function that takes an <code>IList<IConstant></code> as parameter is always a match, but the lowest priority match.

			A function that takes the exact type (or a type with a known conversion) will be a better match than a function that takes a very generic superclass. For example, a function x that has two overloads, one takes an IConstant and another that takes an ArrayConstant, when called with an ArrayConstant, the second overload takes precedence.

			Due to the automapping some constructs may have the same overload. For example a function x that has two overloads, one takes an NumberConstant and another that takes an int. These are considered equivalent, and it is totally random which is called.

	= Functions =		= Functions =

Catglobe: /* Parameters */

2010-07-16T07:33:15Z

Parameters

← Older revision		Revision as of 07:33, 16 July 2010
Line 112:		Line 112:

	* Interpreter - If you require the interpreter to do something, you can get it by adding a Interpreter parameter. You are probably doing something wrong if you need this.		* Interpreter - If you require the interpreter to do something, you can get it by adding a Interpreter parameter. You are probably doing something wrong if you need this.
	* IList<IConstant> - This is roughly equivalent to a normal C# method that takes a <code>"params object[]"</code>. This enables you to do advanced scenarios where the parameters from cgscript cannot be predicted.		* IList<IConstant> - This is roughly equivalent to a normal C# method that takes a <code>"params object[]"</code>. This enables you to do advanced scenarios where the parameters from cgscript cannot be predicted. For obvious reasons there can be no other parameters marked with CgAttribute.
	* other - If a parameter is not marked with a CgAttribute, it is presumed it is a IoC type that must be resolved when calling the function. This works for Constructors, Methods and Properties.		* other - If a parameter is not marked with a CgAttribute, it is presumed it is a IoC type that must be resolved when calling the function. This works for Constructors, Methods and Properties.

Catglobe: /* Object functions */

2010-07-16T07:30:33Z

Object functions

← Older revision		Revision as of 07:30, 16 July 2010
Line 41:		Line 41:
	}		}
	</pre></code>		</pre></code>

			A function may be static, but from inside cgscript it will be exposed as a member function.

	== Object properties ==		== Object properties ==

Catglobe: /* Parameters */

2010-07-16T07:27:23Z

Parameters

← Older revision		Revision as of 07:27, 16 July 2010
Line 109:		Line 109:
	There are some special parameter types, that must all NOT be marked with a CgAttribute:		There are some special parameter types, that must all NOT be marked with a CgAttribute:

	* Interpreter - If you require the interpreter to do something, you can get it by adding a Interpreter parameter.		* Interpreter - If you require the interpreter to do something, you can get it by adding a Interpreter parameter. You are probably doing something wrong if you need this.
	* IList<IConstant> - This is roughly equivalent to a normal C# method that takes a <code>"params object[]"</code>. This enables you to do advanced scenarios where the parameters from cgscript cannot be predicted.		* IList<IConstant> - This is roughly equivalent to a normal C# method that takes a <code>"params object[]"</code>. This enables you to do advanced scenarios where the parameters from cgscript cannot be predicted.
	* other - If a parameter is not marked with a CgAttribute, it is presumed it is a IoC type that must be resolved when calling the function. This works for Constructors, Methods and Properties.		* other - If a parameter is not marked with a CgAttribute, it is presumed it is a IoC type that must be resolved when calling the function. This works for Constructors, Methods and Properties.