public static void RunTest(TestType type, int ThreadCount, CallbackFunction callBack, ITest target) { for (int i = 0; i < ThreadCount; i++) { BackgroundWorker worker = new BackgroundWorker(); worker.DoWork += (object sender, DoWorkEventArgs e) => { bool result = target.Test(); e.Result = result; }; worker.RunWorkerCompleted += (object sender, RunWorkerCompletedEventArgs e) => { if (callBack != null) { if (e.Error != null) { callBack(type, (bool)e.Result); } else { callBack(type, false); } } }; worker.RunWorkerAsync(); } }
public void Load(string collectionName, CallbackFunction.Load<IList<JsonDocument>> callback) { Guard.Assert(() => !string.IsNullOrEmpty(collectionName)); Guard.Assert(() => callback != null); SynchronizationContext context = SynchronizationContext.Current; IndexSession.Query("Raven/DocumentsByEntityName", new IndexQuery {Query = string.Format("Tag:{0}", collectionName)}, null, (result) => { var documents = new List<JsonDocument>(); if (result.IsSuccess) { var jsonSerializer = new JsonSerializer(); documents = result.Data.Results.Select( document => (JsonDocument) jsonSerializer.Deserialize(document.CreateReader(), typeof (JsonDocument))). ToList(); } var loadResponse = new LoadResponse<IList<JsonDocument>> { Data = documents, Exception = result.Exception, StatusCode = result.StatusCode }; context.Post(delegate { callback.Invoke(loadResponse); }, null); }); }
public static void RegisterTriggerRule(CallbackFunction c, TestTriggerCondition f) { lock (mutex) { if (!hash.ContainsKey(c) || hash[c] != f) hash.Add(c, f); } }
public static void UnregisterTriggerRule(CallbackFunction c, TestTriggerCondition f) { lock (mutex) { if (hash.ContainsKey(c) && hash[c] == f) hash.Remove(c); } }
private static void CheckCallDelayed() { if (Time.realtimeSinceStartup > s_DelayedCallbackTime) { update = (CallbackFunction) Delegate.Remove(update, new CallbackFunction(EditorApplication.CheckCallDelayed)); delayedCallback(); } }
private static void Internal_CallDelayFunctions() { CallbackFunction delayCall = EditorApplication.delayCall; EditorApplication.delayCall = null; if (delayCall != null) { delayCall(); } }
public void ExecuteDelegate(CallbackFunction function) { if (function != null) { function(); } HideDialog(); Button1.onClick.RemoveAllListeners(); Button2.onClick.RemoveAllListeners(); }
public static void UnregisterTriggerRule(CallbackFunction c, TestTriggerCondition f) { lock (mutex) { if (hash.ContainsKey(c) && hash[c] == f) { hash.Remove(c); } } }
public static void RegisterTriggerRule(CallbackFunction c, TestTriggerCondition f) { lock (mutex) { if (!hash.ContainsKey(c) || hash[c] != f) { hash.Add(c, f); } } }
private IEnumerator GetUserData(CallbackFunction callback) { WWW www = new WWW("https://randomuser.me/api"); yield return(www); string returnString = www.text; Debug.Log(returnString); }
public ErrorMessage(string errorText, CallbackFunction callback) { MessageBoxButtons buttons = MessageBoxButtons.OK; DialogResult result = MessageBox.Show(errorText, "Error", buttons, MessageBoxIcon.Error); if (result == System.Windows.Forms.DialogResult.OK) { callback?.Invoke(); } }
public void PlayMissionCompletedTransition(CallbackFunction callbackFunction) { _callbackFunction = callbackFunction; _animationList = new List <SceneTransitionAnimation>(); _animationList.Add(new TransitionAnimationWait(1f)); _animationList.Add(new TransitionAnimationSwipe(canvas, transitionSwipeObject /*transitionSwipePrefab*/, 1f, false)); StartAnimation(); }
public virtual void Invoke(IV8PluginRouter router, CefV8Context context, object result, int errorCode, string error) { if (CallbackFunction == null) { throw new ObjectDisposedException("_callback"); } // Have to enter the context in order to be able to create object/array/function/date V8 instances context.Enter(); try { var args = new List <CefV8Value>(); switch (_callbackType) { case V8CallbackType.ParameterCallback: case V8CallbackType.EventListener: { var remoteResult = result as ResultData; var localArray = result as object[]; if (remoteResult != null) { if (remoteResult.Items != null) { args.AddRange(remoteResult.Items.Select(item => ToCefV8Value(router, item))); } } else if (localArray != null) { args.AddRange(localArray.Select(item => ToCefV8Value(router, item))); } break; } case V8CallbackType.FunctionCallback: { args.Add(ToCefV8Value(router, result)); args.Add(CefV8Value.CreateInt(errorCode)); args.Add(CefV8Value.CreateString(error)); break; } } var functionResult = CallbackFunction.ExecuteFunction(null, args.ToArray()); if (functionResult == null && CallbackFunction.HasException) { var exception = CallbackFunction.GetException(); Logger.Error("Error executing callback: ", exception.Message); } } finally { context.Exit(); } }
public ADData(MccBoard board, BoardConfiguration bc) { lowChannel = bc.LowChannel; qChans = bc.QChanns; NumPoints = 186;//bc.PointsRead; MemHandle = MccDaq.MccService.WinBufAllocEx(10*qChans*NumPoints); Board = board; rate = bc.Rate; adData = new ushort[qChans*NumPoints]; mCb = new CallbackFunction(this.CreateBackground); }
/// <summary> /// Create a new TCP listener on the default port and create a new ConnectionState, /// then begin listening for clients on the default port /// </summary> /// <param name="connectedCallback"></param> public static void ServerAwaitingClientLoop(CallbackFunction connectedCallback) { TcpListener lstn = new TcpListener(IPAddress.Any, DEFAULT_PORT); lstn.Start(); ConnectionState cs = new ConnectionState(); cs.listener = lstn; cs.EventProcessor = connectedCallback; lstn.BeginAcceptSocket(AcceptNewClient, cs); }
/// <summary> /// Start attempting to connect to the server /// </summary> /// <param name="host_name"> server to connect to </param> /// <returns></returns> public static Socket ConnectToServer(string hostName, int port, CallbackFunction connectedCallback) { // Connect to a remote device. try { // Establish the remote endpoint for the socket. IPHostEntry ipHostInfo; IPAddress ipAddress = IPAddress.None; // Determine if the server address is a URL or an IP try { ipHostInfo = Dns.GetHostEntry(hostName); bool foundIPV4 = false; foreach (IPAddress addr in ipHostInfo.AddressList) { if (addr.AddressFamily != AddressFamily.InterNetworkV6) { foundIPV4 = true; ipAddress = addr; break; } } // Didn't find any IPV4 addresses if (!foundIPV4) { Debug.WriteLine("Could not find IP"); return(null); } } catch (Exception e1) { // see if host name is actually an ipaddress, i.e., 155.99.123.456 ipAddress = IPAddress.Parse(hostName); } // Create a TCP/IP socket. Socket theServer = new Socket(ipAddress.AddressFamily, SocketType.Stream, ProtocolType.Tcp); theServer.SetSocketOption(SocketOptionLevel.IPv6, SocketOptionName.IPv6Only, false); SocketState serverState = new SocketState(theServer, -1); // store the action for when first conectting to the server. serverState.EventProcessor = connectedCallback; serverState.socket.BeginConnect(ipAddress, port, ConnectedToServer, serverState); //serverState.socket.Connect(ipAddress, 2112); return(theServer); } catch (Exception e) { return(null); } }
/// <summary> /// Receives an item from the cache or loads it /// </summary> /// <param name="key">to lookup</param> /// <param name="callback">to be calles when loaded</param> public void Get(TKey key, CallbackFunction callback) { if (storage.ContainsKey(key)) { callback(storage[key]); } else { enqueue(key, callback); } }
public static void DelayCall(CallbackFunction method) { #if UNITY_EDITOR if (EditorApplication.delayCall != method) { EditorApplication.delayCall += method; } return; #endif Utility.DelayCall(method, 0); }
static void Internal_CallDelayFunctions() { CallbackFunction delay = delayCall; delayCall = null; if (delay != null) { delay(); } }
public static void DelayCall(Action method) { #if UNITY_EDITOR CallbackFunction callback = new CallbackFunction(method); if (EditorApplication.delayCall != callback) { EditorApplication.delayCall += callback; } return; #endif Utility.DelayCall(method, 0); }
/// <summary> /// Releases all resource used by the <see cref="LuaSharp.ClrFunction"/> object. /// </summary> /// <remarks> /// Call <see cref="Dispose"/> when you are finished using the <see cref="LuaSharp.ClrFunction"/>. The /// <see cref="Dispose"/> method leaves the <see cref="LuaSharp.ClrFunction"/> in an unusable state. After calling /// <see cref="Dispose"/>, you must release all references to the <see cref="LuaSharp.ClrFunction"/> so the garbage /// collector can reclaim the memory that the <see cref="LuaSharp.ClrFunction"/> was occupying. /// </remarks> public void Dispose() { var wasDisposed = Interlocked.Exchange( ref disposed, 1 ) == 1; if( wasDisposed ) return; callback = null; name = null; Dispose( true ); GC.SuppressFinalize( this ); }
/// <summary> /// Enqueues the work item. Returns a work-item-state-struct as a handle to the operation that is just about, or /// queued, to be executed. /// <para>Information on the returned struct... </para> /// <para> /// Call the result property on this struct to trigger a lock, thus blocking your current thread until the function /// has executed. /// </para> /// <para> /// Call Dispose on that returned item to automatically reuse the data-structure behind each work-item in order to /// avoid /// garbage-collector-cycles. /// </para> /// <para> /// Use its <c>IsCompleted</c>-Property to verify within a monitor if your method has finished executing. The /// <c>IsCompleted</c>-Property actually triggers a WaitOne(1) on a /// ManualResetEvent internally thus returning almost instantly. /// </para> /// </summary> /// <typeparam name="V">The type of the result.</typeparam> /// <param name="workerFunction">The worker function.</param> /// <param name="asyncCallback">The async callback.</param> /// <returns> /// Returns a work-item-state-struct as a handle to the operation that is just about, or queued, to be executed. /// </returns> public IWorkItemState <V> EnqueueWorkItem <V>(Func <V> workerFunction, CallbackFunction asyncCallback = null) { var workItem = GetWorkItem(asyncCallback); workItem.DelegateInputParameters = new object[] {}; workItem.Delegate = delegateInputParameters => { return(workerFunction.Invoke()); }; var workItemState = new WorkItemState <V>(workItem.WorkItemStateTypeless); EnqueueWorkItemInternal(workItem); return(workItemState); }
public void testTail() { var lua = @" print(tail) tail(100) "; //var script = new Script(); script.Globals["tail"] = DynValue.NewCallback(CallbackFunction.FromDelegate(script, (Func <int, DynValue>)newTail)); script.DoString(lua); Console.ReadKey(); }
/// <summary> /// Enqueues the work item. Returns a work-item-state-struct as a handle to the operation that is just about, or /// queued, to be executed. /// <para>Information on the returned struct... </para> /// <para> /// Call the result property on this struct to trigger a lock, thus blocking your current thread until the function /// has executed. /// </para> /// <para> /// Call Dispose on that returned item to automatically reuse the data-structure behind each work-item in order to /// avoid /// garbage-collector-cycles. /// </para> /// <para> /// Use its <c>IsCompleted</c>-Property to verify within a monitor if your method has finished executing. The /// <c>IsCompleted</c>-Property actually triggers a WaitOne(1) on a /// ManualResetEvent internally thus returning almost instantly. /// </para> /// </summary> /// <typeparam name="T1">The type of the 1.</typeparam> /// <typeparam name="T2">The type of the 2.</typeparam> /// <typeparam name="V">The type of the result.</typeparam> /// <param name="workerFunction">The worker function.</param> /// <param name="arg1">The arg1.</param> /// <param name="arg2">The arg2.</param> /// <param name="asyncCallback">The async callback.</param> /// <returns> /// Returns a work-item-state-struct as a handle to the operation that is just about, or queued, to be executed. /// </returns> public IWorkItemState <V> EnqueueWorkItem <T1, T2, V>(Func <T1, T2, V> workerFunction, T1 arg1, T2 arg2, CallbackFunction asyncCallback = null) { var workItem = GetWorkItem(asyncCallback); workItem.DelegateInputParameters = new object[] { arg1, arg2 }; workItem.Delegate = delegateInputParameters => workerFunction.Invoke(arg1, arg2); var workItemState = new WorkItemState <V>(workItem.WorkItemStateTypeless); EnqueueWorkItemInternal(workItem); return(workItemState); }
private void enqueue(TKey key, CallbackFunction callback) { if (queued.ContainsKey(key)) { queued[key].Add(callback); } else { queued[key] = new List <CallbackFunction> { callback }; load(key); // invoke the first load per key } }
public Lua() { state = LuaLib.luaL_newstate(); panicFunction = ( IntPtr s ) => { throw new LuaException( "Error in call to Lua API: " + LuaLib.lua_tostring( s, -1 ) ); }; LuaLib.lua_atpanic( state, panicFunction ); LuaLib.luaL_openlibs( state ); disposed = false; }
public Lua() { state = LuaLib.luaL_newstate(); panicFunction = ( IntPtr s ) => { throw new LuaException("Error in call to Lua API: " + LuaLib.lua_tostring(s, -1)); }; LuaLib.lua_atpanic(state, panicFunction); LuaLib.luaL_openlibs(state); disposed = false; }
public static void Delay(Action method) { #if UNITY_EDITOR if (Proxy.IsEditor()) { CallbackFunction callback = new CallbackFunction(method); if (EditorApplication.delayCall != callback) { EditorApplication.delayCall += callback; } return; } #endif Call.Delay(method, 0); }
public void LoadPlugins(CallbackFunction.Load<IList<KeyValuePair<string, Attachment>>> callback) { var context = SynchronizationContext.Current; Client.AttachmentGetAll((result) => context.Post(delegate { callback.Invoke(new LoadResponse<IList<KeyValuePair<string, Attachment>>>() { Data = result.Data.Where(x => x.Key.EndsWith(".xap", StringComparison.InvariantCultureIgnoreCase)).ToList(), Exception = result.Exception, StatusCode = result.StatusCode }); } , null)); }
/// <summary> /// Releases all resource used by the <see cref="LuaSharp.ClrFunction"/> object. /// </summary> /// <remarks> /// Call <see cref="Dispose"/> when you are finished using the <see cref="LuaSharp.ClrFunction"/>. The /// <see cref="Dispose"/> method leaves the <see cref="LuaSharp.ClrFunction"/> in an unusable state. After calling /// <see cref="Dispose"/>, you must release all references to the <see cref="LuaSharp.ClrFunction"/> so the garbage /// collector can reclaim the memory that the <see cref="LuaSharp.ClrFunction"/> was occupying. /// </remarks> public void Dispose() { var wasDisposed = Interlocked.Exchange(ref disposed, 1) == 1; if (wasDisposed) { return; } callback = null; name = null; Dispose(true); GC.SuppressFinalize(this); }
public static void DelayCall(object key, CallbackFunction method, float seconds, bool overwrite = true) { if (!key.IsNull() && !method.IsNull()) { if (seconds <= 0) { method(); return; } if (Utility.delayedMethods.ContainsKey(key) && !overwrite) { return; } Utility.delayedMethods[key] = new KeyValuePair <CallbackFunction, float>(method, Time.realtimeSinceStartup + seconds); } }
/// <summary> /// Add a new callback function to the worker thread. /// </summary> public static void Add(CallbackFunction fn, object param) { if (mInstance == null) { GameObject go = new GameObject("_WorkerThread"); DontDestroyOnLoad(go); mInstance = go.AddComponent<WorkerThread>(); mInstance.mThread = new Thread(mInstance.ThreadFunction); mInstance.mThread.Start(); } Entry ent = new Entry(); ent.fnct = fn; ent.param = param; lock (mInstance) mInstance.mActive.Add(ent); }
/// <summary> /// Removes the specified function from the worker thread. /// </summary> static public void Remove(CallbackFunction fn) { if (mInstance != null) { lock (mInstance) { foreach (Entry ent in mInstance.mActive) { if (ent.fnct == fn) { mInstance.mActive.Remove(ent); break; } } } } }
private WorkItem GetWorkItem(CallbackFunction asyncCallback) { WorkItem workItem; if (!returnedWorkItems.TryDequeue(out workItem)) { workItem = new WorkItem(); workItem.WorkItemStateTypeless = new WorkItemStateTypeless(workItem); } workItem.SingleThreadRunner = null; workItem.IsCompleted = false; workItem.Result = null; workItem.AsyncCallback = asyncCallback; return(workItem); }
/// <summary> /// Creates a new instance of the <see cref="Lua"/> class. /// </summary> public Lua() { state = LuaLib.luaL_newstate(); panicFunction = ( IntPtr s ) => { throw new LuaException( "Error in call to Lua API: " + LuaLib.lua_tostring( s, -1 ) ); }; LuaLib.lua_atpanic( state, panicFunction ); LuaLib.luaL_openlibs( state ); LookupTable<IntPtr, Lua>.Store( state, this ); disposed = 0; }
/// <summary> /// Creates a new instance of the <see cref="Lua"/> class. /// </summary> public Lua() { state = LuaLib.luaL_newstate(); panicFunction = ( IntPtr s ) => { throw new LuaException("Error in call to Lua API: " + LuaLib.lua_tostring(s, -1)); }; LuaLib.lua_atpanic(state, panicFunction); LuaLib.luaL_openlibs(state); LookupTable <IntPtr, Lua> .Store(state, this); disposed = 0; }
unsafe public bool Init_USB() { char[] name = new char[64]; char[] model = new char[64]; int[] type = new int[1]; connected = false; try { if (File.Exists("ExtIO_Si570_usb.dll")) { connected = InitHW(name, model, type); if (connected) { callback = new CallbackFunction(ExtSi570CallbackFunction); SetCallback(callback); if (!console.SkinsEnabled) { console.btnUSB.BackColor = Color.GreenYellow; } console.UsbSi570Enable = true; } else { if (!console.SkinsEnabled) { console.SetupForm.chkGeneralUSBPresent.Checked = false; } console.UsbSi570Enable = false; console.btnUSB.BackColor = Color.Red; } return(connected); } else { return(false); } } catch (Exception ex) { Debug.Write("Error while Si570 init!\n", "Error!\n" + ex.ToString()); return(false); } }
/// <summary> /// Add a new callback function to the worker thread. /// </summary> static public void Add(CallbackFunction fn, object param) { if (mInstance == null) { GameObject go = new GameObject("_WorkerThread"); DontDestroyOnLoad(go); mInstance = go.AddComponent <WorkerThread>(); mInstance.mThread = new Thread(mInstance.ThreadFunction); mInstance.mThread.Start(); } Entry ent = new Entry(); ent.fnct = fn; ent.param = param; lock (mInstance) mInstance.mActive.Add(ent); }
/// <summary> /// Enqueues the work item. Returns a work-item-state-struct as a handle to the operation that is just about, or /// queued, to be executed. /// <para>Information on the returned struct... </para> /// <para> /// Call the result property on this struct to trigger a lock, thus blocking your current thread until the function /// has executed. /// </para> /// <para> /// Call Dispose on that returned item to automatically reuse the data-structure behind each work-item in order to /// avoid /// garbage-collector-cycles. /// </para> /// <para> /// Use its <c>IsCompleted</c>-Property to verify within a monitor if your method has finished executing. The /// <c>IsCompleted</c>-Property actually triggers a WaitOne(1) on a /// <see cref="ManualResetEvent" /> internally thus returning almost instantly. /// </para> /// </summary> /// <typeparam name="T1">The type of the 1.</typeparam> /// <typeparam name="T2">The type of the 2.</typeparam> /// <typeparam name="T3">The type of the 3.</typeparam> /// <param name="workerFunction">The worker function.</param> /// <param name="arg1">The arg1.</param> /// <param name="arg2">The arg2.</param> /// <param name="arg3">The arg3.</param> /// <param name="asyncCallback">The async callback.</param> /// <returns> /// Returns a work-item-state-struct as a handle to the operation that is just about, or queued, to be executed. /// </returns> public IWorkItemState EnqueueWorkItem <T1, T2, T3>(Action <T1, T2, T3> workerFunction, T1 arg1, T2 arg2, T3 arg3, CallbackFunction asyncCallback = null) { var workItem = GetWorkItem(asyncCallback); workItem.DelegateInputParameters = new object[] { arg1, arg2, arg3 }; workItem.Delegate = delegateInputParameters => { workerFunction.Invoke(arg1, arg2, arg3); return(null); }; var workItemState = new WorkItemState(workItem.WorkItemStateTypeless); EnqueueWorkItemInternal(workItem); return(workItemState); }
/// <summary> /// Removes the specified function from the worker thread. /// </summary> public static void Remove(CallbackFunction fn) { if (mInstance != null) { lock (mInstance) { foreach (Entry ent in mInstance.mActive) { if (ent.fnct == fn) { mInstance.mActive.Remove(ent); break; } } } } }
public void Test_DelegateMethod(InteropAccessMode opt) { UserData.UnregisterType <SomeClass>(); string script = @" x = concat(1, 2); return x;" ; Script S = new Script(); SomeClass obj = new SomeClass(); S.Globals["concat"] = CallbackFunction.FromDelegate(S, (Func <int, int, string>)obj.ConcatNums, opt); DynValue res = S.DoString(script); Assert.AreEqual(DataType.String, res.Type); Assert.AreEqual("1%2", res.String); }
public static int str_gmatch(LuaState L) { CallbackFunction C = new CallbackFunction(gmatch_aux_2, "gmatch"); string s = ArgAsType(L, 1, DataType.String, false).String; string p = PatchPattern(ArgAsType(L, 2, DataType.String, false).String); C.AdditionalData = new GMatchAuxData() { S = new CharPtr(s), P = new CharPtr(p), LS = (uint)s.Length, POS = 0 }; L.Push(DynValue.NewCallback(C)); return(1); }
/// <summary> /// Pushes a new C closure onto the stack. /// When a C function is created, it is possible to associate some values with it, thus creating a C closure; these values are then accessible to the function whenever it is called. To associate values with a C function, first these values should be pushed onto the stack (when there are multiple values, the first value is pushed first). Then lua_pushcclosure is called to create and push the C function onto the stack, with the argument n telling how many values should be associated with the function. lua_pushcclosure also pops these values from the stack. /// </summary> /// <param name="state"> /// A <see cref="IntPtr"/> /// </param> /// <param name="fn"> /// A <see cref="CallbackFunction"/> /// </param> /// <param name="n"> /// A <see cref="System.Int32"/> /// </param> public static extern void lua_pushcclosure( IntPtr state, CallbackFunction fn, int n );
/// <summary> /// If an error happens outside any protected environment, Lua calls a panic function and then calls exit(EXIT_FAILURE), thus exiting the host application. Your panic function can avoid this exit by never returning (e.g., doing a long jump). The panic function can access the error message at the top of the stack. /// </summary> /// <param name="state"> /// A Lua State. <see cref="IntPtr"/> /// </param> /// <param name="cb"> /// A new panic function. <see cref="CallbackFunction"/> /// </param> public static extern void lua_atpanic( IntPtr state, CallbackFunction cb );
public void SetCallback(CallbackFunction function) { m_callBack = function; }
internal static void CallDelayed(CallbackFunction function, float timeFromNow) { delayedCallback = function; s_DelayedCallbackTime = Time.realtimeSinceStartup + timeFromNow; if (<>f__mg$cache0 == null) {
public static int str_gmatch(LuaState L) { var C = new CallbackFunction(gmatch_aux_2, "gmatch"); var s = ArgAsType(L, 1, DataType.String, false).String; var p = PatchPattern(ArgAsType(L, 2, DataType.String, false).String); C.AdditionalData = new GMatchAuxData { S = new CharPtr(s), P = new CharPtr(p), LS = (uint) s.Length, POS = 0 }; L.Push(DynValue.NewCallback(C)); return 1; }
public void LinearQuery(string query, int start, int pageSize, CallbackFunction.Load<IList<Database.JsonDocument>> callback) { Client.LinearQuery(query, start, pageSize, callback); }
public void LoadMany(CallbackFunction.Load<IList<KeyValuePair<string, Attachment>>> callback) { Client.AttachmentGetAll(callback); }
public static extern void SetCallback(CallbackFunction function);
public void Delete(string name, CallbackFunction.SaveOne<string> callback) { this.Client.IndexDelete(name, callback); }
public void Save(string name, IndexDefinition definition, CallbackFunction.SaveOne<KeyValuePair<string, IndexDefinition>> callback) { this.Client.IndexPut(name, definition, callback); }
public void LoadMany(CallbackFunction.Load<IDictionary<string, IndexDefinition>> callback) { this.Client.IndexGetMany(null, null, callback); }
/// <summary> /// Pushes a C function onto the stack. This function receives a pointer to a C function and pushes onto the stack a Lua value of type function that, when called, invokes the corresponding C function. /// </summary> /// <param name="state"> /// A <see cref="IntPtr"/> /// </param> /// <param name="fn"> /// A <see cref="CallbackFunction"/> /// </param> public static void lua_pushcfunction( IntPtr state, CallbackFunction fn ) { lua_pushcclosure( state, fn, 0 ); }
private int Internal_ExecCall(int argsCount, int instructionPtr, CallbackFunction handler = null, CallbackFunction continuation = null, bool thisCall = false, string debugText = null, DynValue unwindHandler = null) { DynValue fn = m_ValueStack.Peek(argsCount); CallStackItemFlags flags = (thisCall ? CallStackItemFlags.MethodCall : CallStackItemFlags.None); // if TCO threshold reached if ((m_ExecutionStack.Count > this.m_Script.Options.TailCallOptimizationThreshold && m_ExecutionStack.Count > 1) || (m_ValueStack.Count > this.m_Script.Options.TailCallOptimizationThreshold && m_ValueStack.Count > 1)) { // and the "will-be" return address is valid (we don't want to crash here) if (instructionPtr >= 0 && instructionPtr < this.m_RootChunk.Code.Count) { Instruction I = this.m_RootChunk.Code[instructionPtr]; // and we are followed *exactly* by a RET 1 if (I.OpCode == OpCode.Ret && I.NumVal == 1) { CallStackItem csi = m_ExecutionStack.Peek(); // if the current stack item has no "odd" things pending and neither has the new coming one.. if (csi.ClrFunction == null && csi.Continuation == null && csi.ErrorHandler == null && csi.ErrorHandlerBeforeUnwind == null && continuation == null && unwindHandler == null && handler == null) { instructionPtr = PerformTCO(instructionPtr, argsCount); flags |= CallStackItemFlags.TailCall; } } } } if (fn.Type == DataType.ClrFunction) { //IList<DynValue> args = new Slice<DynValue>(m_ValueStack, m_ValueStack.Count - argsCount, argsCount, false); IList<DynValue> args = CreateArgsListForFunctionCall(argsCount, 0); // we expand tuples before callbacks // args = DynValue.ExpandArgumentsToList(args); SourceRef sref = GetCurrentSourceRef(instructionPtr); m_ExecutionStack.Push(new CallStackItem() { ClrFunction = fn.Callback, ReturnAddress = instructionPtr, CallingSourceRef = sref, BasePointer = -1, ErrorHandler = handler, Continuation = continuation, ErrorHandlerBeforeUnwind = unwindHandler, Flags = flags, }); var ret = fn.Callback.Invoke(new ScriptExecutionContext(this, fn.Callback, sref), args, isMethodCall: thisCall); m_ValueStack.RemoveLast(argsCount + 1); m_ValueStack.Push(ret); m_ExecutionStack.Pop(); return Internal_CheckForTailRequests(null, instructionPtr); } else if (fn.Type == DataType.Function) { m_ValueStack.Push(DynValue.NewNumber(argsCount)); m_ExecutionStack.Push(new CallStackItem() { BasePointer = m_ValueStack.Count, ReturnAddress = instructionPtr, Debug_EntryPoint = fn.Function.EntryPointByteCodeLocation, CallingSourceRef = GetCurrentSourceRef(instructionPtr), ClosureScope = fn.Function.ClosureContext, ErrorHandler = handler, Continuation = continuation, ErrorHandlerBeforeUnwind = unwindHandler, Flags = flags, }); return fn.Function.EntryPointByteCodeLocation; } // fallback to __call metamethod var m = GetMetamethod(fn, "__call"); if (m != null && m.IsNotNil()) { DynValue[] tmp = new DynValue[argsCount + 1]; for (int i = 0; i < argsCount + 1; i++) tmp[i] = m_ValueStack.Pop(); m_ValueStack.Push(m); for (int i = argsCount; i >= 0; i--) m_ValueStack.Push(tmp[i]); return Internal_ExecCall(argsCount + 1, instructionPtr, handler, continuation); } throw ScriptRuntimeException.AttemptToCallNonFunc(fn.Type, debugText); }
/// <summary> /// Registers a C function as the global name. /// </summary> /// <param name="state"> /// A <see cref="IntPtr"/> /// </param> /// <param name="name"> /// A <see cref="System.String"/> /// </param> /// <param name="fn"> /// A <see cref="CallbackFunction"/> /// </param> public static void lua_register( IntPtr state, string name, CallbackFunction fn ) { lua_pushcfunction( state, fn ); lua_setglobal( state, name ); }
public void Query(string index, IndexQuery query, string[] includes, CallbackFunction.Load<QueryResult> callback) { this.Client.Query(index, query, includes, callback); }
private WorkItem GetWorkItem(CallbackFunction asyncCallback) { WorkItem workItem; if (!returnedWorkItems.TryDequeue(out workItem)) { workItem = new WorkItem(); workItem.WorkItemStateTypeless = new WorkItemStateTypeless(workItem); } workItem.SingleThreadRunner = null; workItem.IsCompleted = false; workItem.Result = null; workItem.AsyncCallback = asyncCallback; return workItem; }
public void Load(string key, CallbackFunction.Load<KeyValuePair<string, Attachment>> callback) { Client.AttachmentGet(key, callback); }