public IHttpActionResult Post(int matchId, [FromBody] EntryToAdd entryToAdd) { List <FishingMatch> fishingMatches = DataFileService.GetDataFile <FishingMatch>(DataFileType.Matches).ToList(); FishingMatch fishingMatch = fishingMatches.SingleOrDefault(match => match.Id == matchId); if (fishingMatch == null) { return(NotFound()); } var matchEntry = new MatchEntry { AnglerName = entryToAdd.AnglerName, AnglerId = entryToAdd.AnglerId, Peg = entryToAdd.Peg, Weight = entryToAdd.Pounds + (entryToAdd.Ounces / OuncesInPound) }; fishingMatch.MatchEntries.Add(matchEntry); fishingMatch.CalculateMatchPoints(); DataFileService.WriteDataFile(DataFileType.Matches, fishingMatches); return(Created(string.Empty, entryToAdd)); }
/// <summary> /// The Init method is invoked to initialize an instance /// of the matcher with a version definition registry that /// it can use to lookup information about vesions as it is /// matching messages. /// </summary> /// <param name="registry"> /// The version definition registry that the matcher is to /// use when looking up version information. /// </param> public void Init(IVfxFixVxRegistry registry) { // REC: Iterate over all of the version definitions // in the registry and construct corresponding match // entries for the matcher: foreach (VfxFixVxRecord vxRecord in registry) { // REC: The version name: string vxName = vxRecord.Name; MatchEntry matchEntry = new MatchEntry(); matchEntry.Name = vxName; VfxFixVxRecord vxDetails = registry.Get(vxName); foreach (VfxFixVersion_Rule vxRule in vxDetails.Rules) { matchEntry.Rules.Add(vxRule); } if (!_mapLayers.ContainsKey(vxDetails.Layer)) { _mapLayers.Add(vxDetails.Layer, new List <MatchEntry>()); } _mapLayers[vxDetails.Layer].Add(matchEntry); } }
private static List <ChampionshipRound> GetChampionshipRounds(IEnumerable <FishingMatch> matches, string anglerName) { var rounds = new List <ChampionshipRound>(); var championshipRoundIndex = 1; foreach (FishingMatch match in matches) { MatchEntry anglerMatchEntry = match.MatchEntries.SingleOrDefault(matchEntry => matchEntry.AnglerName == anglerName); var championshipRound = new ChampionshipRound { Number = championshipRoundIndex, Weight = 0, Points = 0, MatchFished = false }; if (anglerMatchEntry != null) { championshipRound.Weight = anglerMatchEntry.Weight; championshipRound.Points = anglerMatchEntry.Points; championshipRound.MatchFished = true; } rounds.Add(championshipRound); championshipRoundIndex += 1; } return(rounds); }
protected LexerArgumentBuilder(MatchEntry matchEntry) { MatchEntry = matchEntry; if (matchEntry is SingleMatchEntry singleMatchEntry) { StaticLexemeText = StaticLexemes[singleMatchEntry.IntOperand]; } }
private Node ConnectEntry(Node source, Entry entry) { return(entry switch { MatchEntry matchEntry => ConnectMatch(source, matchEntry), StateEntry stateEntry => ConnectState(source, stateEntry, stateEntry.State.Inline || Automata.ForceInlineAll), QuantifierEntry quantifierEntry => ConnectQuantifier(source, quantifierEntry), PredicateEntryBase predicateEntry => ConnectPredicate(source, predicateEntry), ActionEntry actionEntry => ConnectAction(source, actionEntry), EpsilonEntry _ => source, _ => throw new ArgumentOutOfRangeException(nameof(entry)) });
public IEnumerable <PairResult> GetPairsMatch([FromUri] int id) { FishingMatch fishingMatch = Get(id); var pairResults = new List <PairResult>(); if (!fishingMatch.IsPairs) { return(pairResults); } foreach (MatchEntry matchEntry in fishingMatch.MatchEntries) { bool toAdd = !pairResults.Any(pair => pair.Peg1 == matchEntry.Peg || pair.Peg2 == matchEntry.Peg); if (!toAdd) { continue; } var matchEntryPair = new List <MatchEntry> { matchEntry }; MatchEntry pairedMatchEntry = fishingMatch.MatchEntries.Single(me => me.PairedWithPeg == matchEntry.Peg); matchEntryPair.Add(pairedMatchEntry); var pairResult = new PairResult { Angler1 = matchEntryPair[0].AnglerName, Angler2 = matchEntryPair[1].AnglerName, Peg1 = matchEntryPair[0].Peg, Peg2 = matchEntryPair[1].Peg, Weight = matchEntryPair[0].Weight + matchEntryPair[1].Weight }; if (pairResult.Peg1 == pairResult.Peg2) { pairResult.Peg2 = null; pairResult.Angler2 = "(weight doubled)"; } pairResults.Add(pairResult); } return(pairResults.OrderByDescending(result => result.Weight)); }
public override int GetHashCode() { unchecked { var hashCode = MinorVersion.GetHashCode(); hashCode = (hashCode * 397) ^ MajorVersion.GetHashCode(); hashCode = (hashCode * 397) ^ (PropMask?.GetHashCode() ?? 0); hashCode = (hashCode * 397) ^ (ForeColor?.GetHashCode() ?? 0); hashCode = (hashCode * 397) ^ (BackColor?.GetHashCode() ?? 0); hashCode = (hashCode * 397) ^ (int)VariousPropertyBits; hashCode = (hashCode * 397) ^ (Caption?.GetHashCode() ?? 0); hashCode = (hashCode * 397) ^ (int)PicturePosition; hashCode = (hashCode * 397) ^ (int)MousePointer; hashCode = (hashCode * 397) ^ (Accelerator?.GetHashCode() ?? 0); hashCode = (hashCode * 397) ^ (Size?.GetHashCode() ?? 0); hashCode = (hashCode * 397) ^ (Picture?.Length.GetHashCode() ?? 0); hashCode = (hashCode * 397) ^ (MouseIcon?.Length.GetHashCode() ?? 0); hashCode = (hashCode * 397) ^ (TextProps?.GetHashCode() ?? 0); hashCode = (hashCode * 397) ^ (int)MaxLength; hashCode = (hashCode * 397) ^ (int)BorderStyle; hashCode = (hashCode * 397) ^ (ScrollBars?.GetHashCode() ?? 0); hashCode = (hashCode * 397) ^ DisplayStyle.GetHashCode(); hashCode = (hashCode * 397) ^ (PasswordChar?.GetHashCode() ?? 0); hashCode = (hashCode * 397) ^ (int)ListWidth; hashCode = (hashCode * 397) ^ BoundColumn.GetHashCode(); hashCode = (hashCode * 397) ^ TextColumn.GetHashCode(); hashCode = (hashCode * 397) ^ ColumnCount.GetHashCode(); hashCode = (hashCode * 397) ^ ListRows.GetHashCode(); hashCode = (hashCode * 397) ^ ColumnInfoCount.GetHashCode(); hashCode = (hashCode * 397) ^ MatchEntry.GetHashCode(); hashCode = (hashCode * 397) ^ ListStyle.GetHashCode(); hashCode = (hashCode * 397) ^ ShowDropButtonWhen.GetHashCode(); hashCode = (hashCode * 397) ^ DropButtonStyle.GetHashCode(); hashCode = (hashCode * 397) ^ MultiSelect.GetHashCode(); hashCode = (hashCode * 397) ^ (BorderColor?.GetHashCode() ?? 0); hashCode = (hashCode * 397) ^ (int)SpecialEffect; hashCode = (hashCode * 397) ^ (Value?.GetHashCode() ?? 0); hashCode = (hashCode * 397) ^ (GroupName?.GetHashCode() ?? 0); hashCode = (hashCode * 397) ^ (Remainder?.Length.GetHashCode() ?? 0); return(hashCode); } }
public ExecutionPath(Node pathSourceNode, Node[] route, int weight, params MatchEntry[] match) { PathSourceNode = pathSourceNode; Nodes = route; IsInvalid = Nodes == null || Nodes.Length == 0; Output = IsInvalid ? null : Nodes[Nodes.Length - 1]; if (match == null || match.Length == 0) { IsReturnPath = true; LookAheadMatch = Array.Empty <MatchEntry>(); } else { Match = match[0]; LookAheadMatch = match; } Weight = weight; CalcInfo(ref Weight, out PassLazyNode, out EnterReturnNodes, out StackEvalDelta); }
public MatchEntry Pick(DateTime timepoint, int cnt = 0) { var query = _matchList.Where(x => (x.Timepoint.Equals(timepoint) && x.Cnt == cnt)); int qcnt = query.Count(); if (qcnt != 1) { if (SearchMode) { var matches = FileList.Where(x => DateEqual(x.Timepoint, timepoint)).ToList(); var matchEntry = new MatchEntry(timepoint, matches, cnt); _matchList.Add(matchEntry); return(matchEntry); } else { throw new ArgumentException($"Invalid number of entries found ({qcnt}), 1 expected"); } } return(query.First()); }
public OperandNode(Automata <TInstruction, TOperand> automata, Graph graph, MatchEntry matchEntry) : base(automata, graph) { MatchEntry = matchEntry; }
public Edge(Node sourceNode, Node targetNode, MatchEntry operandMatch, int weight = 0) : this(sourceNode, targetNode, weight) { OperandMatch = operandMatch; IsMatch = true; }
public ExternalLexemeArgumentBuilder(Type argumentType, MatchEntry matchEntry) : base(argumentType, matchEntry) { }
protected override void BuildInvoke(ILBuilderContext ilBuilderContext, MatchEntry matchEntry, bool main) { }
private static ArgumentBuilder CreateLexerArgumentBuilder(Type type, Type converterType, MatchEntry matchEntry) { return(new LocalLexerArgumentBuilder(type, matchEntry)); }
protected override void BuildInvoke(ILBuilderContext ilBuilderContext, MatchEntry matchEntry, bool main) { if (main == false) { return; } var parserEntry = matchEntry switch { ParserSingleMatchEntry s => s.ParserEntryData, ParserSetMatchEntry s => s.ParserEntryData, _ => throw new ArgumentOutOfRangeException() }; if (parserEntry.FlatIndex == -1) { return; } var parserProduction = parserEntry.ParserProduction; if (parserProduction == null) { return; } if (parserProduction.IsInline) { return; } var entryBuilder = parserProduction.Binder.Template[parserEntry.FlatIndex]; if (entryBuilder == null) { return; } if (!(entryBuilder is LexerArgumentBuilder lexerArgumentBuilder)) { throw new InvalidOperationException(); } ilBuilderContext.EmitLdContext(); ilBuilderContext.IL.Emit(OpCodes.Call, PeekStateEntryMethodInfo); ilBuilderContext.IL.Emit(OpCodes.Ldfld, ProductionInstanceBuilderArgumentsFieldInfo); ilBuilderContext.IL.Emit(OpCodes.Ldc_I4, parserEntry.FlatIndex); ilBuilderContext.IL.Emit(OpCodes.Ldelem_Ref); lexerArgumentBuilder.EmitConsumeValue(this, ilBuilderContext); if (parserProduction.Binder.TryReturn) { ilBuilderContext.EmitLdContext(); ilBuilderContext.IL.Emit(OpCodes.Ldc_I4, parserEntry.FlatIndex); ilBuilderContext.IL.Emit(OpCodes.Call, OnAfterConsumeValueMethodInfo); } //ilBuilderContext.EmitLdContext(); //ilBuilderContext.IL.Emit(OpCodes.Ldc_I4, parserStateEntry.FlatIndex); //ilBuilderContext.IL.Emit(OpCodes.Call, ConsumeLexerEntryMethodInfo); }
protected virtual void BuildInvoke(ILBuilderContext ilBuilderContext, MatchEntry matchEntry, bool main) { }
public LocalLexerArgumentBuilder(Type argumentType, MatchEntry matchEntry) : base(argumentType, matchEntry) { }