aview-app 1.0.2

package/aardio/lib/thread/manage.aardio

@@ -0,0 +1,166 @@
+//manage 线程管理器
+import win.guid;
+namespace thread;
+
+class manage {
+
+	ctor( limit = 63 ){ 
+		this._guid = tostring(..win.guid.create()); 
+		var threads = {}  
+	}; 
+	
+	getSlot = function(){
+		for(slot,thrd in threads)
+			if(!thrd.handle )  
+				return thrd;
+		 
+		var len = #threads
+		if( len >= limit)  
+			return this.waitOne(); 
+		 	
+		var slot = len+1;
+		threads[slot] = { _name = ..string.format("%s[%d]",this._guid, slot ) }  	
+		return threads[slot]
+	};
+	
+	getHandles = function(){
+		var handles ={}
+		for(slot,thrd in threads){
+			..table.push( handles,thrd.handle ) //support push null   
+		} 
+		return handles;	
+	}; 
+	
+	create = function( tfunc,...){  
+		var thrd = this.getSlot(); 
+		if(!thrd) return {};
+		
+ 	 	thrd.handle,thrd.id = ..thread.create(
+		function(tfunc,name,...){  
+			var ret = { tfunc(...) }  
+			..thread.set(name, ret)  
+		},tfunc,thrd._name ,...);
+		delay(1);  
+		return thrd;
+	};  
+	
+	createLite = function( tfunc,...){  
+		var thrd = this.getSlot();  
+		if(!thrd) return {};
+ 	 	thrd.handle,thrd.id = ..thread.create(tfunc ,...);  
+ 	 	return thrd;
+	};  
+	
+	createSuspended = function(...){
+		return ..thread.createSuspended(true,this.create,...)
+	};
+	
+	suspend = function(){
+		var handles = this.getHandles();
+		for(i,hdle in handles){ 
+			..thread.suspend(hdle)
+		} 
+	}; 
+	
+	resume = function(){
+		var handles = this.getHandles();
+		for(i,hdle in handles){ 
+			..thread.resume(hdle)
+		} 	
+	}; 
+	
+	quitMessage = function(){
+		if( ! ..win[["quitMessage"]] )
+			error("使用 quitMessage() 函数之前请执行import win语句!",2)
+		 
+		for(slot,thrd in threads){
+			if( thrd.handle ){ 
+				..thread.resume( thrd.handle )
+				::PostThreadMessage(thrd.id,0x12/*_WM_QUIT*/ ,0,0);
+				..raw.closehandle( thrd.handle ); 
+			} 
+		} 
+		threads = {}; //stop waiting 
+	};
+	
+	busy = function(){
+		for(slot,thrd in threads){
+			if( thrd.handle )
+				return true;  
+		} 
+	};
+	
+	waitOne = function(){   
+		var handles = this.getHandles();
+		if(!#handles)
+			return;
+			
+		var pos  = ..thread.waitOne(handles)
+		if(!pos){
+			this.quitMessage(); //return null; 
+			return;
+		}
+		 
+		var handle = handles[pos];  
+		for(slot,thrd in threads){
+			if( thrd.handle == handle ){ 
+				..raw.closehandle(handle); 
+				thrd.handle = null;  
+				thrd.id = null;
+				if( thrd.onEnd ){ 
+					var result = ..thread.get( thrd._name )   
+					if(result){
+						var _,ubound = ..table.range(result);
+						thrd.onEnd( ..table.unpack(result,1,ubound ) )  
+						..thread.set( thrd._name,null ) //Remove  
+					}
+					else {
+						thrd.onEnd()
+					} 
+					thrd.onEnd = null;
+				}  
+				return thrd;
+			}
+		}  
+		return false;
+	}; 
+	
+	waitClose = function(){ 
+		this.resume();
+		
+		while( this.waitOne() ) { 
+		} 
+	};
+}
+
+namespace manage{
+	delay = ..win[["delay"]] : sleep
+}
+
+/**intellisense()
+thread.manage = 线程管理器
+thread.manage() = 创建线程管理器。\n可使用一个参数指定线程池大小，\n默认为 63,该值必须小于 64\n!thread_mgr.
+?thread.manage = !thread_mgr.
+!thread_mgr.create( = 创建线程，\n如果线程池已满会自动等待其他线程结束，并自动关闭已结束的线程句柄
+!thread_mgr.create(.(线程执行函数,任意个启动参数) = 创建线程。\n此函数参数与 thread.create 函数的参数一致。\n\n返回对象可指定 onEnd 成员函数，\n线程结束将线程函数返回值作为参数回调 onEnd 函数。\n必须调用 thread.manage 对象的 waitClose 函数\n才会触发 onEnd 回调函数
+!thread_mgr.createSuspended() = 创建线程并且暂停执行\n如果线程池已满会自动等待其他线程结束，并自动关闭已结束的线程句柄
+!thread_mgr.createSuspended(.(线程执行函数,任意个启动参数) = 创建线程并且暂停执行。\n此函数参数与 thread.create 函数的参数一致。\n\n返回对象可指定 onEnd 成员函数，\n线程结束将线程函数返回值作为参数回调 onEnd 函数。\n必须调用 thread.manage 对象的 waitClose 函数\n才会触发 onEnd 回调函数
+!thread_mgr.createLite( = 创建线程，但忽略线程执行函数的返回值。\n如果线程池已满会自动等待其他线程结束，并自动关闭已结束的线程句柄
+!thread_mgr.createLite(.(线程执行函数,任意个启动参数) = 创建线程但忽略线程执行函数的返回值。\n此函数参数与 thread.create 函数的参数一致。\n\n返回对象可指定 onEnd 成员函数，\n线程函数结束将回调 onEnd 函数，回调函数无参数。\n必须调用 thread.manage 对象的 waitClose 函数\n才会触发 onEnd 回调函数
+!thread_mgr.waitClose() = 等待所有线程返回，不阻塞界面线程消息处理。\n并关闭所有线程句柄。\n\n添加线程以后，必须调用 waitClose 函数
+!thread_mgr.waitOne() = 等待任一线程返回，不阻塞界面线程消息处理。\n并关闭已结束的线程句柄。\n失败返回 null\n\nwaitClose 函数实际上循环调用 waitOne 函数。
+!thread_mgr.suspend() = 所有线程暂停。\n注意线程是否正在使用互斥锁
+!thread_mgr.resume() = 所有线程继续执行
+!thread_mgr.busy() = 如果线程池里仍有未关闭的线程句柄返回 false，否则返回 true 。\n必须调用 waitOne 或 waitClose 函数才会自动关闭已结束的线程句柄
+!thread_mgr.quitMessage() = 向所有线程发送 _WM_QUIT 消息\n线程内 win.delay 函数可接受该消息并返回 false 值
+!thread_mgr.create() = !_thread_mgr_cb.
+!thread_mgr.createSuspended() = !_thread_mgr_cb.
+!thread_mgr.createLite() = !_thread_mgr_cbLite. 
+!_thread_mgr_cb.onEnd = @.onEnd = function(...){
+	__/*线程结束回调此函数，参数为线程执行函数返回的值。\n必须调用 thread.manage 对象的 waitOne 或 waitClose 函数\n才会触发 onEnd 回调函数*/	
+}
+!_thread_mgr_cbLite.onEnd = @.onEnd = function(){
+	__/*线程结束回调此函数，无参数。\n必须调用 thread.manage 对象的 waitOne 或 waitClose 函数\n才会触发 onEnd 回调函数*/	
+}
+
+end intellisense**/

package/aardio/lib/thread/semaphore.aardio

@@ -0,0 +1,86 @@
+//semaphore 计数信号量
+namespace thread;
+
+class semaphore { 
+	ctor( semaphoreName,max,initCount ){ 
+		var tArg1 = type(semaphoreName);
+		if( tArg1 == "pointer" )   {
+			this.handle	= semaphoreName;
+			if(max===true)..table.gc( this,"close" );
+		}
+		else{
+			if( !max || max <=0 ) error("信号使用计数最大值必须大于 0");
+			if( initCount===null ) initCount = max;
+		    
+		    if( tArg1 == "string") 	
+				this.handle  =  OpenSemaphore( 0x1F0003/*_EVENT_ALL_ACCESS*/,false,semaphoreName);
+				
+			if(! this.handle ) {  
+				this.handle  =  CreateSemaphore(null,initCount,max,semaphoreName); 
+				
+				if( tArg1 == "string" ) {	
+					if(! this.handle) {
+						this.handle = OpenSemaphore( 0x1F0003/*_EVENT_ALL_ACCESS*/,false,semaphoreName);
+						if( this.handle ) this.conflict = "信号量已存在";
+					}
+					elseif(::GetLastError()==0xB7/*_ERROR_ALREADY_EXISTS*/){
+						this.conflict = "信号量已存在";
+					}
+				}
+			} 
+			else {
+				this.conflict = "信号量已存在" 
+			} 
+			
+			if(!this.handle) return null,..lasterr();
+			..table.gc( this,"close" );
+		}
+	};
+	close = function(){  
+		//The system closes the handle automatically when the process terminates. 
+		//The semaphore object is destroyed when its last handle has been closed.  
+		..raw.closehandle(this.handle)
+	}
+	@_metaProperty 
+}
+  
+namespace semaphore{
+	import util.metaProperty;
+	_metaProperty = util.metaProperty(
+ 
+		_topointer = function(){
+			return owner.handle;
+		} 
+		_serialize = function(kernelCall){
+			if(kernelCall) return ..raw.serializeDupHandle("thread.semaphore",owner.handle);
+		}
+		release = function(count=1){
+			return ReleaseSemaphore( owner.handle,count,0 )
+		} 
+		wait = function(timeout){
+			return ..thread.wait(owner.handle,timeout)
+		}   
+		waitOne = function(timeout){
+			return ..thread.waitOne(owner.handle,timeout)
+		}  
+	) 
+
+	//声明API
+	CreateSemaphore= ::Kernel32.api("CreateSemaphore","pointer(pointer lpSemaphoreAttributes,int lInitialCount,int lMaximumCount,ustring lpName)");
+	OpenSemaphore= Kernel32.api("OpenSemaphore","pointer(INT desiredAccess,bool bInheritHandle,ustring lpName)");
+	ReleaseSemaphore= Kernel32.api("ReleaseSemaphore","bool(pointer hSemaphore,int lReleaseCount,int &lpPreviousCount)");  
+}
+ 
+/**intellisense() 
+thread.semaphore( = 创建或打开信号量对象,\n返回对象可传入其他线程使用。
+thread.semaphore(.(信号量句柄) = 使用句柄直接打开信号量
+thread.semaphore(.(信号量句柄,true) = 使用句柄直接打开信号量\n添加析构函数负责释放句柄
+thread.semaphore(.("信号量对象名称__",10) = 创建信号量同步对象,可以跨进程使用,\n省略名称创建匿名对象,\n参数@2指定最大资源计数,\n可选参数@3指定初始空闲计数，默认等于最大资源计数,\n参数2,参数3仅在首次创建该事件对象是起作用
+!thread_semaphore.close() = 关闭信号量对象\n该函数并不关闭信号量内核对象\n当所有引用内核对象的对象关闭,内核对象自动释放
+!thread_semaphore.conflict = 如果信号量对象已存在,此属性为真值\n否则为空值
+!thread_semaphore.release() =  线程在处理完共享资源后,\n应在离开时调用此函数将可用资源计数加1\n可在参数中指定要释放的资源计数(默认为1)\n第一个返回值表示函数执行是否成功,\n第二个返回值为原来的资源计数
+!thread_semaphore.wait() = 等待可用资源计数大于0,\n可选增加一个参数指定超时,以毫秒为单位\n注意此函数应与release()函数配对使用\n在UI线程中应使用非阻塞的waitOne()函数替代
+!thread_semaphore.waitOne() = 等待可用资源计数大于0,\n可选增加一个参数指定超时,以毫秒为单位\n注意此函数应与release()函数配对使用
+thread.semaphore() = !thread_semaphore.
+thread.semaphore = 信号量可用于进程或线程间同步
+end intellisense**/

package/aardio/lib/thread/shareHandle.aardio

@@ -0,0 +1,49 @@
+//shareHandle 共享句柄
+namespace thread.shareHandle;
+import thread.table;
+
+var context_table = thread.table("{93B5BAF4-EE2F-4A70-8295-F0F1D896C775}")
+var context_table_ref = thread.table("{6D47D215-F4AD-478E-8EC0-029CA5C39612}")
+
+create = function(shareName,init,...){
+	..thread.lock("{EF819EA3-9D57-4C32-A68C-6D39CA55BECE}")
+	var handle = context_table.get(shareName)
+	if( handle === null ){
+		handle = init(...);
+		context_table.set(shareName,handle);
+		context_table_ref.set(shareName,1)
+	}
+	else {
+		var ref = context_table_ref.get(shareName)
+		context_table_ref.set(shareName,ref+1)
+	}
+	..thread.unlock("{EF819EA3-9D57-4C32-A68C-6D39CA55BECE}")
+	return handle;
+}
+
+delete = function(shareName,free){
+	..thread.lock("{EF819EA3-9D57-4C32-A68C-6D39CA55BECE}")
+	var ret;
+	var handle = context_table.get(shareName)
+	if(handle === null )return;
+	
+	var ref = context_table_ref.get(shareName) - 1;
+	if( ref <= 0 ){
+		context_table_ref.set(shareName,null);
+		context_table.set(shareName,null);
+		ret = free(handle) 
+	}
+	else{
+		context_table_ref.set(shareName,ref)   
+	}
+	..thread.unlock("{EF819EA3-9D57-4C32-A68C-6D39CA55BECE}")
+	return ret;
+}
+
+/**intellisense(thread)
+shareHandle = 线程共享句柄
+shareHandle.create(.(全局唯一名字,构造函数,其他创建参数) = 创建一个多线程共享句柄,返回指针\n如果已存在句柄,则增加引用计数并直接返回该句柄\n构造函数必须返回非空值
+shareHandle.delete(.(全局唯一名字,析构函数) = 多线程共享句柄引用计数减一,\n如果引用计数为0,将共享句柄作为参数调用析构函数关闭对象
+end intellisense**/
+
+

package/aardio/lib/thread/table.aardio

@@ -0,0 +1,193 @@
+//table 线程共享表
+namespace thread 
+
+var t_call = ..thread.call 
+
+class table{
+	ctor( name,clear=false){
+		if(!name) name = "$_thread_table:" + ..thread.add("$_thread_table_id",1);
+			
+		if( ( ! ..thread.get(name ) || clear) ){ 
+			..thread.set(name,{}) 
+		}
+			
+		this.name = name
+	}; 
+	set = function(k,v){
+		t_call("__table_set", ,this.name,k,v )
+	}
+	get = function(k,v){
+		return t_call("__table_get", ,this.name,k )
+	}
+	getByNamespace = function(k){
+		return t_call("__table_getByNamespace", ,this.name,k)
+	}
+	setByNamespace = function(k,v){
+		t_call("__table_setByNamespace", ,this.name,k,v )
+	}
+	lenByNamespace = function(k,v){
+		t_call("__table_lenByNamespace", ,this.name,k,v )
+	}
+	len = function(){
+		return t_call("__table_len", ,this.name )
+	}
+	append = function(...){
+		return t_call("__table_append", ,this.name,... )
+	}
+	each = function(){ 
+		return this.next,this	
+	}	
+	@meta;
+}
+
+var tableFunc = { 
+    shift=1;
+    unshift=1;
+	right=1;
+	slice=1;
+	sort=1;
+	unpack=1;
+	new=1;
+	range=1;
+	mixin=1;
+	next=1;
+	splice=1;
+	tostring=1;
+	insert=1;
+	pop=1;
+	concat=1;
+	push=1;
+	count=1;
+	reverse=1;
+	left=1;
+	append=1;
+	remove=1;
+	clear=1;
+} 
+table.meta = {
+	_get = function(k,ownerCall){
+		if( !ownerCall && !tableFunc[k] )
+			return t_call("__table_get", ,owner.name,k )
+			
+		owner[[k]] =  function(...){
+			return t_call("__table_call",k,owner.name,... )
+		}
+		return owner[[k]]; 
+	}
+	_set = function(k,v){
+		if( tableFunc[k] )
+			error("不能修改默认函数",2)
+			
+		t_call("__table_set", ,owner.name,k,v )
+	}
+	_serialize = function(kernelCall){
+		if(kernelCall) return `global.import('thread.table') : thread.table("`++owner.name++`")`;
+		else {
+			return owner.tostring();
+		}
+	}
+	_json = function(){
+		return ..thread.get(owner.name);
+	} 
+}
+ 
+lock("INIT.THREAD.CALL.{7EC7B22E-F1A6-4AA7-B5A3-4741C583AA00}")
+if( ! get("__table_call" ) ){
+	set(
+		"__table_call",
+		function( name,...){
+			var t = global[name];
+			if(t)return table[owner]( t,...);
+		}
+	)  
+	set(
+		"__table_get",
+		function( name,k){
+			var t = global[name];
+			if(t)return t[k];
+		}
+	)
+	set(
+		"__table_set",
+		function( name,k,v){
+			var t = global[name];
+			if(t)t[k] = v;
+		}
+	)
+	set(
+		"__table_getByNamespace",
+		function( name,k){
+			var t = global[name];
+			if(t)return ( ..table.getByNamespace(k,t) );
+		}
+	)
+	set(
+		"__table_lenByNamespace",
+		function( name,k){
+			var t = global[name];
+			if(t)return #..table.getByNamespace(k,t);
+		}
+	)
+	set(
+		"__table_setByNamespace",
+		function( name,k,v){
+			var t = global[name];
+			if(t)..table.setByNamespace(k,v,t); 
+		}
+	)
+	set(
+		"__table_len",
+		function( name ){
+			var t = global[name];
+			if(t) return #(t);
+			return 0;
+		}
+	) 
+	set(
+		"__table_append",
+		function( name,... ){
+			var t = global[name];
+			if(t) ..table.append(t,...); 
+		}
+	) 
+}
+unlock("INIT.THREAD.CALL.{7EC7B22E-F1A6-4AA7-B5A3-4741C583AA00}")
+ 
+/**intellisense()
+thread.table = 线程共享表
+thread.table("__") = 创建多线程共享表,返回对象可传入其他线程使用,\n可选使用参数@1指定线程共享变量名,\n省略参数则自动生成共享变量名
+thread.table() = !thread_table.
+?thread.table =  !thread_table.
+!thread_table.get("键名") = 读取成员值
+!thread_table.set("键名",__/*值*/) = 写入成员值
+!thread_table.getByNamespace("__/*指定表内名字空间路径*/") = 在指定表查找并返回成员
+!thread_table.setByNamespace("__/*指定表内名字空间路径*/",新值) = 参数一指定表内名字空间路径,如果不存在则则创建此表内名字空间,\n支持索引操作符,可以使用[]空索引实现在数组尾部添加值\n参数二指定需要设置的值,如果不指定则创建空表并赋值
+!thread_table.lenByNamespace("__/*指定表内名字空间路径*/") = 返回指定元素长度
+!thread_table.next(.() = 获取table的第一个键值对元素
+!thread_table.next(.( key ) = 迭代获取table的下一个键值对元素
+!thread_table.tostring(__) = 获取table的字符串表达式
+!thread_table.concat(.( tab2 ) = 拼接多个table对象
+!thread_table.insert(.(要插入的值,要插入的位置 ) = 插入元素到指定位置
+!thread_table.insert(.(要插入的值 ) = 插入元素到table头部
+!thread_table.remove(.(位置 ) = 在表中指定位置移除元素
+!thread_table.remove(.( ) = 在table头部移除元素
+!thread_table.push(.(__) = 在顺序数组尾部压入一个或多个元素,返回数组大小
+!thread_table.push(.(__v1,v2,v3,...) = 在顺序数组尾部压入多个元素,返回数组大小
+!thread_table.pop(__) = 在顺序数组尾部弹出一个或多个元素并作为返回值
+!thread_table.sort(.( ) = 排序
+!thread_table.sort(.( comProc ) = 排序,comProc指定用于比较元素大小的函数
+!thread_table.reverse(__) =  table数组倒序排列。
+!thread_table.range(__) =  返回table数组的最小索引,最大索引\nmin,max=tab.range();
+!thread_table.unpack(__) =  返回表中所有的元素\na,b,c,d,e = tab.unpack();
+!thread_table.left(len__) = 返回table对象左侧开始返回指定个数的元素。
+!thread_table.right(len__ = 返回table对象右侧开始返回指定个数的元素 
+!thread_table.len() = 返回table长度
+!thread_table.count() = 获取table成员总数
+!thread_table.unshift(.(要插入的一个或多个元素) = 插入一个或多个元素到数组头部,返回数组长度
+!thread_table.shift(.(移除数目) = 自数组头部移除并返回指定个数成员,\n参数默认为1
+!thread_table.append(__) = 追加一个或多个数组到线程共享表,\n此函数内部使用table.append实现,规则相同,\n但无返回值
+!thread_table.each = @for( k,v in ??.each() ){
+	__ 
+}
+!thread_table.clear() = 清空共享表中的所有值
+end intellisense**/

package/aardio/lib/thread/token.aardio

@@ -0,0 +1,58 @@
+//token 令牌
+import process.token;
+
+namespace thread;
+
+class token{
+	ctor(thandle,access,gc,openAsSelf){
+		var token = {ptr handle}
+		if(openAsSelf===null) openAsSelf = true;
+		if(gc===null) gc = true;
+	
+		if(::Advapi32.OpenThreadToken(thandle:..thread.getHandle(),access : 8/*_TOKEN_QUERY*/,openAsSelf,token)){
+			return ..process.token( token = token.handle; gc = gc )
+		} 
+		
+		return null;
+	} 
+}
+
+token.impersonate = function(process,proc){
+	var tkImpersonation = ..thread.token(null, 0x20008/*_TOKEN_READ*/ | 4/*_TOKEN_IMPERSONATE*/,false)
+	if(tkImpersonation){
+		if(!::Advapi32.RevertToSelf()){
+			tkImpersonation.close();
+			tkImpersonation = null;
+		}
+	}
+			
+	var token = ..process.token(process,8/*_TOKEN_QUERY*/ | 4/*_TOKEN_IMPERSONATE*/|2/*_TOKEN_DUPLICATE*/)
+
+	var ret;
+	if(token){  
+		var th = token.duplicate() 
+		if(th) {
+
+			if( ::Advapi32.SetThreadTokenB(,th) ){
+				ret = proc();
+
+				::Advapi32.RevertToSelf();
+				if(tkImpersonation)::Advapi32.SetThreadTokenB(,tkImpersonation);
+			} 
+
+			if(tkImpersonation) tkImpersonation.close();
+		};
+	}
+	
+	return ret;
+}
+
+/**intellisense()
+thread.token = 获取线程令牌
+thread.token( = 获取线程令牌，返回 process.token 对象。\n未切换认线程令牌的默认状态回 null
+thread.token(.(threadHandle,access,gc) =获取线程令牌，返回 process.token 对象。\n@threadHandle 参数指定线程句柄，省略取当前线程句柄，\naccess指定访问权限,省略时默认值为 _TOKEN_QUERY\n@gc 指定返回对象在回收时默认自动调用close函数，省略时默认为 true
+thread.token() = !processToken.
+thread.token.impersonate(process,proc) = @.impersonate("winlogon.exe",function(){
+	__/*@process 参数指定进程对象、句柄、或已执行文件名，\n指定系统进程 winlogon.exe 可获取 SYSTEM 身份，进程需要管理权限。\n@proc 参数指定设置模拟令牌期间执行的回调函数。\n此函数返回回调函数的第一个返回值*/
+})
+end intellisense**/