//metaProperty 属性元表
namespace util;

class metaProperty{
	ctor( meta ){
		if(type(meta)==type.table)
			this = meta;
	};
	
	_get = function(k){
		var t = this[ k];

		if( type(t)==type.table  ){
			if(type(t._get) == type.function ){ //Ducking Type 是宽松的隐性接口
					var ok,v =call( t._get,owner  ); 
					if(!ok)error(v,2) 
					return v;
			}
			error("只写属性["+k+"]，禁止读取!" ,2)  
		}
		
		if(t)return t;
		
		if(this.get){ 
			ok,ret = call( this.get,owner,k );
			if(!ok)error(v,2) 
			return  ret;
		} 
				
	}
	_set = function(k,v){
		var t = this[ k];
		if( type(t)==type.table  ){
			if(type(t._set) == type.function ) { 
				var ok,v = call( t._set,owner ,v)  
				if(!ok)error(v,2) 
				return;
			} 
			error("只读属性["+k+"]，禁止修改!" ,2) 	
		}
		
		if(this.set){ 
			var ok,v = call( this.set,owner,k,v);
			if(!ok)error(v,2) 
			return;
		}
		owner[[k]] = v;
	} 
}

namespace metaProperty{

	extend = function(cls,...){
		if( type(cls) == type.class  && cls._metaProperty[["_get"]] ){
			..table.mixin(cls._metaProperty,...)
		}
		else
			error("不是有效类,或未找到属性表( 类._metaProperty ) ",2)
	} 
}

/**intellisense()
util.metaProperty = 属性元表
util.metaProperty(__) = @.metaProperty(\n\n	属性 = {\n		_get = function(){ \n			/*读取属性代码写在这里*/\n			return null;\n		}\n		_set = function( value ){\n			/*写入属性代码写在这里*/\n			..io.print( owner,value)\n		} 	\n	};\n	@{ _get = ..父属性表 } /*属性表可继承*/ \n)
util.metaProperty.extend(.(类对象,一个或多个混入表) = 使用混入表扩展类的属性情\n类名字空间必须定义了_metaProperty静态成员\n并且是一个有效的属性表
end intellisense**/
 