public async Task <IActionResult> Get(string id) { return(await FunctionWrapper.ExecuteFunction(this, async() => { return await _dashboardPanelRepository.Get(new ObjectId(id)); })); }
public async Task <IActionResult> Get() { return(await FunctionWrapper.ExecuteFunction(this, async() => { return await _workflowTransitionRepository.GetAll(); })); }
public async Task <IActionResult> Post([FromBody] WorkflowTransition item) { return(await FunctionWrapper.ExecuteFunction(this, async() => { return await _workflowTransitionRepository.Add(item); })); }
private bool ProcessDecryptMessage(FunctionWrapper f) { Core.ProcessFunctions.DecryptMessage fDecryptMessage = new Core.ProcessFunctions.DecryptMessage(f); byte[] buffer = fDecryptMessage.GetBuffer(); if (buffer == null) { lbFunction.Invoke(new MethodInvoker(delegate { lbFunction.Text = ""; })); f.status = FunctionWrapper.Status.Forwarded; return(false); } DynamicFileByteProvider dynamicFileByteProvider; mStream = new MemoryStream(); mStream.Write(buffer, 0, buffer.Length); mStream.Seek(0, SeekOrigin.Begin); dynamicFileByteProvider = new DynamicFileByteProvider(mStream); hexBox.Invoke(new MethodInvoker(delegate { hexBox.ByteProvider = dynamicFileByteProvider; })); Search(0); return(true); }
private async Task GenerateForRecord(ObjectGeneration obj, FileGeneration fg) { if (!obj.IsTopClass) { return; } using (var args = new FunctionWrapper(fg, $"public{obj.FunctionOverride()}async Task WriteToXmlFolder")) { args.Add("DirectoryPath dir"); args.Add("string name"); args.Add("XElement node"); args.Add("int counter"); args.Add($"ErrorMaskBuilder? errorMask"); } using (new BraceWrapper(fg)) { using (var args = new ArgsWrapper(fg, "this.WriteToXml")) { args.Add("node: node"); args.Add("errorMask: errorMask"); args.Add("translationMask: null"); } } }
public async Task <IActionResult> Search([FromQuery] ItemSearchRequest requestArgs) { return(await FunctionWrapper.ExecuteFunction(this, async() => { return await _itemRepository.Search(requestArgs); })); }
private bool ProcessRecvFrom(FunctionWrapper f) { Core.ProcessFunctions.recvfrom fRecvfrom = new Core.ProcessFunctions.recvfrom(f); byte[] buffer = fRecvfrom.GetBuffer(); // Esto ocurre cuando la funcion devuelve -1 bytes leidos. Cuando no quedan mas datos que leer. if (buffer == null || buffer.Length == 0) { // Hacemos forward de la función y aceptamos nuevas f.status = FunctionWrapper.Status.Forwarded; //Program.data.AceptingNewFunctions = true; lbFunction.Invoke(new MethodInvoker(delegate { lbFunction.Text = ""; })); return(false); } DynamicFileByteProvider dynamicFileByteProvider; mStream = new MemoryStream(); mStream.Write(buffer, 0, buffer.Length); mStream.Seek(0, SeekOrigin.Begin); dynamicFileByteProvider = new DynamicFileByteProvider(mStream); hexBox.Invoke(new MethodInvoker(delegate { hexBox.ByteProvider = dynamicFileByteProvider; })); Search(0); return(true); }
private static Point GeneralizedNewtonMethod(FunctionWrapper function, Point x0, double h0, double epsilon) { var g = function.Gradient(x0); if (!(g.Normalize() > epsilon)) { return(x0); } double h; var hessian = function.Hess(x0); var hessianInverted = hessian.InvertByJordanGauss(); do { CountThisLoop(); var x = x0; x0 = new Point(new double[x0.Length]); var w = new Vector(new double[x0.Length]); for (var i = 0; i < w.Length; i++) { for (var j = 0; j < w.Length; j++) { w[i] += hessianInverted[i, j] * g[j]; } } h = function.FindHForFastestDescent(x, w, h0, epsilon); x0 = x - h * w; g = function.Gradient(x0); } while (g.Normalize() >= epsilon && Math.Abs(h) > Math.Sqrt(epsilon)); return(x0); }
public async Task <IActionResult> Post([FromBody] ItemType item) { return(await FunctionWrapper.ExecuteFunction(this, async() => { return await _itemTypeRepository.Add(item); })); }
private static Point NewtonMethod(FunctionWrapper function, Point x0, double epsilon) { var g = function.Gradient(x0); if (g.Normalize() > epsilon) { do { CountThisLoop(); var x = x0; var hessian = function.Hess(x0); var hessianInverted = hessian.InvertByJordanGauss(); x0 = new Point(new double[x0.Length]); var w = new Vector(new double[x0.Length]); for (var i = 0; i < w.Length; i++) { for (var j = 0; j < w.Length; j++) { w[i] += hessianInverted[i, j] * g[j]; } } x0 = x - w; g = function.Gradient(x0); } while (g.Normalize() >= epsilon); } return(x0); }
private static Point CoordinateDescent(FunctionWrapper function, Point x0, double h0, double epsilon) { var h = new Vector(new double[x0.Length]); for (var i = 0; i < h.Length; i++) { h[i] = h0; } var xInt = x0.Clone(); Point xExt; do { xExt = xInt.Clone(); for (var i = 0; i < xInt.Length; i++) { Program.CountThisLoop(); var x = xInt.Clone(); var y1 = x.Clone(); y1[i] += 3 * epsilon; var y2 = x.Clone(); y2[i] -= 3 * epsilon; var f1 = function.Eval(y1); var f2 = function.Eval(y2); var z = Math.Sign(f2 - f1); h[i] = function.FindHForCoordinateDescent(xInt.Clone(), z, i, h[i], epsilon); xInt[i] = x[i] + h[i] * z; } } while ((xInt - xExt).Normalize() >= epsilon); return(xInt); }
public async Task <IActionResult> Find([FromBody] List <ObjectId> screenIds) { return(await FunctionWrapper.ExecuteFunction(this, async() => { return await _screenRepository.Find(screenIds); })); }
public async Task <IActionResult> Post([FromBody] DashboardPanel item) { return(await FunctionWrapper.ExecuteFunction(this, async() => { return await _dashboardPanelRepository.Add(item); })); }
public async Task <IActionResult> Get() { return(await FunctionWrapper.ExecuteFunction(this, async() => { return await _dashboardPanelRepository.GetAll(); })); }
public async Task <IActionResult> Post([FromBody] TestCase testCaseR) { return(await FunctionWrapper.ExecuteFunction(this, async() => { return await _testCaseRepository.Add(testCaseR); })); }
private void GetThreadName(ThreadWrapper threadWrapper, ValueWrapper threadObject, NuGenFrameRefresher threadActiveFrameRefresher) { List <ModuleWrapper> modules = threadWrapper.FindModulesByName(GetThreadNameMethod.BaseTypeDefinition.ModuleScope.Assembly.FileName); if (modules.Count == 1) { ModuleWrapper module = modules[0]; FunctionWrapper getThreadNameFunction = module.GetFunction(GetThreadNameMethod.Token); List <ValueWrapper> arguments = new List <ValueWrapper>(1); arguments.Add(threadObject); NuGenEvaluationHandler methodCaller = new NuGenEvaluationHandler(threadActiveFrameRefresher); NuGenBaseEvaluationResult evaluationResult = methodCaller.CallFunction(getThreadNameFunction, arguments); if (evaluationResult.IsSuccessful) { if (evaluationResult.Result != null && (CorElementType)evaluationResult.Result.ElementType == CorElementType.ELEMENT_TYPE_STRING) { ValueWrapper dereferencedResult = evaluationResult.Result.DereferenceValue(); if (dereferencedResult != null) { EvaluatedThreadName = NuGenHelperFunctions.ShowEscapeCharacters(dereferencedResult.GetStringValue(), true); } } } } }
public async Task <IActionResult> Get(string id, [FromQuery] string expand = null) { return(await FunctionWrapper.ExecuteFunction(this, async() => { return await _itemRepository.Get(new ObjectId(id), new ItemExpansionParams(expand)); })); }
public static FunctionWrapper PrepareFunction(FunctionWrapper f, byte[] buffer) { Nektra.Deviare2.INktParam lpBuffers = f.callInfo.Params().GetAt(1); Nektra.Deviare2.INktParam dwBufferCount = f.callInfo.Params().GetAt(2); Nektra.Deviare2.INktParam lpNumberOfBytesRecvd = f.callInfo.Params().GetAt(3); // Numero de estructuras ulong nStructs = dwBufferCount.Memory().Read(dwBufferCount.Address, Nektra.Deviare2.eNktDboFundamentalType.ftUnsignedWord); // Puntero a donde apunta la lista de estructuras IntPtr lpwsabuf = new IntPtr(lpBuffers.Memory().Read(lpBuffers.Address, Nektra.Deviare2.eNktDboFundamentalType.ftUnsignedDoubleWord)); // len. No la leemos de la estructura WSABUF sino de WSARecv Nektra.Deviare2.INktParam NumberOfBytesRecvd = lpNumberOfBytesRecvd.Evaluate(); // *buf IntPtr pBuffer = new IntPtr(lpBuffers.Memory().Read(lpwsabuf + 4, Nektra.Deviare2.eNktDboFundamentalType.ftUnsignedDoubleWord)); // Modificamos el buffer Auxiliar.Memory.WriteMemory(f.callInfo.Process().Id, pBuffer, buffer); // Modificamos el tamaño lpNumberOfBytesRecvd.Value = buffer.Length; return(f); }
public async Task <IActionResult> Get([FromQuery] string imageFileName) { return(await FunctionWrapper.ExecuteFunction(this, async() => { if (string.IsNullOrEmpty(imageFileName)) { return ""; } var url = string.Concat( "https://meticulos.blob.core.windows.net/images/", imageFileName); var blob = new CloudBlockBlob(new Uri(url), GetStorageCredentials()); if (await blob.ExistsAsync()) { await blob.FetchAttributesAsync(); byte[] imageBytes = new byte[blob.Properties.Length]; await blob.DownloadToByteArrayAsync(imageBytes, 0); return Convert.ToBase64String(imageBytes); } return ""; })); }
public void AddEventHandlerToCalculator() { Listener listener = new Listener(); Calculator calculator = new Calculator(); FunctionWrapper <int, int, int, Action <int, int> > wrapper = new FunctionWrapper <int, int, int, Action <int, int> >(listener, null); typeof(Calculator).GetEvent("MyEvent").AddEventHandler(calculator, wrapper.CreateActionDelegate()); calculator.Add(1, 2); Assert.AreEqual(1, listener.X); Assert.AreEqual(2, listener.Y); MethodInfo invoke = typeof(Calculator).GetEvent("MyEvent").EventHandlerType.GetMethod("Invoke"); MethodInfo add = typeof(Calculator).GetEvent("MyEvent").GetAddMethod(); Assert.IsNotNull(add); Assert.AreEqual(1, add.GetParameters().Count()); Assert.IsNotNull(invoke); var parameters = invoke.GetParameters(); var returnparameter = invoke.ReturnParameter; Assert.IsNotNull(returnparameter); Assert.AreEqual("System.Void", returnparameter.ParameterType.FullName); Assert.AreEqual(typeof(MyEvent), typeof(Person).GetEvent("NameEvent").EventHandlerType); }
private bool ProcessWSASendTo(FunctionWrapper f) { //f.status = FunctionWrapper.Status.Forwarded; ////Program.data.AceptingNewFunctions = true; //lbFunction.Invoke(new MethodInvoker(delegate //{ // lbFunction.Text = ""; //})); //return true; //throw new Exception("Not implemented"); Core.ProcessFunctions.WSAsendto fWSASendTo = new Core.ProcessFunctions.WSAsendto(f); byte[] buffer = fWSASendTo.GetBuffer(); DynamicFileByteProvider dynamicFileByteProvider; mStream = new MemoryStream(); mStream.Write(buffer, 0, buffer.Length); mStream.Seek(0, SeekOrigin.Begin); dynamicFileByteProvider = new DynamicFileByteProvider(mStream); hexBox.Invoke(new MethodInvoker(delegate { hexBox.ByteProvider = dynamicFileByteProvider; })); Search(0); return(true); }
public static void GenerateWritePartialMethods( FileGeneration fg, ObjectGeneration obj, TypeGeneration field, bool isAsync) { using (var args = new FunctionWrapper(fg, $"public static partial void WriteBinary{field.Name}Custom{obj.GetGenericTypes(MaskType.Normal)}")) { args.Wheres.AddRange(obj.GenerateWhereClauses(LoquiInterfaceType.IGetter, defs: obj.Generics)); args.SemiColon = true; args.Add($"{nameof(MutagenWriter)} writer"); args.Add($"{obj.Interface(getter: true, internalInterface: true)} item"); } fg.AppendLine(); using (var args = new FunctionWrapper(fg, $"public static void WriteBinary{field.Name}{obj.GetGenericTypes(MaskType.Normal)}")) { args.Wheres.AddRange(obj.GenerateWhereClauses(LoquiInterfaceType.IGetter, defs: obj.Generics)); args.Add($"{nameof(MutagenWriter)} writer"); args.Add($"{obj.Interface(getter: true, internalInterface: true)} item"); } using (new BraceWrapper(fg)) { using (var args = new ArgsWrapper(fg, $"WriteBinary{field.Name}Custom")) { args.Add("writer: writer"); args.Add("item: item"); } } fg.AppendLine(); }
public async Task <IActionResult> Delete(string id) { return(await FunctionWrapper.ExecuteAction(this, async() => { await _workflowRepository.Delete(new ObjectId(id)); })); }
public override async Task GenerateInCommonMixin(ObjectGeneration obj, FileGeneration fg) { if (!await obj.IsMajorRecord()) { return; } if (!obj.IsTopClass) { return; } using (var args = new FunctionWrapper(fg, $"public static {nameof(IMajorRecordCommon)} {nameof(IDuplicatable.Duplicate)}")) { //ToDo // Modify to getter interface after copy is refactored args.Add($"this {obj.ObjectName} item"); args.Add("Func<FormKey> getNextFormKey"); args.Add($"IList<({nameof(IMajorRecordCommon)} Record, FormKey OriginalFormKey)>? duplicatedRecords = null"); } using (new BraceWrapper(fg)) { using (var args = new ArgsWrapper(fg, $"return {obj.CommonClassInstance("item", LoquiInterfaceType.IGetter, CommonGenerics.Class, MaskType.Normal)}.{nameof(IDuplicatable.Duplicate)}")) { args.AddPassArg("item"); args.AddPassArg("getNextFormKey"); args.AddPassArg("duplicatedRecords"); } } }
public override async Task GenerateInCommonMixin(ObjectGeneration obj, FileGeneration fg) { await base.GenerateInCommonMixin(obj, fg); if (!await obj.IsMajorRecord()) { return; } using (var args = new FunctionWrapper(fg, $"public static {obj.ObjectName} Duplicate{obj.GetGenericTypes(MaskType.Normal, MaskType.NormalGetter)}")) { args.Wheres.AddRange(obj.GenericTypeMaskWheres(LoquiInterfaceType.IGetter, MaskType.Normal, MaskType.NormalGetter)); args.Add($"this {obj.Interface(obj.GetGenericTypes(MaskType.NormalGetter), getter: true, internalInterface: true)} item"); args.Add($"{nameof(FormKey)} formKey"); args.Add($"{obj.Mask(MaskType.Translation)}? copyMask = null"); } using (new BraceWrapper(fg)) { using (var args = new ArgsWrapper(fg, $"return {obj.CommonClassInstance("item", LoquiInterfaceType.IGetter, CommonGenerics.Functions, MaskType.NormalGetter)}.Duplicate{obj.GetGenericTypes(MaskType.Normal, MaskType.NormalGetter, MaskType.Translation)}")) { args.AddPassArg("item"); args.AddPassArg("formKey"); args.Add("copyMask: copyMask?.GetCrystal()"); } } fg.AppendLine(); }
public static FunctionWrapper PrepareFunction(FunctionWrapper f, byte[] buffer) { foreach (MatchAndReplace.MatchAndReplace match in Program.data.GetReplaceList()) { if (!match.enabled) { continue; } if (match.replaceIncomming) { bool changed; do { buffer = Searcher.Searcher.ReplaceBytes(buffer, match.match, match.replace, out changed); } while (changed); } } f.callInfo.Result().Value = buffer.Length; f.callInfo.Params().GetAt(2).Value = buffer.Length;; f.callInfo.Params().GetAt(1).set_ValueAt(0, buffer); return(f); }
public async Task <IActionResult> Get(string id) { return(await FunctionWrapper.ExecuteFunction(this, async() => { return await _workflowTransitionRepository.Get(new ObjectId(id)); })); }
public async Task <IActionResult> Search([FromQuery] TestCaseSearchRequest searchRequest) { return(await FunctionWrapper.ExecuteFunction(this, async() => { return await _testCaseRepository.Search(searchRequest); })); }
public static FunctionWrapper PrepareFunction(FunctionWrapper f, byte[] buffer) { Nektra.Deviare2.INktParam lWsabuf = f.callInfo.Params().GetAt(1).Evaluate(); Nektra.Deviare2.INktParam lWsaSendTo = f.callInfo.Params().GetAt(3).Evaluate(); Nektra.Deviare2.INktParam len = lWsabuf.Fields().GetAt(0); Nektra.Deviare2.INktParam pBuff = lWsabuf.Fields().GetAt(1); foreach (MatchAndReplace.MatchAndReplace match in Program.data.GetReplaceList()) { if (!match.enabled) { continue; } if (match.replaceOutcomming) { bool changed; do { buffer = Searcher.Searcher.ReplaceBytes(buffer, match.match, match.replace, out changed); } while (changed); } } len.Value = buffer.Length; pBuff.Value = buffer; return(f); }
public static async Task Main(string[] args) { var config = new ConfigurationBuilder() .SetBasePath(Directory.GetCurrentDirectory()) .AddJsonFile("appsettings.json", true) .AddEnvironmentVariables() .Build(); var configWrapper = new ConfigurationWrapper(config); var topClipsModuleHelper = new TopClipsModuleHelper(configWrapper); var botHelper = new BotHelper(configWrapper); using (var functionWrapper = new FunctionWrapper(configWrapper)) using (var discordWrapper = new DiscordWrapper(configWrapper["BotToken"])) using (var services = new ServiceCollection() .AddSingleton <IDiscordWrapper>(discordWrapper) .AddSingleton <IConfigurationWrapper>(configWrapper) .AddSingleton <IFunctionWrapper>(functionWrapper) .AddSingleton <ITopClipsModuleHelper>(topClipsModuleHelper) .AddSingleton <IBotHelper>(botHelper) .AddLogging(s => s.AddConsole()) .BuildServiceProvider()) { var bot = new Bot(services); await bot.RunAsync(); await Task.Delay(-1); } }