protected void AddQuantifier(int min, int max, bool greedy) { List <PatternNode <TData, TOffset> > list = _alternation.Any() ? _alternation : _nodes; var quantifier = new Quantifier <TData, TOffset>(min, max, list.Last()) { IsGreedy = greedy }; list[list.Count - 1] = quantifier; }
public static Quantifier Quantifier(this Tuple tuple, INode node) { var quantifier = tuple.GetState<Quantifier>(node); if (quantifier == null) { quantifier = new Quantifier(); tuple.SetState(node, quantifier); } return quantifier; }
public void Test0020_ConstuctorAcceptsPlusQuantifier() { Quantifier sut = new Quantifier("+"); sut.Should().NotBeNull("the constructor should accept this input"); sut.Lower.Should().Be(1, "the lower value of '+' is 1"); sut.Upper.Should() .Be(int.MaxValue, "the infinite upper vlue of '+' has been capped at the maximum value of int."); sut.Type.Should().Be(Quantifier.Types.Range); }
public void Test0050_ConstuctorAcceptsInfinateNumericQuantifier() { var fixedNum = 7; var testValue = string.Format("{{{0},}}", fixedNum); Quantifier sut = new Quantifier(testValue); sut.Should().NotBeNull("the constructor should accept this input"); sut.Lower.Should().Be(7, "the lower value of numeric quantifier '{0}' is {1}.", testValue, fixedNum); sut.Upper.Should().Be(int.MaxValue, "the upper value of numeric quantifier '{0}' is {1}.", testValue, int.MaxValue); sut.Type.Should().Be(Quantifier.Types.Range); }
// Quantifiers public VCExpr Quantify(Quantifier quan, List <TypeVariable /*!*/> /*!*/ typeParams, List <VCExprVar /*!*/> /*!*/ vars, List <VCTrigger /*!*/> /*!*/ triggers, VCQuantifierInfos infos, VCExpr body) { Contract.Requires(body != null); Contract.Requires(infos != null); Contract.Requires(cce.NonNullElements(triggers)); Contract.Requires(cce.NonNullElements(vars)); Contract.Requires(cce.NonNullElements(typeParams)); Contract.Ensures(Contract.Result <VCExpr>() != null); return(new VCExprQuantifier(quan, typeParams, vars, triggers, infos, body)); }
public void Constructor_PassingAlphabeticCharacter_ExpectedVariableAssignedAndObjectConstructed() { // Arrange Quantifier quantifier = GetQuantifier(); // Act char actualBoundVariable = quantifier.GetBoundVariable(); // Assert actualBoundVariable.Should().Be(GetBoundVariable(), "Because the character should be assigned"); }
public void QuantifierTest() { var text = "Canadians"; var target = new ProperPluralNoun(text); IQuantifier expected = new Quantifier("5"); IQuantifier actual; target.QuantifiedBy = expected; actual = target.QuantifiedBy; Check.That(actual).IsEqualTo(expected); }
internal static IEnumerable <string> getTriggers(Quantifier quantifier, bool display) { var bodyTerms = quantifier.BodyTerm.Args; if (bodyTerms == null || bodyTerms.Length <= 1) { return(Enumerable.Empty <string>()); } return(bodyTerms.Take(bodyTerms.Length - 1).Select(x => ExtractTrigger(x, display))); }
public Group(IRegularExpression expression, string specifier, Quantifier quantifier) { if (expression == null || quantifier == null) { throw new ArgumentNullException(); } Quantifier = quantifier; Subexpression = expression; Specifier = specifier; }
public void QuantifiedByTest() { var target = new CommonSingularNoun("dog"); var quantifying = new Quantifier("3"); target.QuantifiedBy = quantifying; var actual = target.QuantifiedBy; Check.That(actual).IsEqualTo(quantifying); Check.That(target.QuantifiedBy.Quantifies).IsEqualTo(target); }
public static Quantifier Quantifier(this Tuple tuple, INode node) { var quantifier = tuple.GetState <Quantifier>(node); if (quantifier == null) { quantifier = new Quantifier(); tuple.SetState(node, quantifier); } return(quantifier); }
public void QuantifiedByTest() { var text = "clowns"; var target = new CommonPluralNoun(text); IQuantifier expected = new Quantifier("all"); IQuantifier actual; target.QuantifiedBy = expected; actual = target.QuantifiedBy; Check.That(actual).IsEqualTo(expected); }
public QuantifierPredicate(Quantifier quantifier, Variable variable, Sort typeBound, Predicate predicate) { Debug.Assert(quantifier != null); Debug.Assert(variable != null); Debug.Assert(typeBound != null); Debug.Assert(predicate != null); this.quantifier = quantifier; this.variable = variable; this.typeBound = typeBound; this.predicate = predicate; }
public void Test0060_ConstuctorAcceptsBoundedNumericQuantifier() { var lowerNum = 7; var upperNum = 95; var testValue = string.Format("{{{0},{1}}}", lowerNum, upperNum); Quantifier sut = new Quantifier(testValue); sut.Should().NotBeNull("the constructor should accept this input"); sut.Lower.Should().Be(7, "the lower value of numeric quantifier '{0}' is {1}.", testValue, lowerNum); sut.Upper.Should().Be(95, "the upper value of numeric quantifier '{0}' is {1}.", testValue, upperNum); sut.Type.Should().Be(Quantifier.Types.Range); }
public Parser(IParser <TInput, TOutput> initial, Func <IParser <TInput, TOutput>, IParser <TInput, TOutput> > getRight, Quantifier arity, string name = "") { Assert.ArgumentNotNull(initial, nameof(initial)); Assert.ArgumentNotNull(getRight, nameof(getRight)); _initial = initial; _quantifier = arity; _left = new LeftValue(name); _right = getRight(_left); _getRight = getRight; Name = name; }
/// <summary> /// Reinitialize global variables that track the values of constituents. /// Called each time a new syntax rule is tried. /// </summary> private void ResetConstituentInformation() { Subject.Reset(); Verb.Reset(); Verb2.Reset(); Object.Reset(); PredicateAP.Reset(); SubjectNounList.Reset(); PredicateAPList.Reset(); Quantifier.Reset(); VerbNumber = null; }
/// <inheritdoc /> public string CreateQuantifier(IRegularExpressionFactoryContext ctx, Quantifier quantity, string quantifiedContentRegex) { if (string.IsNullOrEmpty(quantifiedContentRegex)) { return(string.Empty); } quantifiedContentRegex = CreateNonCapturingGroup(ctx, quantifiedContentRegex); var defined = quantity.ToDefinedRange(); var min = defined.Min.MaxUInt; var max = defined.Max.MaxUInt; if (min == 1 && max == 1) { return(quantifiedContentRegex); } return(CreateNonCapturingGroup(ctx, GetQuantifiedContent())); string GetQuantifiedContent() { if (min == 0 && max == 1) { return($"{quantifiedContentRegex}?"); } if (defined.Max.IsInfinite) { if (min == 0) { return($"{quantifiedContentRegex}*"); } if (min == 1) { return($"{quantifiedContentRegex}+"); } return($"{quantifiedContentRegex}{{{min},}}"); } if (min == max) { return($"{quantifiedContentRegex}{{{min}}}"); } return($"{quantifiedContentRegex}{{{min},{max}}}"); } }
public override void Generate(GroupSet groups, Random rand, StringBuilder sb, int recursionDepth, int repetitionLimit) { if (possibleChars.Length == 0) { return; } var c = Quantifier.GetQuantity(rand, repetitionLimit); for (var i = 0; i < c; ++i) { sb.Append(possibleChars[rand.Next(possibleChars.Length)]); } }
private Decomposition DecomposeWFF(Quantifier f) { if (f is Existential) { return(DecomposeWFF((Existential)f)); } else if (f is Universal) { return(DecomposeWFF((Universal)f)); } throw new NotImplementedException(f.GetType().ToString()); }
// <item> (<middle> <item>)* with right-associativity in the production method public Parser(IParser <TInput, TOutput> item, IParser <TInput, TMiddle> middle, Func <Arguments, TOutput> produce, Quantifier quantifier, Func <IParseState <TInput>, TOutput>?getMissingRight = null, string name = "") { Assert.ArgumentNotNull(item, nameof(item)); Assert.ArgumentNotNull(middle, nameof(middle)); Assert.ArgumentNotNull(produce, nameof(produce)); _item = item; _middle = middle; _produce = produce; _getMissingRight = getMissingRight; _quantifier = quantifier; Name = name; }
public static int SortOrder(this Quantifier f) { if (f is Existential) { return(1); } else if (f is Universal) { return(int.MaxValue); } throw new NotImplementedException(f.GetType().ToString()); }
private IEvaluatable GetTerm(string inputString) { var pattern = new Regex(_regexMatchFact, RegexOptions.IgnoreCase); var matches = pattern.Matches(inputString); Quantifier quantifier1 = string.IsNullOrEmpty(matches[0].Groups[2].Value) ? Quantifier.ALL: _quantifierSynonyms[matches[0].Groups[2].Value.ToUpperInvariant()]; var attributeName = DecompressStringFully(matches[0].Groups[3].Value); Predicate relationalOperator = _operatorSynonyms[matches[0].Groups[5].Value.ToUpperInvariant()]; Quantifier quantifier2 = string.IsNullOrEmpty(matches[0].Groups[7].Value) ? quantifier1 : _quantifierSynonyms[matches[0].Groups[7].Value.ToUpperInvariant()]; var reflective = !string.IsNullOrEmpty(matches[0].Groups[8].Value); var attributeValue = DecompressStringFully(matches[0].Groups[9].Value); return(new Proposition(attributeName, relationalOperator, attributeValue, reflective, quantifier1, quantifier2)); }
public static bool Decomposable(this Quantifier f) { if (f is Existential) { return(true); } else if (f is Universal) { return(true); } throw new NotImplementedException(f.GetType().ToString()); }
public static QuantifiedExpression Make(Quantifier q, IEnumerable <VariableType> vars, BooleanExpression b) { var freeVars = b.GetVariables(); foreach (var v in vars) { if (!freeVars.Contains(v)) { throw new ArgumentException(); } } return(new QuantifiedExpression(q, vars, b)); }
public void GetRandomQuantity(int minimum, int maximum) { var quantifier = new Quantifier(minimum, maximum); var random = new Random(); Assert.Multiple(() => { for (int i = 0; i < 100; i++) { var actual = quantifier.GetRandomRepeat(random); Assert.Between(actual, minimum, maximum); } }); }
/// <summary> /// Initializes a new insstance of a QuantifierFilter. /// </summary> /// <param name="leftHand">The value being compared to the set of values.</param> /// <param name="quantifier">The quantifier to use to compare the value to the set of values.</param> /// <param name="valueProvider">The source of values.</param> protected QuantifierFilter(IFilterItem leftHand, Quantifier quantifier, IValueProvider valueProvider) { if (leftHand == null) { throw new ArgumentNullException("leftHand"); } if (valueProvider == null) { throw new ArgumentNullException("valueProvider"); } LeftHand = leftHand; Quantifier = quantifier; ValueProvider = valueProvider; }
private bool EvaluateQuantifiedOperation(Quantifier quantifier1, IEnumerable <string> actualValues, Predicate op, Quantifier quantifier2, IEnumerable <string> expectedValues) { if (quantifier1 == Quantifier.ALL && quantifier2 == Quantifier.ALL) { return(actualValues.All(actualValue => expectedValues.All(expectedValue => EvaluateOperation(actualValue, op, expectedValue)))); } if (quantifier1 == Quantifier.ALL && quantifier2 == Quantifier.ANY) { return(actualValues.All(actualValue => expectedValues.Any(expectedValue => EvaluateOperation(actualValue, op, expectedValue)))); } if (quantifier1 == Quantifier.ALL && quantifier2 == Quantifier.SINGLE) { return(actualValues.All(actualValue => expectedValues.Where(expectedValue => EvaluateOperation(actualValue, op, expectedValue)).Count() == 1)); } if (quantifier1 == Quantifier.ANY && quantifier2 == Quantifier.ALL) { return(actualValues.Any(actualValue => expectedValues.All(expectedValue => EvaluateOperation(actualValue, op, expectedValue)))); } if (quantifier1 == Quantifier.ANY && quantifier2 == Quantifier.ANY) { return(actualValues.Any(actualValue => expectedValues.Any(expectedValue => EvaluateOperation(actualValue, op, expectedValue)))); } if (quantifier1 == Quantifier.ANY && quantifier2 == Quantifier.SINGLE) { return(actualValues.Any(actualValue => expectedValues.Where(expectedValue => EvaluateOperation(actualValue, op, expectedValue)).Count() == 1)); } if (quantifier1 == Quantifier.SINGLE && quantifier2 == Quantifier.ALL) { return(actualValues.Where(actualValue => expectedValues.All(expectedValue => EvaluateOperation(actualValue, op, expectedValue))).Count() == 1); } if (quantifier1 == Quantifier.SINGLE && quantifier2 == Quantifier.ANY) { return(actualValues.Where(actualValue => expectedValues.Any(expectedValue => EvaluateOperation(actualValue, op, expectedValue))).Count() == 1); } if (quantifier1 == Quantifier.SINGLE && quantifier2 == Quantifier.SINGLE) { return(actualValues.Where(actualValue => expectedValues.Where(expectedValue => EvaluateOperation(actualValue, op, expectedValue)).Count() == 1).Count() == 1); } throw new Exception("Invalid proposition quantification"); }
private Quantifier CreateQuantifier(string name, string qid) { Quantifier quant; if (!model.quantifiers.TryGetValue(name, out quant)) { quant = new Quantifier(); quant.Qid = qid; quant.Instances = new List <Instantiation>(); model.quantifiers[name] = quant; loadBoogieToken(quant); } return(quant); }
public void ToPrefixString_SucessorAssigned_ExpectedPrefixStringReturned() { // Arrange Quantifier quantifier = GetQuantifier(); quantifier.LeftSuccessor = new Proposition('P'); // Act string actualToPrefixString = quantifier.ToPrefixString(); string expectedToPrefixString = $"{quantifier.Data}{quantifier.GetBoundVariable()}.(P)"; // Assert actualToPrefixString.Should().Be(expectedToPrefixString, "Because that's the prefix format for the quantifier"); }
public Proposition( string attributeName, Predicate operation, string attributeValue, bool binaryArgument = false, Quantifier argument1Quantifier = Quantifier.ALL, Quantifier argument2Quantifier = Quantifier.ALL) { AttributeName = attributeName; Operator = operation; AttributeValue = attributeValue; BinaryArgument = binaryArgument; Argument1Quantifier = argument1Quantifier; Argument2Quantifier = argument2Quantifier; }
private static T AddPredicate <T>(T node, Expression expression, bool sign, Quantifier quantifier = null) where T : ISemantic { if (quantifier == null) { ((IPredicate)node).AddPredicate( new Predicate((DbNode)(object)node, PredicateType.Existential, sign, LogicalOperator.And, expression)); } else { ((IPredicate)node).AddPredicate( new Predicate((DbNode)(object)node, PredicateType.Quantified, sign, LogicalOperator.And, expression, quantifier)); } return(node); }
public DateFilter(DateTime query, Char q, String attribute) { this.query = query; this.attribute = attribute; switch (q) { case '>': this.q = Quantifier.AFTER; break; case '<': this.q = Quantifier.BEFORE; break; case '=': this.q = Quantifier.IN; break; } }
public IntListFilter(int query, Char q, String attribute) { this.query = query; this.attribute = attribute; switch (q) { case '>': this.q = Quantifier.GREATERTHAN; break; case '<': this.q = Quantifier.LESSTHAN; break; case '=': this.q = Quantifier.EQUALTO; break; } }
private void Refresh() { //apagar os elementos no meu itemContainer int children = hooks.ItemContainer.transform.childCount; for (int i = 0; i < children; i++) { GameObject.Destroy (hooks.ItemContainer.transform.GetChild (i).gameObject); } //limpar as listas itemsInContainerList.Clear (); inventoryTotalList.Clear (); //fazer reset ao itemIndex itemIndex = 0; //ativar botoes e tudo o que for preciso ativar for (int i = 0; i < hooks.ItemsArea.Count(); i++) { hooks.ItemsArea [i].SetActive (true); } //initialize my list with 2 tables and 8 chairs SpecificItem specificItemTable = GameManager.Instance.SpecificItems.Find (x => x.Id == 59); SpecificItem specificItemChair = GameManager.Instance.SpecificItems.Find (x => x.Id == 58); Quantifier<SpecificItem> tables = new Quantifier<SpecificItem> (2, specificItemTable); inventoryTotalList.Add (tables); Quantifier<SpecificItem> chairs = new Quantifier<SpecificItem> (8, specificItemChair); inventoryTotalList.Add (chairs); //preender a minha lista de inventorio foreach (Player player in game.Players) { for (int i = 0; i < player.Inventory.Count; i++) { SpecificItem specificItem = player.Inventory [i].Item; int index = inventoryTotalList.FindIndex (speItem => speItem.Item.Id == specificItem.Id); if (index == -1) { SpecificItem specificItemCopy = new SpecificItem (specificItem.Id, specificItem.Name, specificItem.IconId, specificItem.Price, specificItem.Theme, specificItem.GeneralItem); Quantifier<SpecificItem> itemToAddWithQTD = new Quantifier<SpecificItem> (player.Inventory [i].Quantity, specificItemCopy); inventoryTotalList.Add (itemToAddWithQTD); } else { inventoryTotalList [index].Quantity += player.Inventory [i].Quantity; } } } inventoryTotalSize = inventoryTotalList.Count (); updateScene (); }
void Quantifier(out Expression e) { Quantifier q = new Quantifier(); NodeType n; Expression cexpr; Quant(out n); Comprehension(out cexpr); Comprehension c = cexpr as Comprehension; if (c == null){ e = null; }else{ c.Type = SystemTypes.GenericIEnumerable.GetTemplateInstance(currentAssembly,SystemTypes.Boolean); q.QuantifierType = n; q.Comprehension = c; q.Type = SystemTypes.Boolean; q.SourceType = SystemTypes.Boolean; e = q; } }
public IArrayCompareCondition LowerThanOrEqualTo(string arrayPath, string path, object value, Quantifier? quantifier = null) => new LowerThanOrEqualArrayCondition(arrayPath, path, value) { Quantifier = quantifier };
public override Expression VisitQuantifier(Quantifier quantifier) { if (quantifier == null) return null; return base.VisitQuantifier((Quantifier)quantifier.Clone()); }
private IEnumerable<PatternNode<Word, ShapeNode>> LoadPatternNodes(XElement pseqElem, Dictionary<string, Tuple<string, SymbolicFeature>> variables, CharacterDefinitionTable defaultTable, Dictionary<string, string> groupNames) { foreach (XElement recElem in pseqElem.Elements()) { PatternNode<Word, ShapeNode> node = null; switch (recElem.Name.LocalName) { case "SimpleContext": SimpleContext simpleCtxt = LoadSimpleContext(recElem, variables); node = new Constraint<Word, ShapeNode>(simpleCtxt.FeatureStruct) {Tag = simpleCtxt}; break; case "Segment": case "BoundaryMarker": CharacterDefinition cd = _charDefs[(string) recElem.Attribute(recElem.Name.LocalName == "Segment" ? "segment" : "boundary")]; node = new Constraint<Word, ShapeNode>(cd.FeatureStruct) {Tag = cd}; break; case "OptionalSegmentSequence": var minStr = (string) recElem.Attribute("min"); int min = string.IsNullOrEmpty(minStr) ? 0 : int.Parse(minStr); var maxStr = (string) recElem.Attribute("max"); int max = string.IsNullOrEmpty(maxStr) ? -1 : int.Parse(maxStr); node = new Quantifier<Word, ShapeNode>(min, max, new Group<Word, ShapeNode>(LoadPatternNodes(recElem, variables, defaultTable, groupNames))); break; case "Segments": CharacterDefinitionTable segsTable = GetTable(recElem, defaultTable); var shapeStr = (string) recElem.Element("PhoneticShape"); var segments = new Segments(segsTable, shapeStr); node = new Group<Word, ShapeNode>(segments.Shape.Select(n => new Constraint<Word, ShapeNode>(n.Annotation.FeatureStruct))) {Tag = segments}; break; } Debug.Assert(node != null); var id = (string) recElem.Attribute("id"); string groupName; if (groupNames == null || string.IsNullOrEmpty(id) || !groupNames.TryGetValue(id, out groupName)) yield return node; else yield return new Group<Word, ShapeNode>(groupName, node); } }
public virtual Differences VisitQuantifier(Quantifier quantifier1, Quantifier quantifier2){ Differences differences = new Differences(quantifier1, quantifier2); if (quantifier1 == null || quantifier2 == null){ if (quantifier1 != quantifier2) differences.NumberOfDifferences++; else differences.NumberOfSimilarities++; return differences; } Quantifier changes = (Quantifier)quantifier2.Clone(); Quantifier deletions = (Quantifier)quantifier2.Clone(); Quantifier insertions = (Quantifier)quantifier2.Clone(); Differences diff = this.VisitComprehension((Comprehension)quantifier1.Comprehension, (Comprehension)quantifier2.Comprehension); if (diff == null){Debug.Assert(false); return differences;} changes.Comprehension = diff.Changes as Comprehension; deletions.Comprehension = diff.Deletions as Comprehension; insertions.Comprehension = diff.Insertions as Comprehension; differences.NumberOfDifferences += diff.NumberOfDifferences; differences.NumberOfSimilarities += diff.NumberOfSimilarities; if (quantifier1.QuantifierType == quantifier2.QuantifierType) differences.NumberOfSimilarities++; else differences.NumberOfDifferences++; if (differences.NumberOfDifferences == 0){ differences.Changes = null; differences.Deletions = null; differences.Insertions = null; }else{ differences.Changes = changes; differences.Deletions = deletions; differences.Insertions = insertions; } return differences; }
private void Refresh() { for (int i = 0; i < amountOfPlayers; i++) { playersInventory [i].Clear (); game.Players [i].ItemsReturned = 0; for (int j = 0; j < game.Players[i].Inventory.Count; j++) { SpecificItem specificItem = game.Players [i].Inventory [j].Item; SpecificItem specificItemCopy = new SpecificItem (specificItem.Id, specificItem.Name, specificItem.IconId, specificItem.Price, specificItem.Theme, specificItem.GeneralItem); Quantifier<SpecificItem> itemToAddWithQTD = new Quantifier<SpecificItem> (game.Players [i].Inventory [j].Quantity, specificItemCopy); playersInventory [i].Add (itemToAddWithQTD); } } for (int i = 0; i < amountOfPlayers; i++) { playersSpent [i] = game.Players [i].TotalSpent (); updateCardboardInv (i); } updateTotalSpendingAmount (); }
public override Expression VisitQuantifier(Quantifier quantifier) { bool savedInsideQuantifier = this.insideQuantifier; this.insideQuantifier = true; quantifier.Comprehension = (Comprehension)this.VisitComprehension(quantifier.Comprehension); this.insideQuantifier = savedInsideQuantifier; if (quantifier.Comprehension == null) return null; // Signal error? TypeNode comprType = TypeNode.StripModifiers(quantifier.Comprehension.Type); if (comprType == null) return null; // Signal error? if (comprType.TemplateArguments == null || comprType.TemplateArguments.Count != 1) return null; // Signal error? if (!this.GetTypeView(comprType.TemplateArguments[0]).IsAssignableTo(quantifier.SourceType)) { this.HandleError(quantifier, Error.ImpossibleCast, this.GetTypeName(quantifier.SourceType), this.GetTypeName(comprType.TemplateArguments[0])); } return quantifier; }
/// <summary> /// Parse an element and its quantifier, and put it in Item /// </summary> private Element ParseElement(Block Parent) { //Go through each of the helper functions to parse an element _caret.WS(); Element el = PENamedBlock(Parent) ?? PEFunctionCall(Parent) ?? PEKeyword(Parent) ?? PEBinaryOperator(Parent) ?? PELiteral(Parent) ?? PEMemory(Parent) ?? PEBlock(Parent); //do //{ // _caret.WhiteSpace(); // Item = PENamedBlock(Parent); // if (Item != null) break; // Item = PEFunctionCall(Parent); // if (Item != null) break; // Item = PEKeyword(Parent); // if (Item != null) break; // Item = PEBinaryOperator(Parent); // if (Item != null) break; // Item = PELiteral(Parent); // if (Item != null) break; // Item = PEMemory(Parent); // if (Item != null) break; // Item = PEBlock(Parent); // if (Item != null) break; //} while (false); if ((el is Literal) || //No quantifier for text literal (el is Variable) || //No quantifier for variables (el is ControlFlow) || //No quantifier for variables (el is BinaryOperator)) //No quantifier for binary operators { var q = new Quantifier(); //No quantifier must be specified if (ParseQuantifier(ref q)) if ((el is ControlFlow) && (((ControlFlow)el).Type == ControlFlow.eType.Call)) el.Quantifier = q; else ThrowParseError("No quantifier must be specified here"); } else if (el != null) { ParseQuantifier(ref el.Quantifier); if (el.Quantifier.SourcePosition.IsInit) el.Annotation.SourcePosition.End = el.Quantifier.SourcePosition.End; } if (el != null) AddSourceCodeAnnotation(el); return el; }
private void Advance() { //mudar os inventorios dos jogadores for (int i = 0; i < amountOfPlayers; i++) { game.Players [i].Inventory.Clear (); for (int j = 0; j < playersInventory[i].Count; j++) { SpecificItem specificItem = playersInventory [i] [j].Item; SpecificItem specificItemCopy = new SpecificItem (specificItem.Id, specificItem.Name, specificItem.IconId, specificItem.Price, specificItem.Theme, specificItem.GeneralItem); Quantifier<SpecificItem> itemToAddWithQTD = new Quantifier<SpecificItem> (playersInventory [i] [j].Quantity, specificItemCopy); game.Players [i].Inventory.Add (itemToAddWithQTD); } } game.CurrentCheckpoint = Game.Checkpoint.Party; GuiManager.Instance.messageCanvas.SetAndShow (MessageCanvasControl.LOADING_MESSAGE, false); Loom loom = Loom.Instance; loom.RunAsync (() => { try { GameManager.Instance.Entity.SyncSaveGame (game); loom.QueueOnMainThread (() => { GuiManager manager = GuiManager.Instance; manager.messageCanvas.Hide (); manager.Show (manager.partyIntroCanvas); }); } catch (Database.DatabaseException) { loom.QueueOnMainThread (() => { GuiManager.Instance.messageCanvas.SetAndShow ( "Ocorreu um erro com a Internet.\nPor favor tenta de novo.", true); }); } }); }
/// <summary> /// Parse the Quantifier, right after the element, and update the Item.Quantifier /// </summary> /// <returns>Returns true if a Quantifier is encountered, false otherwise</returns> private bool ParseQuantifier(ref Quantifier Quantifier) { if (_caret.Match(@"(?<_skw>(?<plus>\&)?((?<keyword>if_any|\?|as_many|\*|at_least_once|\+|never|\!)|\((?<min>\d*)((?<comma>,)(?<max>\d*))?\)))")) { if (_caret.LastMatch.Groups["plus"].Value != "") Quantifier.Additive = true; switch (_caret.LastMatch.Groups["keyword"].Value.ToLower()) { case "if_any": case "?": Quantifier.Min = 0; Quantifier.Max = 1; break; case "as_many": case "*": Quantifier.Min = 0; Quantifier.Max = -1; break; case "at_least_once": case "+": Quantifier.Min = 1; Quantifier.Max = -1; break; case "never": case "!": Quantifier.Min = 0; Quantifier.Max = 0; break; default: string min = _caret.LastMatch.Groups["min"].Value, max = _caret.LastMatch.Groups["max"].Value; //Get minimum if (min == "") Quantifier.Min = 0; else if (!int.TryParse(min, out Quantifier.Min)) ThrowParseError("Expecting an integer as minimum"); //Get maximum if (max == "") if (_caret.LastMatch.Groups["comma"].Value != "") Quantifier.Max = -1; else Quantifier.Max = Quantifier.Min; else if (!int.TryParse(max, out Quantifier.Max)) ThrowParseError("Expecting an integer as maximum"); //At least one must be specified if ((min == "") && (max == "")) ThrowParseError("Specify at least minimum or maximum"); break; } if (Quantifier.Additive && ((Quantifier.Max == 0) || (Quantifier.Max ==1))) ThrowParseError("& is redundant"); Quantifier.SourcePosition = _caret.LastMatch; return true; } else if (_caret.Match(@"(?<_skw>(?<plus>\&))")) ThrowParseError("Did you mean & to be text concatenation? Leave a space for concatanation or specify a quantifier"); return false; }
internal static IEnumerable<PatternNode<Word, ShapeNode>> DeepCloneExceptBoundaries(this IEnumerable<PatternNode<Word, ShapeNode>> nodes) { foreach (PatternNode<Word, ShapeNode> node in nodes) { var constraint = node as Constraint<Word, ShapeNode>; if (constraint != null && (constraint.FeatureStruct.IsEmpty || constraint.Type() != HCFeatureSystem.Boundary)) { yield return constraint.DeepClone(); continue; } var alternation = node as Alternation<Word, ShapeNode>; if (alternation != null) { var newAlteration = new Alternation<Word, ShapeNode>(alternation.Children.DeepCloneExceptBoundaries()); if (newAlteration.Children.Count > 0) yield return newAlteration; continue; } var group = node as Group<Word, ShapeNode>; if (group != null) { var newGroup = new Group<Word, ShapeNode>(group.Name, group.Children.DeepCloneExceptBoundaries()); if (newGroup.Children.Count > 0) yield return newGroup; continue; } var quantifier = node as Quantifier<Word, ShapeNode>; if (quantifier != null) { var newQuantifier = new Quantifier<Word, ShapeNode>(quantifier.MinOccur, quantifier.MaxOccur, quantifier.Children.DeepCloneExceptBoundaries().SingleOrDefault()); if (newQuantifier.Children.Count > 0) yield return newQuantifier; continue; } var pattern = node as Pattern<Word, ShapeNode>; if (pattern != null) { var newPattern = new Pattern<Word, ShapeNode>(pattern.Name, pattern.Children.DeepCloneExceptBoundaries()); if (newPattern.Children.Count > 0) yield return newPattern; } } }
// forall{int i in xs; i > 0}; // ==> // "forall{| {i32, $block::a, $1}; ::>(i32,i32){$block::a, 0} |}" public override Expression VisitQuantifier(Quantifier quantifier) { if (this._string == null){ this._string = new StringBuilder(); } switch (quantifier.QuantifierType){ case NodeType.Forall: this._string.Append("$_forall"); break; case NodeType.Exists: this._string.Append("$_exists"); break; case NodeType.ExistsUnique: this._string.Append("$_exists1"); break; case NodeType.Count: this._string.Append("$_count"); break; case NodeType.Max: this._string.Append("$_max"); break; case NodeType.Min: this._string.Append("$_min"); break; case NodeType.Product: this._string.Append("$_product"); break; case NodeType.Sum: this._string.Append("$_sum"); break; default: this._string.Append("??"); // REVIEW: What would be a good default? break; } this.VisitComprehension(quantifier.Comprehension); return quantifier; }
public override Expression VisitQuantifier(Quantifier quantifier) { if (quantifier == null) return null; quantifier.Comprehension = (Comprehension)this.VisitComprehension(quantifier.Comprehension); switch (quantifier.QuantifierType){ case NodeType.Forall: case NodeType.Exists: case NodeType.ExistsUnique: // Quantifiers that are of type bool --> bool quantifier.Type = SystemTypes.Boolean; quantifier.SourceType = SystemTypes.Boolean; break; case NodeType.Count: // Quantifiers that are of type bool --> int quantifier.Type = SystemTypes.Int32; quantifier.SourceType = SystemTypes.Boolean; break; case NodeType.Max: case NodeType.Min: case NodeType.Product: case NodeType.Sum: // Quantifiers that are of type int --> int quantifier.Type = SystemTypes.Int32; quantifier.SourceType = SystemTypes.Int32; break; default: quantifier.Type = null; // REVIEW: What would be a good default? quantifier.SourceType = null; break; } return quantifier; }
//cd = cardboard private void updateCardboardInv(int cd) { //primeiro: selecionar os itens que quero mostrar int playerInvCount = playersInventory [cd].Count; int numberOfItemsAdded = playerInvCount - itemIndex [cd]; if (numberOfItemsAdded > 6) // o maximo sao 6 itens de cada vez numberOfItemsAdded = 6; Quantifier<SpecificItem>[] SelectedItems = new Quantifier<SpecificItem>[numberOfItemsAdded]; playersInventory [cd].CopyTo (itemIndex [cd], SelectedItems, 0, numberOfItemsAdded); //segundo: ver se tenho 5 ou mais itens, se tiver entao fazer active a tudo //TODO: verificar se faz sentido adicionar uns ifs. int i = 0; Transform itemContainer = hooks.CardBoardItems [cd].transform.Find ("ItemsContainer"); while (i < numberOfItemsAdded) { itemContainer.GetChild (i).gameObject.SetActive (true); i++; } while (i < 6) { itemContainer.GetChild (i).gameObject.SetActive (false); i++; } ShowCardBoardArrows (cd); //terceiro: fazer update tendo em conta o que estou a ver ItemCheckBoughtItem boughtItem; for (int j = 0; j < numberOfItemsAdded; j++) { boughtItem = itemContainer.GetChild (j).GetComponent<ItemCheckBoughtItem> (); boughtItem.ItemName = SelectedItems [j].Item.Name; boughtItem.ItemID = SelectedItems [j].Item.Id; boughtItem.ItemQTD = "x" + SelectedItems [j].Quantity.ToString (); boughtItem.ItemPrice = (SelectedItems [j].Item.Price * SelectedItems [j].Quantity); boughtItem.ItemImage = AssetsManager.Instance. SpecificItemsSprites [SelectedItems [j].Item.IconId]; } //quarto, fazer update do total gasto hooks.CardBoardItems [cd].transform.Find ("PlayerSpent").GetComponent<Text> ().text = CultureConverter.ToPrice (playersSpent [cd]); //game.Players[cd].Inventory e playersInventory[cd] }
private IFilter buildQuantifierFilter(MatchResult result, IFilterItem leftHand, Quantifier quantifier, IValueProvider valueProvider) { MatchResult equalToResult = result.Matches[SqlGrammar.ComparisonOperator.EqualTo]; if (equalToResult.IsMatch) { return new EqualToQuantifierFilter(leftHand, quantifier, valueProvider); } MatchResult notEqualToResult = result.Matches[SqlGrammar.ComparisonOperator.NotEqualTo]; if (notEqualToResult.IsMatch) { return new NotEqualToQuantifierFilter(leftHand, quantifier, valueProvider); } MatchResult lessThanEqualToResult = result.Matches[SqlGrammar.ComparisonOperator.LessThanEqualTo]; if (lessThanEqualToResult.IsMatch) { return new LessThanEqualToQuantifierFilter(leftHand, quantifier, valueProvider); } MatchResult greaterThanEqualToResult = result.Matches[SqlGrammar.ComparisonOperator.GreaterThanEqualTo]; if (greaterThanEqualToResult.IsMatch) { return new GreaterThanEqualToQuantifierFilter(leftHand, quantifier, valueProvider); } MatchResult lessThanResult = result.Matches[SqlGrammar.ComparisonOperator.LessThan]; if (lessThanResult.IsMatch) { return new LessThanQuantifierFilter(leftHand, quantifier, valueProvider); } MatchResult greaterThanResult = result.Matches[SqlGrammar.ComparisonOperator.GreaterThan]; if (greaterThanResult.IsMatch) { return new GreaterThanQuantifierFilter(leftHand, quantifier, valueProvider); } throw new InvalidOperationException(); }
/// <summary> /// Initializes a new insstance of an GreaterThanEqualToQuantifierFilter. /// </summary> /// <param name="leftHand">The value being compared to the set of values.</param> /// <param name="quantifier">The quantifier to use to compare the value to the set of values.</param> /// <param name="valueProvider">The source of values.</param> public GreaterThanEqualToQuantifierFilter(IFilterItem leftHand, Quantifier quantifier, IValueProvider valueProvider) : base(leftHand, quantifier, valueProvider) { }
private static string quantifier2str(Quantifier qtf) { //forall{comprehension} StringBuilder sb=new StringBuilder(); sb.Append(quantifiertype2str(qtf.QuantifierType)); sb.Append("{"); sb.Append(comprehension2str(qtf.Comprehension)); sb.Append("}"); return sb.ToString(); }
public IArrayCompareCondition GreaterThan(string arrayPath, string path, object value, Quantifier? quantifier = null) => new GreaterThanArrayCondition(arrayPath, path, value) { Quantifier = quantifier };
public virtual Expression VisitQuantifier(Quantifier quantifier){ if (quantifier == null) return null; quantifier.Comprehension = (Comprehension)this.VisitComprehension(quantifier.Comprehension); return quantifier; }
public virtual void VisitQuantifier(Quantifier quantifier) { if (quantifier == null) return; this.VisitComprehension(quantifier.Comprehension); }
// TODO: Handle default values in the comprehension // Q{U i in enumerable, P(i); T(i)} public override Expression VisitQuantifier(Quantifier quantifier) { if (quantifier == null) return null; Comprehension comprehension = quantifier.Comprehension; if (comprehension == null) return null; Block block = new Block(new StatementList()); block.HasLocals = true; #region Create local to act as accumulator for the quantifier Local b = null; switch (quantifier.QuantifierType){ case NodeType.Forall: b = new Local(Identifier.Empty,SystemTypes.Boolean,block); break; case NodeType.Exists: b = new Local(Identifier.Empty,SystemTypes.Boolean,block); break; case NodeType.ExistsUnique: case NodeType.Count: case NodeType.Max: case NodeType.Min: case NodeType.Product: case NodeType.Sum: b = new Local(Identifier.Empty,SystemTypes.Int32,block); break; default: Debug.Assert(false); return null; } #endregion Create local to act as accumulator for the quantifier if (comprehension.IsDisplay){ #region Display: Generate a separate if-statement for each element Block endBlock = new Block(new StatementList()); for(int i = 0, n = comprehension.Elements == null ? 0 : comprehension.Elements.Count; i < n; i++){ #region assign the value of the term to b Statement updateB = null; switch (quantifier.QuantifierType){ case NodeType.Forall: updateB = new AssignmentStatement(b,comprehension.Elements[i]); break; case NodeType.Exists: updateB = new AssignmentStatement(b,comprehension.Elements[i]); break; case NodeType.ExistsUnique: case NodeType.Count: // b := b + (T(i) ? 1 : 0) updateB = new AssignmentStatement(b, new BinaryExpression(b, new TernaryExpression(comprehension.Elements[i], Literal.Int32One, Literal.Int32Zero, NodeType.Conditional, SystemTypes.Int32), NodeType.Add)); break; case NodeType.Product: // b := b * T(i) updateB = new AssignmentStatement(b, new BinaryExpression(b, comprehension.Elements[i], NodeType.Mul)); break; case NodeType.Sum: // b := b + T(i) updateB = new AssignmentStatement(b, new BinaryExpression(b, comprehension.Elements[i], NodeType.Add)); break; case NodeType.Max: // b := b < T(i) ? T(i) : b updateB = new AssignmentStatement(b, new TernaryExpression(new BinaryExpression(b, comprehension.Elements[i], NodeType.Lt, SystemTypes.Boolean), comprehension.Elements[i], b, NodeType.Conditional, SystemTypes.Int32)); break; case NodeType.Min: // b := b > T(i) ? T(i) : b updateB = new AssignmentStatement(b, new TernaryExpression(new BinaryExpression(b, comprehension.Elements[i], NodeType.Gt, SystemTypes.Boolean), comprehension.Elements[i], b, NodeType.Conditional, SystemTypes.Int32)); break; default: Debug.Assert(false); return null; } block.Statements.Add(updateB); #endregion assign the value of the term to b #region Test to see if loop should terminate early Expression condition = null; switch (quantifier.QuantifierType){ case NodeType.Forall: condition = new UnaryExpression(b, NodeType.LogicalNot, SystemTypes.Boolean); block.Statements.Add(new Branch(condition, endBlock)); break; case NodeType.Exists: condition = b; block.Statements.Add(new Branch(condition, endBlock)); break; case NodeType.ExistsUnique: condition = new BinaryExpression(b,Literal.Int32One,NodeType.Gt,SystemTypes.Boolean); break; case NodeType.Count: case NodeType.Max: case NodeType.Min: case NodeType.Product: case NodeType.Sum: condition = Literal.False; // no short-circuit!! Need to evaluate all of the terms! break; default: Debug.Assert(false); return null; } #endregion Test to see if loop should terminate early } block.Statements.Add(endBlock); #endregion Display: Generate a separate if-statement for each element }else { #region "True" comprehension #region assign the value of the term to the accumulator Statement updateB = null; switch (quantifier.QuantifierType){ case NodeType.Forall: // b := T(i); updateB = new AssignmentStatement(b,comprehension.Elements[0]); break; case NodeType.Exists: // b := T(i); updateB = new AssignmentStatement(b,comprehension.Elements[0]); break; case NodeType.ExistsUnique: case NodeType.Count: // b := b + T(i) ? 1 : 0; // TODO: is it better to try and generate "b += ..."? updateB = new AssignmentStatement(b, new BinaryExpression(b, new TernaryExpression(comprehension.Elements[0],Literal.Int32One,Literal.Int32Zero,NodeType.Conditional,SystemTypes.Int32), NodeType.Add)); break; case NodeType.Product: // b := b * T(i) updateB = new AssignmentStatement(b, new BinaryExpression(b, comprehension.Elements[0], NodeType.Mul)); break; case NodeType.Sum: // b := b + T(i) updateB = new AssignmentStatement(b, new BinaryExpression(b, comprehension.Elements[0], NodeType.Add)); break; case NodeType.Max: // b := b < T(i) ? T(i) : b updateB = new AssignmentStatement(b, new TernaryExpression(new BinaryExpression(b, comprehension.Elements[0], NodeType.Lt, SystemTypes.Boolean), comprehension.Elements[0], b, NodeType.Conditional, SystemTypes.Int32)); break; case NodeType.Min: // b := b > T(i) ? T(i) : b updateB = new AssignmentStatement(b, new TernaryExpression(new BinaryExpression(b, comprehension.Elements[0], NodeType.Gt, SystemTypes.Boolean), comprehension.Elements[0], b, NodeType.Conditional, SystemTypes.Int32)); break; default: Debug.Assert(false); return null; } block.Statements.Add(updateB); #endregion assign the value of the term to the accumulator #region Generate the "foreach" and "if P(x)" parts for (int i = comprehension.BindingsAndFilters.Count - 1; i >= 0; i--) { ComprehensionBinding binding = comprehension.BindingsAndFilters[i] as ComprehensionBinding ; if (binding != null){ #region Test to see if loop should terminate early Expression condition = null; switch (quantifier.QuantifierType){ case NodeType.Forall: condition = new UnaryExpression(b,NodeType.LogicalNot,SystemTypes.Boolean); break; case NodeType.Exists: condition = b; break; case NodeType.ExistsUnique: condition = new BinaryExpression(b,Literal.Int32One,NodeType.Gt,SystemTypes.Boolean); break; case NodeType.Count: case NodeType.Max: case NodeType.Min: case NodeType.Product: case NodeType.Sum: condition = Literal.False; // no short-circuit!! Need to evaluate all of the terms! break; default: Debug.Assert(false); return null; } block.Statements.Add(new If(condition,new Block(new StatementList(new Exit())),null)); #endregion Test to see if loop should terminate early #region Wrap everything so far into a loop (either for or foreach) Expression forEachTargetVariable = binding.TargetVariable; if (binding.AsTargetVariableType != null){ Local l = new Local(Identifier.For("SS$dummyForEachVar"),binding.SourceEnumerable.Type,block); forEachTargetVariable = l; Block b2 = new Block(new StatementList(2)); b2.Statements.Add(new AssignmentStatement(binding.TargetVariable, new BinaryExpression(l,new MemberBinding(null,binding.AsTargetVariableType),NodeType.Isinst,binding.AsTargetVariableType))); b2.Statements.Add(new If(new BinaryExpression(binding.TargetVariable,new Literal(null,SystemTypes.Type),NodeType.Ne), block,null)); block = b2; } if (binding.SourceEnumerable== null) return null; CollectionEnumerator ce = binding.SourceEnumerable as CollectionEnumerator; UnaryExpression u = ce == null ? null : ce.Collection as UnaryExpression; BinaryExpression be = u == null ? null : u.Operand as BinaryExpression; if (be != null && be.NodeType == NodeType.Range){ // implement Range with a for-loop AssignmentStatement init = new AssignmentStatement(forEachTargetVariable,be.Operand1); AssignmentStatement incr = new AssignmentStatement(forEachTargetVariable, new BinaryExpression(forEachTargetVariable,new Literal(1,SystemTypes.Int32),NodeType.Add,SystemTypes.Int32)); Expression cond = new BinaryExpression(forEachTargetVariable,be.Operand2,NodeType.Le,SystemTypes.Boolean); #region Add loop invariant "be.Operand1 <= forEachTargetVariable" Block invariantBlock = new Block(new StatementList()); Assertion assertion = new Assertion(new BinaryExpression(be.Operand1, forEachTargetVariable, NodeType.Le, SystemTypes.Boolean)); assertion.SourceContext = be.SourceContext; foreach (Statement s in this.SerializeAssertion(this.currentModule, assertion.Condition, "For loop index must be at least first operand of range.", assertion.SourceContext, "LoopInvariant")) { invariantBlock.Statements.Add(s); } // need to put the generated invariants in the for-loop's condition because that's where VisitFor // puts any user-declared invariants. invariantBlock.Statements.Add(new ExpressionStatement(cond, cond.SourceContext)); cond = new BlockExpression(invariantBlock, SystemTypes.Boolean); #endregion For forloop = new For(new StatementList(init),cond,new StatementList(incr),block); block = new Block(new StatementList(forloop)); }else{ // Just use the source enumerable as an IEnumerable in a foreach loop ForEach fe = new ForEach(binding.SourceEnumerable.Type,forEachTargetVariable,binding.SourceEnumerable,block); fe.ScopeForTemporaryVariables = binding.ScopeForTemporaryVariables; block = new Block(new StatementList(fe)); } #endregion Wrap everything so far into a loop (either for or foreach) }else{ // it's a filter block = new Block(new StatementList(new If(comprehension.BindingsAndFilters[i],block,null))); } } #endregion #endregion } #region Choose initial value for accumulator Literal initialValue = null; switch (quantifier.QuantifierType){ case NodeType.Forall: initialValue = Literal.True; break; case NodeType.Exists: initialValue = Literal.False; break; case NodeType.ExistsUnique: case NodeType.Count: case NodeType.Sum: initialValue = Literal.Int32Zero; break; case NodeType.Product: initialValue = Literal.Int32One; break; case NodeType.Max: initialValue = new Literal(Int32.MinValue, SystemTypes.Int32); break; case NodeType.Min: initialValue = new Literal(Int32.MaxValue, SystemTypes.Int32); break; default: Debug.Assert(false); return null; } #endregion Choose initial value for accumulator #region Set the return value of the quantifier Expression valueToReturn = null; switch (quantifier.QuantifierType){ case NodeType.Forall: valueToReturn = b; break; case NodeType.Exists: valueToReturn = b; break; case NodeType.ExistsUnique: valueToReturn = new BinaryExpression(b,Literal.Int32One,NodeType.Eq,SystemTypes.Boolean); break; case NodeType.Count: case NodeType.Max: case NodeType.Min: case NodeType.Product: case NodeType.Sum: valueToReturn = b; break; default: Debug.Assert(false); return null; } #endregion Set the boolean to return as the value of the quantifier BlockExpression returnBlock = new BlockExpression( new Block(new StatementList( new AssignmentStatement(b,initialValue), block, new ExpressionStatement(valueToReturn))), SystemTypes.Boolean,comprehension.SourceContext); if (this.quantifiedVarStack == null) this.quantifiedVarStack = new System.Collections.Generic.Stack<ExpressionList>(); this.quantifiedVarStack.Push(comprehension.BindingsAndFilters); Expression result = this.VisitBlockExpression(returnBlock); this.quantifiedVarStack.Pop(); return result; }
public override void OnFirstShow() { base.OnFirstShow (); hooks = canvas.GetComponent<PartyControlHooks> (); if (hooks == null) return; hooks.OnForwardHook = Forward; hooks.OnBackHook = Back; hooks.OnRefreshHook = Refresh; hooks.OnNextHook = ChangeItem; game = Gameplay.GameManager.Instance.ActiveGame; hooks.ThemeBG = AssetsManager.Instance.ThemeBackGrounds [game.Theme.IconId]; indicationStars = new List<int> (); //id unico para os itens que estao na party, dois itens iguais teem que ter ids diferentes uniqueID = 0; inventoryTotalList = new List<Quantifier<SpecificItem>> (); //initialize my list with 2 tables and 8 chairs SpecificItem specificItemTable = GameManager.Instance.SpecificItems.Find (x => x.Id == 59); SpecificItem specificItemChair = GameManager.Instance.SpecificItems.Find (x => x.Id == 58); Quantifier <SpecificItem> tables = new Quantifier<SpecificItem> (2, specificItemTable); inventoryTotalList.Add (tables); Quantifier<SpecificItem> chairs = new Quantifier<SpecificItem> (8, specificItemChair); inventoryTotalList.Add (chairs); //preender a minha lista de inventorio foreach (Player player in game.Players) { for (int i = 0; i < player.Inventory.Count; i++) { SpecificItem specificItem = player.Inventory [i].Item; int index = inventoryTotalList.FindIndex (speItem => speItem.Item.Id == specificItem.Id); if (index == -1) { SpecificItem specificItemCopy = new SpecificItem (specificItem.Id, specificItem.Name, specificItem.IconId, specificItem.Price, specificItem.Theme, specificItem.GeneralItem); Quantifier<SpecificItem> itemToAddWithQTD = new Quantifier<SpecificItem> (player.Inventory [i].Quantity, specificItemCopy); inventoryTotalList.Add (itemToAddWithQTD); } else { inventoryTotalList [index].Quantity += player.Inventory [i].Quantity; } } } inventoryTotalSize = inventoryTotalList.Count (); itemsInContainerList = new List<Quantifier<SpecificItem>> (); foreach (GameObject item in hooks.ItemsArea) { item.GetComponent<ItemGeneral> ().AddItem = AddItem; } itemIndex = 0; updateScene (); }
/// <summary> /// Initializes a new insstance of an LessThanQuantifierFilter. /// </summary> /// <param name="leftHand">The value being compared to the set of values.</param> /// <param name="quantifier">The quantifier to use to compare the value to the set of values.</param> /// <param name="valueProvider">The source of values.</param> public LessThanQuantifierFilter(IFilterItem leftHand, Quantifier quantifier, IValueProvider valueProvider) : base(leftHand, quantifier, valueProvider) { }
public virtual Expression VisitQuantifier(Quantifier quantifier1, Quantifier quantifier2) { if (quantifier1 == null) return null; if (quantifier2 == null) { quantifier1.Comprehension = (Comprehension)this.VisitComprehension(quantifier1.Comprehension, null); } else { quantifier1.Comprehension = (Comprehension)this.VisitComprehension(quantifier1.Comprehension, quantifier2.Comprehension); } return quantifier1; }