protected internal override Results Match(string userAgent) { bool isMobile = false; // Use RIS to find a match first. Results results = base.Match(userAgent); // If no match with RIS then try edit distance. if (results == null || results.Count == 0) results = Matcher.Match(userAgent, this); // If a match other than edit distance was used then we'll have more confidence // and return the mobile version of the device. if (results.GetType() == typeof (Results)) isMobile = true; Results newResults = new Results(); // Look at the results for one that matches our isMobile setting based on the // matcher used. foreach (Result result in results) { if (result.Device.IsMobileDevice == isMobile) newResults.Add(result.Device); } // Return the new results if any values are available. return newResults; }
public Results Join(Guid partyId, int userId, out IPlayer player) { player = null; var results = new Results(); IParty party = this.GetAllJoinable(userId).Where(p => p.Id == partyId).FirstOrDefault(); if (party != null) { var players = party.Players.Where(p => p.UserId == userId); if (players.Count() == 1) { player = players.ElementAt(0); results.Add(ResultCode.Undefined, @"\Games\mv\map.html?partyId=" + partyId); } } else { results.Add(ResultCode.PartyNotFound); } return results; }
public static Results GetLatestAlertResults(String ipHost, Namespace nameSpace) { if (!latest_results.ContainsKey(nameSpace)) latest_results[nameSpace] = new Dictionary<String, ResultsCounter>(); if (!latest_results[nameSpace].ContainsKey(ipHost)) latest_results[nameSpace].Add(ipHost, new ResultsCounter()); Results results = new Results(); foreach (IResult result in latest_results[nameSpace][ipHost].Results.ToEnumerable()) { if(!result.Ok) results.Add(result); } return results; }
public bool Login(string userName, string password, bool rememberMe, out Results results) { bool ok = WebSecurity.Login(userName, password, persistCookie: rememberMe); results = new Results(); if (ok) { var user = base.Resolve<IUserRepository>().GetUserByUserName(userName); if (user != null) CreateAuthTicket(userName, Guid.Empty, string.Empty, rememberMe, HttpContext.Current.Response, user.Nick, Guid.Empty); } if (!ok) results.Add(ResultCode.LoginError); return ok; }
public void Update(GameResult result) { Results.Add(result); }
public override void ExecuteInternal() { if (!roots.Any()) { if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) { foreach (var driveInfo in DriveInfo.GetDrives()) { if (driveInfo.IsReady && driveInfo.DriveType == DriveType.Fixed) { roots.Add(driveInfo.Name); } } } else if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux)) { roots.Add("/"); } else if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX)) { roots.Add("/"); } } Action <string> IterateOn = Path => { Log.Verbose("Started parsing {0}", Path); FileSystemObject obj = FilePathToFileSystemObject(Path, downloadCloud, INCLUDE_CONTENT_HASH); if (obj != null) { Results.Add(obj); // TODO: Also try parse .DER as a key if (Path.EndsWith(".cer", StringComparison.CurrentCulture) || Path.EndsWith(".der", StringComparison.CurrentCulture) || Path.EndsWith(".p7b", StringComparison.CurrentCulture) || Path.EndsWith(".pfx", StringComparison.CurrentCulture)) { try { using var certificate = new X509Certificate2(Path); var certObj = new CertificateObject( StoreLocation: StoreLocation.LocalMachine.ToString(), StoreName: StoreName.Root.ToString(), Certificate: new SerializableCertificate(certificate)); Results.Add(certObj); } catch (Exception e) { Log.Verbose($"Could not parse certificate from file: {Path}, {e.GetType().ToString()}"); } } } Log.Verbose("Finished parsing {0}", Path); }; foreach (var root in roots) { Log.Information("{0} root {1}", Strings.Get("Scanning"), root); var filePathEnumerable = DirectoryWalker.WalkDirectory(root); if (parallel) { filePathEnumerable.AsParallel().ForAll(filePath => { IterateOn(filePath); }); } else { foreach (var filePath in filePathEnumerable) { IterateOn(filePath); } } } }
public override void Parse() { string linkText = string.Empty; string linkURL = string.Empty; try { byte[] fileByteArray = Utility.GetFileByteArray(FileUrl); if (fileByteArray != null) { using (MemoryStream fileStream = new MemoryStream(fileByteArray, false)) { Mail_Message mime = Mail_Message.ParseFromStream(fileStream); HtmlDocument doc = new HtmlDocument(); string html = string.IsNullOrEmpty(mime.BodyHtmlText) ? mime.BodyText : mime.BodyHtmlText; if (!string.IsNullOrEmpty(html)) { doc.LoadHtml(html); foreach (HtmlNode link in doc.DocumentNode.SelectNodesOrEmpty("//a[@href]")) { if (link.Attributes["href"].Value.StartsWith("#", StringComparison.InvariantCultureIgnoreCase) == false && link.Attributes["href"].Value.StartsWith("javascript:", StringComparison.InvariantCultureIgnoreCase) == false && link.Attributes["href"].Value.StartsWith("mailto:", StringComparison.InvariantCultureIgnoreCase) == false) { linkURL = link.Attributes["href"].Value; if (link.FirstChild == link.LastChild) { linkText = link.InnerText; } else { linkText = link.LastChild.InnerText; } linkText = new string(linkText.ToCharArray()).Replace("\r\n", " "); FileLink objLink = new FileLink() { ParentFileUrl = FileUrl, LinkText = linkText, LinkAddress = linkURL }; Results.Add(objLink); } } } } } } catch (Exception ex) { FileLink objLink = new FileLink() { ParentFileUrl = FileUrl, LinkText = "Error occurred when parsing this file.", LinkAddress = ex.Message, hasError = true }; Results.Add(objLink); } }
public Result AddResult(Result arg) { arg.C_RowId = ++_rowCounter; Results.Add(arg); return(arg); }
void ExecuteConvert(object sender, EventArgs e) { var result = _model.SecretLogic(); Results.Add(result); }
public GyroTemperatureCalibrator(IRUSDevice device) : base(device) { Results.Add(_measureResult); }
/// <summary> /// Adds the result of a test method into the log. /// </summary> /// <param name="test">The test metadata.</param> /// <param name="storage">The storage value.</param> /// <param name="codeBase">The code base value.</param> /// <param name="adapterTypeName">The adapter type name.</param> /// <param name="className">The class name.</param> /// <param name="testListName">The test list name.</param> /// <param name="computerName">The computer name.</param> /// <param name="startTime">The start time.</param> /// <param name="endTime">The end time.</param> /// <param name="outcome">The outcome.</param> public void AddTestMethodResult( ITestMethod test, string storage, string codeBase, string adapterTypeName, string className, string testListName, string computerName, DateTime startTime, DateTime endTime, TestOutcome outcome) { if (test == null) { throw new ArgumentNullException("test"); } // Friendly name of the test string name = test.Name; // Generate GUIDs. string testId = Guid.NewGuid().ToString(); string executionId = Guid.NewGuid().ToString(); string testListId = GetTestListGuid(testListName); // UnitTest element. SimpleXElement unitTest = CreateElement("UnitTest"); unitTest.SetAttributeValue("name", name); unitTest.SetAttributeValue("storage", storage); unitTest.SetAttributeValue("id", testId); SimpleXElement owners = CreateElement("Owners"); SimpleXElement owner = CreateElement("Owner"); string ownerString = test.Owner ?? string.Empty; owner.SetAttributeValue("name", ownerString); owners.Add(owner); unitTest.Add(owners); if (!string.IsNullOrEmpty(test.Description)) { SimpleXElement description = CreateElement("Description"); description.SetValue(test.Description); unitTest.Add(description); } SimpleXElement execution = CreateElement("Execution"); execution.SetAttributeValue("id", executionId); unitTest.Add(execution); // TestMethod element. SimpleXElement testMethod = CreateElement("TestMethod"); testMethod.SetAttributeValue("codeBase", codeBase); testMethod.SetAttributeValue("adapterTypeName", adapterTypeName); testMethod.SetAttributeValue("className", className); testMethod.SetAttributeValue("name", name); unitTest.Add(testMethod); TestDefinitions.Add(unitTest); // TestEntry element. SimpleXElement testEntry = CreateElement("TestEntry"); testEntry.SetAttributeValue("testId", testId); testEntry.SetAttributeValue("executionId", executionId); testEntry.SetAttributeValue("testListId", testListId); TestEntries.Add(testEntry); // UnitTestResult element. SimpleXElement unitTestResult = CreateElement("UnitTestResult"); unitTestResult.SetAttributeValue("executionId", executionId); unitTestResult.SetAttributeValue("testId", testId); unitTestResult.SetAttributeValue("testName", name); unitTestResult.SetAttributeValue("computerName", computerName); TimeSpan duration = endTime.Subtract(startTime); unitTestResult.SetAttributeValue("duration", duration.ToString()); unitTestResult.SetAttributeValue("startTime", ToDateString(startTime)); unitTestResult.SetAttributeValue("endTime", ToDateString(endTime)); unitTestResult.SetAttributeValue("testType", UnitTestTestTypeId); unitTestResult.SetAttributeValue("outcome", outcome.ToString()); unitTestResult.SetAttributeValue("testListId", testListId.ToString()); // Add any pending items foreach (SimpleXElement pending in _pendingElements) { unitTestResult.Add(pending); } _pendingElements.Clear(); Results.Add(unitTestResult); }
private static void SecondPass(VersionHandler handler, int[] maxCharacters, List<DeviceResult> initialResults, Results results) { int lowestScore = int.MaxValue; foreach (DeviceResult current in initialResults) { // Calculate the score for this device. int deviceScore = 0; for (int segment = 0; segment < handler.VersionRegexes.Length; segment++) { deviceScore += (maxCharacters[segment] - current.Scores[segment].CharactersMatched + 1)* (current.Scores[segment].Difference + maxCharacters[segment] - current.Scores[segment].CharactersMatched); } // If the score is lower than the lowest so far then reset the list // of best matching devices. if (deviceScore < lowestScore) { results.Clear(); lowestScore = deviceScore; } // If the device score is the same as the lowest score so far then add this // device to the list. if (deviceScore == lowestScore) { results.Add(current.Device); } } }
protected override void Run() { var solution = CreateZeroRSolution(Problem.ProblemData); Results.Add(new Result("ZeroR solution", "The simplest possible classifier, ZeroR always predicts the majority class.", solution)); }
public Row(string owner) { Results.Add(owner, new MatchResult('X', 0)); }
private async Task AllCompanyScoresYieldResults(IEnumerable <ScoringParam> sps) { foreach (ScoringParam sp in sps) { // 2. There are companies with non-zero values string scoreTable; switch (sp.ScoringType) { case CompanyScoringType.CompanyTextBagOfWords: case CompanyScoringType.PatentClassProfile: case CompanyScoringType.TopicScore: scoreTable = "company_score_real"; break; case CompanyScoringType.IndustryAttribute: scoreTable = "company_score_str"; break; case CompanyScoringType.OrbisTemporalAttribute: scoreTable = (sp.ScoreDataType == "real" ? "company_time_score_real" : scoreTable = "company_time_score_int"); break; case CompanyScoringType.ManualScore: scoreTable = (sp.ScoreDataType == "real" ? "company_score_real" : (sp.ScoreDataType == "nvarchar" ? scoreTable = "company_score_str" : scoreTable = "company_score_int")); break; case CompanyScoringType.OrbisAttribute: scoreTable = "unknown"; break; default: scoreTable = "unknown"; break; } using (var cmd = Db.CreateCommand()) { if (scoreTable == "unknown") { cmd.CommandText = @"select count(distinct isnull(csr.company_id,isnull(csi.company_id,isnull(css.company_id,isnull(csrt.company_id,csit.company_id))))) as NumberOfScoredCompanies from (select @p1 as score_name) s LEFT OUTER JOIN company_score_real csr ON csr.score_name=s.score_name LEFT OUTER JOIN company_score_int csi ON csi.score_name=s.score_name LEFT OUTER JOIN company_score_str css ON css.score_name=s.score_name LEFT OUTER JOIN company_time_score_real csrt ON csrt.score_name=s.score_name LEFT OUTER JOIN company_time_score_int csit ON csit.score_name=s.score_name"; } else { cmd.CommandText = @"select count(distinct company_id) as NumberOfScoredCompanies from " + scoreTable + @" where score_name=@p1"; } cmd.Parameters.AddWithValue("@p1", sp.ScoringLabel); using (var reader = await cmd.ExecuteReaderAsync()) { while (await reader.ReadAsync() && !Program.StopNow) { int nc = (int)reader["NumberOfScoredCompanies"]; Results.Add(new TestResult { Message = String.Format("Encountered {1} score-values for [{0}].", sp.ScoringLabel, nc), Name = "ScoresHaveValues", Success = (nc > 0), }); } } } } }
public void SendMails() { try { logger.Debug("Summarized mails..."); foreach (var mailcache in MailCaches) { var summarizedMail = GetMailFromSummarizedMailList(mailcache.Settings); if (summarizedMail == null) { logger.Debug("Create new mail for summarized mail list..."); var mailTo = mailcache.Settings?.To?.Replace(";", ",")?.TrimEnd(',') ?? "No mail recipient was specified."; var mailFrom = mailcache.Settings?.MailServer?.From ?? "No sender was specified."; summarizedMail = new MailMessage(mailFrom, mailTo) { BodyEncoding = Encoding.UTF8, SubjectEncoding = Encoding.UTF8, Subject = mailcache.Settings?.Subject?.Trim() ?? "No subject was specified.", }; var ccAddresses = mailcache.Settings?.Cc?.Replace(";", ",")?.TrimEnd(','); if (!String.IsNullOrEmpty(ccAddresses)) { summarizedMail.CC.Add(ccAddresses); } var bccAddresses = mailcache.Settings?.Bcc?.Replace(";", ",")?.TrimEnd(','); if (!String.IsNullOrEmpty(bccAddresses)) { summarizedMail.Bcc.Add(bccAddresses); } var msgBody = mailcache.Settings?.Message?.Trim() ?? String.Empty; switch (mailcache.Settings?.MailType ?? EMailType.TEXT) { case EMailType.TEXT: msgBody = msgBody.Replace("{n}", Environment.NewLine); break; case EMailType.HTML: summarizedMail.IsBodyHtml = true; break; case EMailType.MARKDOWN: summarizedMail.IsBodyHtml = true; msgBody = Markdown.ToHtml(msgBody); break; default: throw new Exception($"Unknown mail type {mailcache.Settings?.MailType}."); } msgBody = msgBody.Trim(); logger.Debug($"Set mail body '{msgBody}'..."); summarizedMail.Body = msgBody; if (mailcache.Settings.SendAttachment) { logger.Debug($"Attachment report files..."); AddReportstoMail(summarizedMail, mailcache.Report); } else { logger.Debug($"Use no mail attachment..."); } SummarizedMails.Add(summarizedMail); } else { logger.Debug("Duplicate Mail settings was found in summarized mail list..."); if (mailcache.Settings.SendAttachment) { logger.Debug($"Attachment report files..."); AddReportstoMail(summarizedMail, mailcache.Report); } else { logger.Debug($"Use no mail attachment..."); } } } var mailServers = MailCaches.Select(c => c.Settings).Select(s => s.MailServer).GroupBy(s => s.Host).Select(s => s.First()).ToList(); logger.Debug($"Send {SummarizedMails.Count} Mails over {MailCaches.Count} mail servers..."); foreach (var mailServer in mailServers) { var mailResult = new MailResult(); try { foreach (var summarizedMail in SummarizedMails) { using var client = new SmtpClient(mailServer.Host, mailServer.Port); var priateKeyPath = HelperUtilities.GetFullPathFromApp(mailServer.PrivateKey); if (!File.Exists(priateKeyPath)) { logger.Debug("No private key path found..."); } if (!String.IsNullOrEmpty(mailServer.Username) && !String.IsNullOrEmpty(mailServer.Password)) { logger.Debug($"Set mail server credential for user '{mailServer.Username}'..."); var password = mailServer.Password; if (mailServer.UseBase64Password && File.Exists(priateKeyPath)) { logger.Debug($"Use private key path {priateKeyPath}..."); var textCrypter = new TextCrypter(priateKeyPath); password = textCrypter.DecryptText(password); } client.Credentials = new NetworkCredential(mailServer.Username, password); } else { logger.Debug($"No mail server credential found..."); } if (mailServer.UseSsl) { logger.Debug($"Use SSL for mail sending..."); client.EnableSsl = true; } if (mailServer.UseCertificate && File.Exists(priateKeyPath)) { var certifcateFolder = Path.GetDirectoryName(priateKeyPath); logger.Info($"Search for email certificates with name 'mailcert.*' in folder '{certifcateFolder}'..."); var certFiles = Directory.GetFiles(certifcateFolder, "mailcert.*", SearchOption.TopDirectoryOnly); foreach (var certFile in certFiles) { logger.Debug($"Load certificate '{certFile}'."); var x509File = new X509Certificate2(certFile); logger.Debug($"Add certificate '{certFile}'."); client.ClientCertificates.Add(x509File); } } if (summarizedMail.To.Count > 0) { var delay = 0; if (mailServer.SendDelay > 0) { delay = mailServer.SendDelay * 1000; logger.Debug($"Wait {delay} milliseconds for the mail to be sent..."); } Task.Delay(delay).ContinueWith(r => { logger.Debug("Send mail package..."); client.Send(summarizedMail); mailResult.Message = "The mail was sent successfully."; mailResult.Success = true; mailResult.TaskName = JobResult.TaskName; mailResult.ReportState = GetFormatedState(); }).Wait(); } else { mailResult.Message = "Mail without mail Address could not be sent."; logger.Error(mailResult.Message); mailResult.Success = false; mailResult.TaskName = JobResult.TaskName; mailResult.ReportState = "ERROR"; JobResult.Exception = ReportException.GetException(mailResult.Message); JobResult.Status = TaskStatusInfo.ERROR; } client.Dispose(); Results.Add(mailResult); } } catch (Exception ex) { logger.Error(ex, $"The delivery via 'Mail' failed with server '{mailServer.Host}'."); JobResult.Exception = ReportException.GetException(ex); JobResult.Status = TaskStatusInfo.ERROR; mailResult.Success = false; mailResult.ReportState = "ERROR"; mailResult.TaskName = JobResult.TaskName; mailResult.Message = JobResult?.Exception?.FullMessage ?? null; Results.Add(mailResult); } } } catch (Exception ex) { logger.Error(ex, "The delivery via 'Mail' failed."); JobResult.Exception = ReportException.GetException(ex); JobResult.Status = TaskStatusInfo.ERROR; var errorResult = new MailResult() { Success = false, ReportState = "ERROR", TaskName = JobResult?.TaskName ?? "Unknown Task", Message = JobResult?.Exception?.FullMessage ?? null }; Results.Add(errorResult); } }
public static void benchmarkGraph(Graph graph, int avg_iterations, bool usebrute) { Results results = new Results(); Console.WriteLine("Benchmarking graph with {0} vertices and {1} edges.", graph.VerticesCount, graph.EdgesCount); for (int i = 0; i < avg_iterations; i++) { Result res = new Result(); res.vertices = graph.VerticesCount; res.edges = graph.EdgesCount; int[] result; long elapsedMs; Stopwatch watch; Console.WriteLine("Starting iteration " + i); if (usebrute) { watch = System.Diagnostics.Stopwatch.StartNew(); result = BruteForce.Solve(ref graph); watch.Stop(); elapsedMs = watch.ElapsedMilliseconds; bool tmp = graph.IsColoringValid(); res.bruteChromaticNum = graph.ChromaticNumber(); res.bruteTimeMs = elapsedMs; res.bruteValid = graph.IsColoringValid(); } watch = System.Diagnostics.Stopwatch.StartNew(); result = SmallestLast.Solve(ref graph); watch.Stop(); elapsedMs = watch.ElapsedMilliseconds; res.smallestlastChromaticNum = graph.ChromaticNumber(); res.smallestlastTimeMs = elapsedMs; res.smallestlastValid = graph.IsColoringValid(); watch = System.Diagnostics.Stopwatch.StartNew(); result = DSatur.Solve(ref graph); watch.Stop(); elapsedMs = watch.ElapsedMilliseconds; res.dsaturChromaticNum = graph.ChromaticNumber(); res.dsaturTimeMs = elapsedMs; res.dsaturValid = graph.IsColoringValid(); watch = System.Diagnostics.Stopwatch.StartNew(); result = BFSColoring.Solve(ref graph); watch.Stop(); elapsedMs = watch.ElapsedMilliseconds; res.bfsChromaticNum = graph.ChromaticNumber(); res.bfsTimeMs = elapsedMs; res.bfsValid = graph.IsColoringValid(); results.Add(res); //Console.WriteLine(String.Format("{0};{1};{2};{3};{4};{5};{6};{7};", // res.bruteTimeMs, res.bruteChromaticNum, // res.smallestlastTimeMs, res.smallestlastChromaticNum, // res.bfsTimeMs, res.bfsChromaticNum, // res.dsaturTimeMs, res.dsaturChromaticNum)); } Console.WriteLine("Brute ms;XBrute;BFS ms;Xbfs;DS ms;Xds;SL ms;Xsl"); Console.WriteLine(String.Format("{0};{1};{2};{3};{4};{5};{6};{7};" , results.AvgBruteMs(), results.AvgBruteChromaticNum() , results.AvgBFSMs(), results.AvgBFSChromaticNum() , results.AvgDSMs(), results.AvgDSChromaticNum() , results.AvgSLMs(), results.AvgSLChromaticNum())); Console.WriteLine("Benchmark done. Press key to exit..."); Console.ReadKey(); }
public IResults Geocode(string _address) { Results results = new Results(); Uri uriRequest = new Uri(c_strRequestUri + "\"" + _address + "\""); HttpWebRequest request = (HttpWebRequest)WebRequest.Create(uriRequest); WebProxy proxy = null; IWebProxy proxySystem = HttpWebRequest.GetSystemWebProxy(); Uri uriProxy = proxySystem.GetProxy(uriRequest); if (uriProxy != uriRequest) { proxy = new WebProxy(uriProxy); proxy.UseDefaultCredentials = true; request.Proxy = proxy; } HttpWebResponse response = (HttpWebResponse)request.GetResponse(); String content = new StreamReader(response.GetResponseStream()).ReadToEnd(); Regex reg = new Regex( "\"Name\":\"(?<name>.*?)\".*?,\"BestLocation\":{.*?\"Latitude\":(?<lat>.*?),\"Longitude\":(?<lon>.*?)}}.*?\"Locality\":\"(?<locality>.*?)\",.*?\"AdminDistrict\":\"(?<state>.*?)\",\"PostalCode\":\"(?<code>.*?)\",\"CountryRegion\":\"(?<country>.*?)\"" , RegexOptions.IgnoreCase); foreach (Match match in reg.Matches(content)) //mResult.Result("${result}" { Result r = new Result(); r.Address = match.Result("${name}"); r.Country = match.Result("${country}"); r.City = match.Result("${locality}"); r.State = match.Result("${state}"); r.Zip = match.Result("${code}"); try { r.Latitude = Double.Parse(match.Result("${lat}")); r.Longitude = Double.Parse(match.Result("${lon}")); } catch (ArgumentNullException) { } catch (FormatException) { } catch (OverflowException) { } results.Add(r); } /* Regex regex = new Regex(@"AddLocation\(.*?\)", RegexOptions.IgnoreCase); MatchCollection matchCollection = regex.Matches(content); foreach (Match match in matchCollection) { Double dLongitude; Double dLatitude; String m = match.Value.Remove(0, 12); m = m.Remove(m.Length - 1); if (!m.StartsWith("'")) continue; Int32 a = m.IndexOf("'", 1); if (a == -1) continue; String address = HttpUtility.HtmlDecode(m.Substring(1, a - 1)); m = m.Substring(a + 1); String[] marr = m.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries); try { dLongitude = Convert.ToDouble(marr[1].Trim(), CultureInfo.InvariantCulture); dLatitude = Convert.ToDouble(marr[0].Trim(), CultureInfo.InvariantCulture); } catch (InvalidCastException) { continue; } results.Add(new Result(address, dLongitude, dLatitude)); } regex = new Regex(@"new Array\('.*?',.*?\)", RegexOptions.IgnoreCase); matchCollection = regex.Matches(content); foreach (Match match in matchCollection) { Double dLongitude; Double dLatitude; String m = match.Value.Remove(0, 10); m = m.Remove(m.Length - 1); if (!m.StartsWith("'")) continue; Int32 a = m.IndexOf("'", 1); if (a == -1) continue; String address = HttpUtility.HtmlDecode(m.Substring(1, a - 1)); m = m.Substring(a + 1); String[] marr = m.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries); try { dLongitude = (Convert.ToDouble(marr[1].Trim(), CultureInfo.InvariantCulture) + Convert.ToDouble(marr[3].Trim(), CultureInfo.InvariantCulture)) / 2; dLatitude = (Convert.ToDouble(marr[0].Trim(), CultureInfo.InvariantCulture) + Convert.ToDouble(marr[2].Trim(), CultureInfo.InvariantCulture)) / 2; } catch (InvalidCastException) { continue; } results.Add(new Result(address, dLongitude, dLatitude)); } if (results.Count == 0) { regex = new Regex(@"SetViewport\(.*?\)", RegexOptions.IgnoreCase); Match match = regex.Match(content); if (match.Success) { Double dLongitude; Double dLatitude; String m = match.Value.Remove(0, 12); m = m.Remove(m.Length - 1); String[] marr = m.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries); try { dLongitude = (Convert.ToDouble(marr[1].Trim(), CultureInfo.InvariantCulture) + Convert.ToDouble(marr[3].Trim(), CultureInfo.InvariantCulture)) / 2; dLatitude = (Convert.ToDouble(marr[0].Trim(), CultureInfo.InvariantCulture) + Convert.ToDouble(marr[2].Trim(), CultureInfo.InvariantCulture)) / 2; results.Add(new Result("", dLongitude, dLatitude)); } catch (InvalidCastException) { } } } */ return results; }
private async void OnStopped(Results results) { string reason = results.TryFindString("reason"); if (reason.StartsWith("exited")) { string threadGroupId = results.TryFindString("id"); if (!String.IsNullOrEmpty(threadGroupId)) { lock (_debuggeePids) { _debuggeePids.Remove(threadGroupId); } } if (IsLocalGdbAttach()) { CmdExitAsync(); } this.ProcessState = ProcessState.Exited; if (ProcessExitEvent != null) { ProcessExitEvent(this, new ResultEventArgs(results)); } return; } //if this is an exception reported from LLDB, it will not currently contain a frame object in the MI //if we don't have a frame, check if this is an excpetion and retrieve the frame if (!results.Contains("frame") && string.Compare(reason, "exception-received", StringComparison.OrdinalIgnoreCase) == 0 ) { //get the info for the current frame Results frameResult = await MICommandFactory.StackInfoFrame(); //add the frame to the stopping results results.Add("frame", frameResult.Find("frame")); } bool fIsAsyncBreak = MICommandFactory.IsAsyncBreakSignal(results); if (await DoInternalBreakActions(fIsAsyncBreak)) { return; } this.ProcessState = ProcessState.Stopped; FlushBreakStateData(); if (!results.Contains("frame")) { if (ModuleLoadEvent != null) { ModuleLoadEvent(this, new ResultEventArgs(results)); } } else if (BreakModeEvent != null) { if (fIsAsyncBreak) { _requestingRealAsyncBreak = false; } BreakModeEvent(this, new ResultEventArgs(results)); } }
public override void Search() { Results.Clear(); byte[] text = (byte[])Params["text"]; ProcessHandle phandle; int count = 0; bool opt_priv = (bool)Params["private"]; bool opt_img = (bool)Params["image"]; bool opt_map = (bool)Params["mapped"]; bool nooverlap = (bool)Params["nooverlap"]; if (text.Length == 0) { CallSearchFinished(); return; } try { phandle = new ProcessHandle(PID, ProcessAccess.QueryInformation | Program.MinProcessReadMemoryRights); } catch { CallSearchError("Could not open process: " + Win32.GetLastErrorMessage()); return; } phandle.EnumMemory(info => { // skip unreadable areas if (info.Protect == MemoryProtection.AccessDenied) { return(true); } if (info.State != MemoryState.Commit) { return(true); } if ((!opt_priv) && (info.Type == MemoryType.Private)) { return(true); } if ((!opt_img) && (info.Type == MemoryType.Image)) { return(true); } if ((!opt_map) && (info.Type == MemoryType.Mapped)) { return(true); } byte[] data = new byte[info.RegionSize.ToInt32()]; int bytesRead = 0; CallSearchProgressChanged( String.Format("Searching 0x{0} ({1} found)...", info.BaseAddress.ToString("x"), count)); try { bytesRead = phandle.ReadMemory(info.BaseAddress, data, data.Length); if (bytesRead == 0) { return(true); } } catch { return(true); } for (int i = 0; i < bytesRead; i++) { bool good = true; for (int j = 0; j < text.Length; j++) { if (i + j > bytesRead - 1) { continue; } if (data[i + j] != text[j]) { good = false; break; } } if (good) { Results.Add(new string[] { Utils.FormatAddress(info.BaseAddress), String.Format("0x{0:x}", i), text.Length.ToString(), "" }); count++; if (nooverlap) { i += text.Length - 1; } } } return(true); }); phandle.Dispose(); CallSearchFinished(); }
protected override void Run(CancellationToken cancellationToken) { var solution = CreateOneRSolution(Problem.ProblemData, MinBucketSizeParameter.Value.Value); Results.Add(new Result("OneR solution", "The 1R classifier.", solution)); }
public void Insert(string search, Item item, ref MergeResult result, int pos = 0) { TraversalOption nextStep = new TraversalOption(Label, search, pos); switch (nextStep.option) { case TraversalOptions.Found: if (!Items.Any(item1 => item1.ComparePath(item))) { Items.Add(item); Results.Add(item); result.ToBeMergedInto = Results; result.NeedsMerge = true; } break; case TraversalOptions.MoveNext: if (NextNode == null) { NextNode = new SearchNode { Label = search.Substring(pos) }; NextNode.Items.Add(item); NextNode.Results.Add(item); result.ToBeMergedInto = NextNode.Results; result.NeedsMerge = true; } else { NextNode.Insert(search, item, ref result, pos); } break; case TraversalOptions.MoveDown: if (ChildNode == null) { ChildNode = new SearchNode() { Label = search.Substring(pos + nextStep.commonPrefixLength), Items = new List <Item>(), }; ChildNode.Items.Add(item); ChildNode.Results.Add(item); result.ToBeMergedInto = ChildNode.Results; result.NeedsMerge = true; if (result.NeedsMerge) { result.NeedsMerge = Results.MergeIntoList(result.ToBeMergedInto) > 0; result.ToBeMergedInto = Results; } } else { ChildNode.Insert(search, item, ref result, pos + nextStep.commonPrefixLength); if (result.NeedsMerge) { result.NeedsMerge = Results.MergeIntoList(result.ToBeMergedInto) > 0; result.ToBeMergedInto = Results; } } break; case TraversalOptions.Split: SearchNode newNode = new SearchNode { Label = Label.Substring(nextStep.commonPrefixLength), Items = Items, Results = Results, ChildNode = ChildNode }; Items = new List <Item>(); Results = new MergedResultList(newNode.ResultItems); Label = Label.Substring(0, nextStep.commonPrefixLength); ChildNode = newNode; if (search.Length == nextStep.commonPrefixLength + pos) { Items.Add(item); Results.Add(item); } else { SearchNode toInsert = new SearchNode { Label = search.Substring(nextStep.commonPrefixLength + pos), Items = new List <Item> { item }, Results = new MergedResultList(new List <Item> { item }) }; Results.MergeIntoList(toInsert.Results); newNode.NextNode = toInsert; } result.ToBeMergedInto = Results; result.NeedsMerge = true; break; } }
private CharacterGroupListItemViewModel?GenerateFrom(CharacterGroup characterGroup, int deepLevel, IList <CharacterGroup> pathToTop) { if (!characterGroup.IsVisible(CurrentUserId)) { return(null); } var prevCopy = Results.FirstOrDefault(cg => cg.FirstCopy && cg.CharacterGroupId == characterGroup.CharacterGroupId); var vm = new CharacterGroupListItemViewModel { CharacterGroupId = characterGroup.CharacterGroupId, DeepLevel = deepLevel, Name = characterGroup.CharacterGroupName, FirstCopy = prevCopy == null, AvaiableDirectSlots = characterGroup.HaveDirectSlots ? characterGroup.AvaiableDirectSlots : 0, IsAcceptingClaims = characterGroup.IsAcceptingClaims(), ActiveCharacters = prevCopy?.ActiveCharacters ?? GenerateCharacters(characterGroup) .ToList(), Description = characterGroup.Description.ToHtmlString(), ActiveClaimsCount = characterGroup.Claims.Count(c => c.ClaimStatus.IsActive()), Path = pathToTop.Select(cg => Results.First(item => item.CharacterGroupId == cg.CharacterGroupId)), IsPublic = characterGroup.IsPublic, IsSpecial = characterGroup.IsSpecial, IsRootGroup = characterGroup.IsRoot, ProjectId = characterGroup.ProjectId, RootGroupId = Root.CharacterGroupId, }; if (Root == characterGroup) { vm.First = true; vm.Last = true; } if (vm.IsSpecial) { var variant = characterGroup.GetBoundFieldDropdownValueOrDefault(); if (variant != null) { vm.BoundExpression = $"{variant.ProjectField.FieldName} = {variant.Label}"; } } Results.Add(vm); if (prevCopy != null) { vm.ChildGroups = prevCopy.ChildGroups; return(vm); } var childGroups = characterGroup.GetOrderedChildGroups().OrderBy(g => g.IsSpecial).Where(g => g.IsActive && g.IsVisible(CurrentUserId)).ToList(); var pathForChildren = pathToTop.Union(new[] { characterGroup }).ToList(); vm.ChildGroups = childGroups.Select(childGroup => GenerateFrom(childGroup, deepLevel + 1, pathForChildren)).ToList().MarkFirstAndLast(); return(vm); }
internal void Add(PartialResult partialResult) { Results.Add(partialResult); }
protected override void Run(CancellationToken cancellationToken) { IRegressionProblemData problemData = Problem.ProblemData; IEnumerable <string> selectedInputVariables = problemData.AllowedInputVariables; int nSv; ISupportVectorMachineModel model; Run(problemData, selectedInputVariables, SvmType.Value, KernelType.Value, Cost.Value, Nu.Value, Gamma.Value, Epsilon.Value, Degree.Value, out model, out nSv); if (CreateSolution) { var solution = new SupportVectorRegressionSolution((SupportVectorMachineModel)model, (IRegressionProblemData)problemData.Clone()); Results.Add(new Result("Support vector regression solution", "The support vector regression solution.", solution)); } Results.Add(new Result("Number of support vectors", "The number of support vectors of the SVR solution.", new IntValue(nSv))); { // calculate regression model metrics var ds = problemData.Dataset; var trainRows = problemData.TrainingIndices; var testRows = problemData.TestIndices; var yTrain = ds.GetDoubleValues(problemData.TargetVariable, trainRows); var yTest = ds.GetDoubleValues(problemData.TargetVariable, testRows); var yPredTrain = model.GetEstimatedValues(ds, trainRows).ToArray(); var yPredTest = model.GetEstimatedValues(ds, testRows).ToArray(); OnlineCalculatorError error; var trainMse = OnlineMeanSquaredErrorCalculator.Calculate(yPredTrain, yTrain, out error); if (error != OnlineCalculatorError.None) { trainMse = double.MaxValue; } var testMse = OnlineMeanSquaredErrorCalculator.Calculate(yPredTest, yTest, out error); if (error != OnlineCalculatorError.None) { testMse = double.MaxValue; } Results.Add(new Result("Mean squared error (training)", "The mean of squared errors of the SVR solution on the training partition.", new DoubleValue(trainMse))); Results.Add(new Result("Mean squared error (test)", "The mean of squared errors of the SVR solution on the test partition.", new DoubleValue(testMse))); var trainMae = OnlineMeanAbsoluteErrorCalculator.Calculate(yPredTrain, yTrain, out error); if (error != OnlineCalculatorError.None) { trainMae = double.MaxValue; } var testMae = OnlineMeanAbsoluteErrorCalculator.Calculate(yPredTest, yTest, out error); if (error != OnlineCalculatorError.None) { testMae = double.MaxValue; } Results.Add(new Result("Mean absolute error (training)", "The mean of absolute errors of the SVR solution on the training partition.", new DoubleValue(trainMae))); Results.Add(new Result("Mean absolute error (test)", "The mean of absolute errors of the SVR solution on the test partition.", new DoubleValue(testMae))); var trainRelErr = OnlineMeanAbsolutePercentageErrorCalculator.Calculate(yPredTrain, yTrain, out error); if (error != OnlineCalculatorError.None) { trainRelErr = double.MaxValue; } var testRelErr = OnlineMeanAbsolutePercentageErrorCalculator.Calculate(yPredTest, yTest, out error); if (error != OnlineCalculatorError.None) { testRelErr = double.MaxValue; } Results.Add(new Result("Average relative error (training)", "The mean of relative errors of the SVR solution on the training partition.", new DoubleValue(trainRelErr))); Results.Add(new Result("Average relative error (test)", "The mean of relative errors of the SVR solution on the test partition.", new DoubleValue(testRelErr))); } }
public void ProcessTemplate() { // Initialize the template TemplateContext.Iterators.Clear(); TemplateClass.TemplateSetup(); foreach ( var item in TemplateClass.GetType() .GetCustomAttributes(typeof(TemplateAttribute), true) .OfType <TemplateAttribute>().OrderBy(p => p.Priority)) { item.Modify(TemplateClass, null, TemplateContext); } var initializeMethods = TemplateClass.GetType().GetMethods(BindingFlags.Instance | BindingFlags.Public).Where(p => p.IsDefined(typeof(TemplateSetup), true)).ToArray(); foreach (var item in initializeMethods) { item.Invoke(TemplateClass, null); } InvertApplication.SignalEvent <ICodeTemplateEvents>(_ => _.TemplateGenerating(TemplateClass, TemplateContext)); foreach (var templateProperty in TemplateProperties) { if (FilterToMembers != null && !FilterToMembers.Contains(templateProperty.Key.Name)) { continue; } foreach (var item in TemplateContext.RenderTemplateProperty(TemplateClass, templateProperty)) { Results.Add(new TemplateMemberResult(this, templateProperty.Key, templateProperty.Value, item, Decleration)); } } foreach (var templateMethod in TemplateMethods) { if (FilterToMembers != null && !FilterToMembers.Contains(templateMethod.Key.Name)) { continue; } foreach (var item in TemplateContext.RenderTemplateMethod(TemplateClass, templateMethod)) { Results.Add(new TemplateMemberResult(this, templateMethod.Key, templateMethod.Value, item, Decleration)); } } foreach (var templateConstructor in TemplateConstructors) { if (FilterToMembers != null && !FilterToMembers.Contains(templateConstructor.Key.Name)) { continue; } foreach (var item in TemplateContext.RenderTemplateConstructor(TemplateClass, templateConstructor)) { Results.Add(new TemplateMemberResult(this, templateConstructor.Key, templateConstructor.Value, item, Decleration)); } } var postMethods = TemplateClass.GetType().GetMethods(BindingFlags.Instance | BindingFlags.Public).Where(p => p.IsDefined(typeof(TemplateComplete), true)).ToArray(); foreach (var item in postMethods) { item.Invoke(TemplateClass, null); } var list = new List <CodeNamespaceImport>(); foreach (var item in TemplateContext.Namespace.Imports) { list.Add((CodeNamespaceImport)item); } TemplateContext.Namespace.Imports.Clear(); foreach (var item in list.OrderBy(p => p.Namespace)) { TemplateContext.Namespace.Imports.Add(item); } }
//////////////////////////////////////////////////////////////////////////////////////////////////// /// \fn public override void ReceiveHandling(BaseMessage message) /// /// \brief Receive handling. /// /// \par Description. /// -# This method is activated when a new message arrived to the process /// -# The method processing is done according to their arrival order /// -# If you want to change the order of processing use the ArrangeMessageQ /// /// \par Algorithm. /// /// \par Usage Notes. /// Usually the algorithm of this method is: /// -# if message type is ... perform ... /// -# if message type is ... perform ... /// /// \author Ilan Hindy /// \date 26/01/2017 /// /// \param message The message. //////////////////////////////////////////////////////////////////////////////////////////////////// //public override void ReceiveHandling(BaseMessage message) //{ //ChandyLamport_NewStyleChannel channel = (ChandyLamport_NewStyleChannel)ChannelFrom(message); //ChandyLamport_NewStyleMessage msg = message as ChandyLamport_NewStyleMessage; //switch ((msg.MessageType) //{ // case BaseMessage: // // If the process performed snapshot but still did not get marker from all // // it's neighbors : // // Save the message - It will be sent as message in the channels // if (Recordered && !channel.Recorderd) // { // channel.State.Add(msg.Name); // } // break; // case (int)Marker: // // If the process received a marker: // // Add the weight in the marker // // Perform TakeSnapshot (If first Marker in round - Send Marker to all the neighbors) // Weight += msg.MarkerWeight; // TakeSnapshot(); // // Check if the round ended (Received Marker from all it's neighbors) // // Perform EndSnapshot (Send Report, reset variables) // channel.or[c.ork.Recorderd] = true; // if (InChannels.All(cnl => cnl.or[c.ork.Recorderd])) // { // EndSnapshot(); // } // // Change the text on the process because the weight changed // pp[bp.ppk.Text] = GetProcessDefaultName() + "\n" + or[p.ork.Weight]; // break; // case m.MessageTypes.Report: // // If received a Report Message // // If this is not the first report from the source processor in this round // // (or the previouse round because a report can come befor or after // // the marker throw the message // if (message[bm.pak.Round] < or[bp.ork.Round] - 1 || // ((AttributeList)or[p.ork.ReceivedMessageFrom]).Any((a => a.Value == (int)message[m.report.Id]))) // { // break; // } // else // { // or[p.ork.ReceivedMessageFrom].Add(message[m.report.Id]); // } // // If the process is the initiator // // Add the message to the results // // Add the weight to the process weight // // Check condition for end round (weight == 1) // // Check condition for end running (round = max rounds) // if (ea[bp.eak.Initiator]) // { // or[p.ork.Results].Add(message[m.report.Snapshot]); // or[p.ork.Weight] += message[m.report.ReportWeight]; // pp[bp.ppk.Text] = GetProcessDefaultName() + "\n" + or[p.ork.Weight]; // if (or[p.ork.Weight] == 1) // { // PrintResults(); // if (or[bp.ork.Round] < pa[p.pak.MaxRounds]) // { // TakeSnapshot(); // } // else // { // Terminate(); // } // } // } // // If the process is not the initiator // // Propagate the message to all the neighbors // else // { // SendToNeighbours(message, SelectingMethod.Exclude, new List<int> { (int)message[m.report.Id] }); // } // break; //} public override void ReceiveHandling(BaseMessage message) { ChandyLamport_NewStyleChannel channel = (ChandyLamport_NewStyleChannel)ChannelFrom(message); ChandyLamport_NewStyleMessage msg = message as ChandyLamport_NewStyleMessage; switch (msg.MessageType) { case BaseMessage: // If the process performed snapshot but still did not get marker from all // it's neighbors : // Save the message - It will be sent as message in the channels if (Recorderd && !channel.Recorderd) { channel.State.Add(msg.Name); } break; case Marker: // If the process received a marker: // Add the weight in the marker // Perform TakeSnapshot (If first Marker in round - Send Marker to all the neighbors) Weight += msg.MarkerWeight; TakeSnapshot(); // Check if the round ended (Received Marker from all it's neighbors) // Perform EndSnapshot (Send Report, reset variables) channel.or[c.ork.Recorderd] = true; if (InChannels.All(cnl => ((ChandyLamport_NewStyleChannel)cnl).Recorderd)) { EndSnapshot(); } // Change the text on the process because the weight changed Text = GetProcessDefaultName() + "\n" + Weight; break; case Report: // If received a Report Message // If this is not the first report from the source processor in this round // (or the previouse round because a report can come befor or after // the marker throw the message if (msg.Round < Round - 1 || (ReceivedMessageFrom.Any(a => a.Value == msg.Id))) { break; } else { ReceivedMessageFrom.Add(msg.Id); } // If the process is the initiator // Add the message to the results // Add the weight to the process weight // Check condition for end round (weight == 1) // Check condition for end running (round = max rounds) if (Initiator) { Results.Add(msg.Snapshot); Weight += msg.ReportWeight; Text = GetProcessDefaultName() + "\n" + Weight; if (Weight == 1) { PrintResults(); if (Round < MaxRounds) { TakeSnapshot(); } else { Terminate(); } } } // If the process is not the initiator // Propagate the message to all the neighbors else { SendToNeighbours(msg, SelectingMethod.Exclude, new List <int> { msg.Id }); } break; } }
public void Start() { float percent = 0, cpercent = 0.0f; double scalex, scaley; int c, crot = 0; //Shape temp; Matrix points; Matrix ctrans, m, m2, r; SPoint center; foreach (Shape s in b) { points = a.ShapePoints; ctrans = Matrix.Indentity(3); //temp = a; scalex = a.ShapeBitmap.Width < s.ShapeBitmap.Width ? Math.Round(s.Center.X / a.Center.X) : 1 / Math.Round(a.Center.X / s.Center.X); scaley = a.ShapeBitmap.Height < s.ShapeBitmap.Height ? Math.Round(s.Center.X / a.Center.X) : 1 / Math.Round(a.Center.X / s.Center.X); ctrans *= Matrix.Scale(scalex, scaley); center = a.Center; center.X *= (float)scalex; center.Y *= (float)scaley; points *= ctrans; /*crot = 0;-----------------BROKEN ROTATION STUFF * for (int i = 0; i < 8; i++) * { * //points = a.ShapePoints; * * m = Matrix.Translation(-center.X, -center.Y); * r = Matrix.Rotation(Math.PI/4); * m2 = Matrix.Translation(center.X, center.Y); * ctrans *= (m * r * m2); * * temp.ShapePoints *= ctrans; * * temp.ResetPoints(); * * //points *= ctrans; * * c = Hit(s, temp.ShapePoints); * percent = ((float)c / (float)temp.ShapePoints.Count()) * 100.0f; * * if (percent > cpercent) * { * cpercent = percent; * crot = i; * if (percent == 100.0f) * { * break; * } * * } * } * crot *= 45;*/ c = Hit(s, points); percent = ((float)c / (float)a.ShapePoints.Count()) * 100.0f; Percent.Add(percent); Results.Add(s.Name); Scale.Add(scalex.ToString("0.0") + "," + scaley.ToString("0.0")); //Rotation.Add(crot.ToString()); } }
public void Traverse(TSqlFragment node) { if (nestingLevel++ == 1) { Results.Add(new ParseResults()); } ; Debug.Assert(nestingLevel < 10, "Maximum recursion level exceeded."); switch (node) { case InsertStatement insSt: Result.SetStatementType(StatementType.Insert); Traverse(insSt.InsertSpecification); break; case InsertSpecification ins: Result.SetTargetTableFromTableRef(ins.Target); if (ins.InsertSource is SelectInsertSource) { Traverse(((SelectInsertSource)ins.InsertSource).Select); } break; case DeleteStatement delSt: Result.SetStatementType(StatementType.Delete); Traverse(delSt.DeleteSpecification); break; case UpdateStatement updSt: Result.SetStatementType(StatementType.Update); Traverse(updSt.UpdateSpecification); break; case UpdateSpecification us: Result.SetTargetTableFromTableRef(us.Target); if (us.FromClause != null) { Traverse(((FromClause)us.FromClause).TableReferences[0]); } if (us.Target.IsNull() && Result.Alias.BinarySearch(Result.TargetTable) > 0 ) { Result.SetTargetTableFromAlias(); Result.SetFeature(Features.UpdateTargetPointsToAlias); } if (us.WhereClause != null) { Result.SetFeature(Features.HasWhereClause); } break; case SelectStatement selSt: Result.SetStatementType(StatementType.Select); Result.SetTargetTableFromSchema(selSt.Into); Traverse(((QuerySpecification)(selSt.QueryExpression))); break; case CreateTableStatement createTableSt: Result.SetStatementType(StatementType.CreateTable); Result.SetFeature(Features.IsDDL); break; case AlterTableStatement alterTableSt: Result.SetStatementType(StatementType.AlterTable); Result.SetFeature(Features.IsDDL); break; case TruncateTableStatement truncateTableSt: Result.SetStatementType(StatementType.TruncateTable); Result.SetFeature(Features.IsDDL); break; case DeclareVariableStatement declareVariableSt: Result.SetStatementType(StatementType.DeclareVariable); break; case SetVariableStatement setVariableSt: Result.SetStatementType(StatementType.SetVariable); break; case QuerySpecification qs: if (qs.WhereClause != null) { Result.SetFeature(Features.HasWhereClause); } Traverse(qs.FromClause.TableReferences[0]); break; case UnqualifiedJoin uj: Traverse(uj.FirstTableReference); Traverse(uj.SecondTableReference); break; case QualifiedJoin qj: Traverse(qj.FirstTableReference); Traverse(qj.SecondTableReference); break; case BinaryQueryExpression bqs: Traverse(bqs.FirstQueryExpression); Traverse(bqs.SecondQueryExpression); break; case NamedTableReference tr: Result.SourceTables.Add(tr.SchemaObject.FullyQualifiedName()); Result.Alias.Add(string.Format("[{0}]", tr.Alias != null ? tr.Alias.Value : "")); break; default: Debug.Assert(false, "This node type is not implemented yet!!!"); break; } --nestingLevel; }
private async void OnStopped(Results results) { string reason = results.TryFindString("reason"); if (reason.StartsWith("exited") || reason.StartsWith("disconnected")) { if (this.ProcessState != ProcessState.Exited) { this.ProcessState = ProcessState.Exited; if (ProcessExitEvent != null) { ProcessExitEvent(this, new ResultEventArgs(results)); } } return; } //if this is an exception reported from LLDB, it will not currently contain a frame object in the MI //if we don't have a frame, check if this is an exception and retrieve the frame if (!results.Contains("frame") && (string.Compare(reason, "exception-received", StringComparison.OrdinalIgnoreCase) == 0 || string.Compare(reason, "signal-received", StringComparison.OrdinalIgnoreCase) == 0) ) { //get the info for the current frame Results frameResult = await MICommandFactory.StackInfoFrame(); //add the frame to the stopping results results = results.Add("frame", frameResult.Find("frame")); } bool fIsAsyncBreak = MICommandFactory.IsAsyncBreakSignal(results); if (await DoInternalBreakActions(fIsAsyncBreak)) { return; } this.ProcessState = ProcessState.Stopped; FlushBreakStateData(); if (!results.Contains("frame")) { if (ModuleLoadEvent != null) { ModuleLoadEvent(this, new ResultEventArgs(results)); } } else if (BreakModeEvent != null) { BreakRequest request = _requestingRealAsyncBreak; _requestingRealAsyncBreak = BreakRequest.None; BreakModeEvent(this, new StoppingEventArgs(results, request)); } }
public void CopyFile(Report report, FileSettings settings, Connection socketConnection) { var reportName = report?.Name ?? null; try { if (String.IsNullOrEmpty(reportName)) { throw new Exception("The report filename is empty."); } var target = settings?.Target?.Trim() ?? null; if (target == null) { var message = $"No target file path for report '{reportName}' found."; logger.Error(message); JobResult.Exception = ReportException.GetException(message); JobResult.Status = TaskStatusInfo.ERROR; Results.Add(new FileResult() { Success = false, ReportState = "ERROR", TaskName = JobResult.TaskName, Message = message, ReportName = reportName }); return; } if (!target.ToLowerInvariant().StartsWith("lib://") && socketConnection != null) { var message = $"Target value '{target}' is not a 'lib://' connection."; logger.Error(message); JobResult.Exception = ReportException.GetException(message); JobResult.Status = TaskStatusInfo.ERROR; Results.Add(new FileResult() { Success = false, ReportState = "ERROR", Message = message, TaskName = JobResult.TaskName, ReportName = reportName }); return; } var targetPath = String.Empty; if (PathCache.ContainsKey(target)) { targetPath = PathCache[target]; } else { targetPath = ResolveLibPath(target, socketConnection); PathCache.Add(target, targetPath); } logger.Info($"Use the following resolved path '{targetPath}'..."); var fileCount = 0; foreach (var reportPath in report.Paths) { var targetFile = Path.Combine(targetPath, $"{NormalizeReportName(reportName)}{Path.GetExtension(reportPath)}"); if (report.Paths.Count > 1) { fileCount++; targetFile = Path.Combine(targetPath, $"{NormalizeReportName(reportName)}_{fileCount}{Path.GetExtension(reportPath)}"); } var fileData = report.Data.FirstOrDefault(f => f.Filename == Path.GetFileName(reportPath)); logger.Info($"Copy with distibute mode '{settings.Mode}'..."); switch (settings.Mode) { case DistributeMode.OVERRIDE: Directory.CreateDirectory(targetPath); File.WriteAllBytes(targetFile, fileData.DownloadData); break; case DistributeMode.DELETEALLFIRST: if (File.Exists(targetFile)) { File.Delete(targetFile); } Directory.CreateDirectory(targetPath); File.WriteAllBytes(targetFile, fileData.DownloadData); break; case DistributeMode.CREATEONLY: if (File.Exists(targetFile)) { throw new Exception($"The file '{targetFile}' does not exist."); } File.WriteAllBytes(targetFile, fileData.DownloadData); break; default: throw new Exception($"Unkown distribute mode {settings.Mode}"); } logger.Info($"The file '{targetFile}' was copied..."); Results.Add(new FileResult() { Success = true, ReportState = GetFormatedState(), TaskName = JobResult.TaskName, ReportName = reportName, Message = "Report was successful created.", CopyPath = targetFile }); } } catch (Exception ex) { logger.Error(ex, "The delivery process for 'files' failed."); JobResult.Exception = ReportException.GetException(ex); JobResult.Status = TaskStatusInfo.ERROR; Results.Add(new FileResult() { Success = false, ReportState = "ERROR", TaskName = JobResult.TaskName, Message = ex.Message, ReportName = reportName }); } finally { PathCache.Clear(); if (socketConnection != null) { socketConnection.IsFree = true; } } }
/// <summary> /// Callback for task threads /// </summary> public void ReceiveResult(byte[] binData, object taskInfo) { Results.Add(new TaskResult(binData, (TaskInfo)taskInfo)); }
/// <summary> /// Add a Error severity result to the Results list. /// </summary> /// <param name="description">Human-readable description of /// why the rule failed.</param> public void AddErrorResult(string description) { Results.Add(new RuleResult(Rule.RuleName, Rule.PrimaryProperty, description)); }
protected override void Initialize(CancellationToken cancellationToken) { Results.Add(new Result(BestQualityResultName, new DoubleValue(double.NaN))); Results.Add(new Result(IterationsResultName, new IntValue(0))); base.Initialize(cancellationToken); }
static int Main(string[] args) { if (args.Length > 2) { System.Diagnostics.Debugger.Launch(); } if (args.Length < 1) { Console.WriteLine("Usage: parseStats logfile"); return -1; } if (args[0].StartsWith(@"*\")) { var components = args[0].Split('\\'); var results = new Results(); // first dir is key Contract.Assume(components.Count() > 0, "Follows from the fact that Split return a non-empty array"); foreach (var file in Directory.EnumerateFiles(".", components.Last(), SearchOption.AllDirectories)) { var fileComps = file.Split('\\'); if (Matches(components, fileComps)) { var lr = RunOneLog(file); var stats = Sum(lr); results.Add(fileComps[1], stats); } } PrintStats(results, args.Length > 1); } else { var lr = RunOneLog(args[0]); PrintStats(lr, args.Length > 1); } return 0; }
public override void AddResult(Document result) { Results.Add(result); }
protected override void Add(TypeDeclarationSyntax type, AttributeSyntax att) { var r = new ClassWithAttributeResult(type as ClassDeclarationSyntax, att); Results.Add(r); }
private static List<Result> GetProjectResults(Results all, string projectName) { Contract.Ensures(Contract.Result<List<Result>>() != null); List<Result> list; if (!all.TryGetValue(projectName, out list)) { list = new List<Result>(); all.Add(projectName, list); } else { Contract.Assume(list != null); } return list; }
private void DoSearch() { var criteria = new SearchCriteria(); ((RangeFilterFieldViewModel)NumConditions).Parse(out criteria.NumConditions, out criteria.NumConditionsComparison); ((RangeFilterFieldViewModel)NumAltGroups).Parse(out criteria.NumAltGroups, out criteria.NumAltGroupsComparison); criteria.Flag = (RequirementType)Flag.SelectedId; criteria.SourceType = (FieldType)SourceType.SelectedId; ((RangeFilterFieldViewModel)SourceValue).Parse(out criteria.SourceValue, out criteria.SourceValueComparison); criteria.Comparison = (RequirementOperator)Comparison.SelectedId; criteria.TargetType = (FieldType)TargetType.SelectedId; ((RangeFilterFieldViewModel)TargetValue).Parse(out criteria.TargetValue, out criteria.TargetValueComparison); ((RangeFilterFieldViewModel)HitCount).Parse(out criteria.HitCount, out criteria.HitCountComparison); var directory = _settings.DumpDirectory; var filesToRead = 0; if (IsCoreAchievementsScanned || IsNonCoreAchievementsScanned) { filesToRead += Snapshot.AchievementGameCount; } if (IsLeaderboardCancelScanned || IsLeaderboardStartScanned || IsLeaderboardSubmitScanned) { filesToRead += Snapshot.LeaderboardGameCount; } if (IsRichPresenceScanned) { filesToRead += Snapshot.RichPresenceCount; } Progress.Reset(filesToRead); Progress.IsEnabled = true; var results = new List <Result>(); if (IsCoreAchievementsScanned || IsNonCoreAchievementsScanned) { Progress.Label = "Processing Achievements..."; foreach (var gameId in Snapshot.GamesWithAchievements) { Progress.Current++; if (!Progress.IsEnabled) { break; } var file = Path.Combine(directory, gameId + ".json"); var contents = File.ReadAllText(file); var json = new Jamiras.IO.Serialization.JsonObject(contents); var patchData = json.GetField("PatchData"); var achievements = patchData.ObjectValue.GetField("Achievements").ObjectArrayValue; if (achievements == null) { continue; } var gameName = patchData.ObjectValue.GetField("Title").StringValue; foreach (var achievement in achievements) { var flags = achievement.GetField("Flags").IntegerValue; if (!IsCoreAchievementsScanned) { if (flags == 3) { continue; } } else if (!IsNonCoreAchievementsScanned) { if (flags != 3) { continue; } } var memAddr = achievement.GetField("MemAddr").StringValue; if (Matches(memAddr, criteria)) { results.Add(new Result { GameId = gameId, GameName = gameName, AchievementId = achievement.GetField("ID").IntegerValue.GetValueOrDefault(), ItemName = achievement.GetField("Title").StringValue, Details = memAddr, IsUnofficial = flags == 5 }); } } } } if (IsLeaderboardStartScanned || IsLeaderboardSubmitScanned || IsLeaderboardCancelScanned) { Progress.Label = "Processing Leaderboards..."; foreach (var gameId in Snapshot.GamesWithLeaderboards) { Progress.Current++; if (!Progress.IsEnabled) { break; } var file = Path.Combine(directory, gameId + ".json"); var contents = File.ReadAllText(file); var json = new Jamiras.IO.Serialization.JsonObject(contents); var patchData = json.GetField("PatchData"); var leaderboards = patchData.ObjectValue.GetField("Leaderboards").ObjectArrayValue; if (leaderboards == null) { continue; } var gameName = patchData.ObjectValue.GetField("Title").StringValue; foreach (var leaderboard in leaderboards) { var details = String.Empty; var token = Token.Empty; var memAddr = leaderboard.GetField("Mem").StringValue; foreach (var part in Tokenizer.Split(memAddr, ':')) { if (part == "STA" && IsLeaderboardStartScanned) { token = part; continue; } if (part == "CAN" && IsLeaderboardCancelScanned) { token = part; continue; } if (part == "SUB" && IsLeaderboardSubmitScanned) { token = part; continue; } if (token.IsEmpty) { continue; } if (Matches(part.ToString(), criteria)) { if (details.Length > 0) { details += ", "; } details += token.ToString(); details += ':'; details += part.ToString(); } token = Token.Empty; } if (details.Length > 0) { results.Add(new Result { GameId = gameId, GameName = gameName, LeaderboardId = leaderboard.GetField("ID").IntegerValue.GetValueOrDefault(), ItemName = "Leaderboard: " + leaderboard.GetField("Title").StringValue, Details = details, }); } } } } if (IsRichPresenceScanned) { Progress.Label = "Processing Rich Presence..."; foreach (var gameId in Snapshot.GamesWithRichPresence) { Progress.Current++; if (!Progress.IsEnabled) { break; } var file = Path.Combine(directory, gameId + ".json"); var contents = File.ReadAllText(file); var json = new Jamiras.IO.Serialization.JsonObject(contents); var patchData = json.GetField("PatchData"); var richPresence = patchData.ObjectValue.GetField("RichPresencePatch").StringValue; if (richPresence != null) { int index = richPresence.IndexOf("Display:"); if (index != -1) { var details = String.Empty; foreach (var line in richPresence.Substring(index).Split('\n')) { if (line.Trim().Length == 0) { break; } if (line.StartsWith("?")) { index = line.IndexOf('?', 1); if (index != -1) { var memAddr = line.Substring(1, index - 1); if (Matches(memAddr, criteria)) { if (details.Length > 0) { details += ", "; } details += '?'; details += memAddr; details += '?'; } } } } if (details.Length > 0) { results.Add(new Result { GameId = gameId, GameName = patchData.ObjectValue.GetField("Title").StringValue, ItemName = "Rich Presence", Details = details, }); } } } } } if (Progress.IsEnabled) { results.Sort((l, r) => { var diff = String.Compare(l.GameName, r.GameName); if (diff == 0) { diff = String.Compare(l.ItemName, r.ItemName); } return(diff); }); _backgroundWorkerService.InvokeOnUiThread(() => { Results.Clear(); foreach (var result in results) { Results.Add(result); } }); Progress.IsEnabled = false; Progress.Label = String.Empty; } }
/// <summary> /// Renders the rules. /// </summary> /// <returns> </returns> public IValidationContext RenderRules() { results = new Results(); if (rules == null || rules.Count < 1) { return this; } else { //sort rules based on priority; rules.Sort(); } foreach (RulePolicy rule in rules) { if (!exitRuleRendering) { rule.OnRuleRendered += OnRuleRenderedHandler; results.Add(rule.Execute()); } else { break; } } ProcessResults(); return this; }
public override void Write(HttpRequestData result) { // don't log request detail data for non errors over a certain no of requests if (!result.IsError && RequestsProcessed > 30000) { // always clear response result.ResponseContent = null; // detail data only if we explicitly requested if (_stressTester.Options.CaptureMinimalResponseData) { result.Headers = null; result.ResponseHeaders = null; result.FullRequest = null; result.RequestContent = null; } } bool writeOut = false; var savedResults = Results; int savedCount = 0; lock (InsertLock) { Results.Add(result); RequestsProcessed++; if (result.IsError) { RequestsFailed++; } if (Results.Count >= MaxCollectionItems) { FileCount++; savedCount = FileCount; writeOut = true; Results = null; Results = new List <HttpRequestData>(); } } if (writeOut) { //Console.WriteLine(); ThreadPool.QueueUserWorkItem((parm) => { //Console.WriteLine("QUWI Thread: " + Thread.CurrentThread.ManagedThreadId); FileWriteParms parms = (FileWriteParms)parm; var file = Path.Combine(TempFolderName, BaseFilename + parms.FileCount + ".json"); JsonSerializationUtils.SerializeToFile(parms.Requests, file, false); //SerializationUtils.SerializeObject(parms.Requests, file, true); //if (ResultsList == null) // ResultsList = new List<List<HttpRequestData>>(); //ResultsList.Add(parms.Requests); ////ResultsList.Add(null); //ResultsList[ResultsList.Count-1] = parms.Requests; //var r = parms.Requests; //Console.WriteLine("Queued Item " + parms.FileCount + " " + r.Count); //IFormatter formatter = new BinaryFormatter(); //Stream stream = new FileStream(file, FileMode.Create, FileAccess.Write, FileShare.None); //formatter.Serialize(stream, parms.Requests); //stream.Close(); }, new FileWriteParms { FileCount = savedCount, Requests = savedResults }); //Console.WriteLine("Queue Use Worker Item time: " + swatch.ElapsedTicks.ToString("N0") + " " + Thread.CurrentThread.ManagedThreadId); } }