internal static HashSet <Expression> Nominate(Func <Expression, bool> fnCanBeEvaluated, Expression expression) { Nominator nominator = new Nominator(fnCanBeEvaluated); nominator.Visit(expression); return(nominator.candidates); }
internal static Expression PartialEval(Expression expression, Func <Expression, bool> canBeEvaluated) { Nominator nominator = new Nominator(canBeEvaluated); HashSet <Expression> candidates = nominator.Nominate(expression); return(new SubtreeEvaluator(candidates).Eval(expression)); }
public static HashSet <Expression> Nominate(Expression expression, Func <Expression, bool> fnCanBeEvaluated) { var visitor = new Nominator(fnCanBeEvaluated); visitor.Visit(expression); return(visitor.candidates); }
internal static HashSet <Expression> Nominate(Func <Expression, bool> fnCanBeColumn, Expression expression) { var nominator = new Nominator(fnCanBeColumn); nominator.Visit(expression); return(nominator.candidates); }
public static HashSet <Expression> Nominate(Expression node) { var nominator = new Nominator(); nominator.Visit(node); return(nominator._candidates); }
public static Expression Evaluate(Expression node) { var candidates = Nominator.Nominate(node); var evaluator = new PartialEvaluator(candidates); return(evaluator.Visit(node)); }
/// <summary> /// Performs evaluation replacement of independent sub-trees /// </summary> /// <param name="expression">The root of the expression tree.</param> /// <param name="fnCanBeEvaluated">A function that decides whether a given expression node can be part of the local function.</param> /// <returns>A new tree with sub-trees evaluated and replaced.</returns> public static Expression Eval(System.Linq.Expressions.Expression expression, Func <System.Linq.Expressions.Expression, bool> fnCanBeEvaluated) { if (fnCanBeEvaluated == null) { fnCanBeEvaluated = AtkPartialEvaluator.CanBeEvaluatedLocally; } return(SubtreeEvaluator.Eval(Nominator.Nominate(fnCanBeEvaluated, expression), expression)); }
public void GiveAward(Nominator nominator) { // Business logic for validating a story is eligible for an award would // go in this function. var award = nominator.CreateAwardForStory(this); this.SetAward(award); // SetAward can now be private }
public static Expression Eval(Expression expression, Func <Expression, bool> fnCanBeEvaluated, Func <ConstantExpression, Expression> fnPostEval) { if (fnCanBeEvaluated == null) { fnCanBeEvaluated = PartialEvaluator.CanBeEvaluatedLocally; } return(SubtreeEvaluator.Eval(Nominator.Nominate(fnCanBeEvaluated, expression), fnPostEval, expression)); }
/// <summary> /// Performs evaluation & replacement of independent sub-trees /// </summary> /// <param name="expression">The root of the expression tree.</param> /// <param name="fnCanBeEvaluated">A function that decides whether a given expression node can be part of the local function.</param> /// <returns>A new tree with sub-trees evaluated and replaced.</returns> private static Expression Eval(Expression expression, Func <Expression, bool> fnCanBeEvaluated) { if (fnCanBeEvaluated == null) { fnCanBeEvaluated = PartialEvaluator.CanBeEvaluatedLocally; } return(SubtreeEvaluator.Eval(Nominator.Nominate(fnCanBeEvaluated, expression), expression)); }
private ColumnProjector(Func <Expression, bool> fnCanBeColumn, Expression expression, string newAlias, TextWriter logger, params string[] existingAliases) : base(logger) { this.newAlias = newAlias; this.existingAliases = existingAliases; this.map = new Dictionary <ColumnExpression, ColumnExpression>(); this.columns = new List <ColumnDeclaration>(); this.columnNames = new HashSet <string>(); this.candidates = Nominator.Nominate(fnCanBeColumn, expression, logger); }
public void GiveAward(Nominator nominator) { if (this.Award != null) { throw new... var award = nominator.CreateAwardForStory(this); } this.SetAward(award); // SetAward can now be private }
public static Expression EvaluatePartially(Expression expression) { var nominator = new Nominator(); nominator.Visit(expression); var candidates = nominator.Candidates; var evaluator = new SubtreeEvaluator(candidates); return(evaluator.Visit(expression)); }
public static HashSet <Expression> Nominate(QueryLanguage language, Expression expression) { var nominator = new Nominator(language); if (nominator != null) { nominator.Visit(expression); } return(nominator.candidates); }
public static Expression Simplify(Expression expression) { if (expression.NodeType == ExpressionType.Constant) return expression; var nominator = new Nominator(); nominator.Visit(expression); if (nominator.mayBeEvaluated.Count == 0) // no possible evaluations return expression; var ret = new Evaluator(nominator.mayBeEvaluated).Visit(expression); return ret; }
//overrided ToString() public override string ToString() { if (Denominator == 1) { return(Nominator.ToString()); } else { return(this.Nominator + "r" + this.Denominator); } }
/// <summary> /// Performs evaluation & replacement of independent sub-trees /// </summary> /// <param name="expression">The root of the expression tree.</param> /// <param name="fnCanBeEvaluated">A function that decides whether a given expression node can be part of the local function.</param> /// <returns>A new tree with sub-trees evaluated and replaced.</returns> public static Expression PartialEval(Expression expression, Func <Expression, bool> fnCanBeEvaluated) { var nominator = new Nominator(fnCanBeEvaluated); var candidates = nominator.Nominate(expression); var subtreeEvaluator = new SubtreeEvaluator(candidates); var newExpression = subtreeEvaluator.Eval(expression); return(newExpression); }
public override string ToString() { string result = ""; if (!Sign) { result += "-"; } result += Nominator.ToString(); result += "/"; result += Denominator.ToString(); return(result); }
public static Expression Simplify(Expression expression) { if (expression.NodeType == ExpressionType.Constant) { return(expression); } var nominator = new Nominator(); nominator.Visit(expression); if (nominator.mayBeEvaluated.Count == 0) // no possible evaluations { return(expression); } var ret = new Evaluator(nominator.mayBeEvaluated).Visit(expression); return(ret); }
private ColumnProjector(Func <Expression, bool> fnCanBeColumn, Expression expression, IEnumerable <ColumnDeclaration> existingColumns, TableAlias newAlias, IEnumerable <TableAlias> existingAliases) { this.newAlias = newAlias; this.existingAliases = new HashSet <TableAlias>(existingAliases); this.map = new Dictionary <ColumnExpression, ColumnExpression>(); if (existingColumns != null) { this.columns = new List <ColumnDeclaration>(existingColumns); this.columnNames = new HashSet <string>(existingColumns.Select(c => c.Name)); } else { this.columns = new List <ColumnDeclaration>(); this.columnNames = new HashSet <string>(); } this.candidates = Nominator.Nominate(fnCanBeColumn, expression); }
private ColumnProjector(Expression expression, IEnumerable <ColumnDeclaration> existingColumns, TableAlias newAlias, IEnumerable <TableAlias> existingAliases) { this.newAlias = newAlias; this.existingAliases = new HashSet <TableAlias>(existingAliases, TableAlias.Comparer); this.map = new Dictionary <ColumnExpression, ColumnExpression>(); if (existingColumns != null) { this.columns = new List <ColumnDeclaration>(existingColumns); this.columnNames = new HashSet <string>(existingColumns.Select(c => c.Name), StringComparer.Ordinal); } else { this.columns = new List <ColumnDeclaration>(); this.columnNames = new HashSet <string>(StringComparer.Ordinal); } this.candidates = Nominator.Nominate(expression); }
private ColumnProjector(QueryLanguage language, ProjectionAffinity affinity, Expression expression, IEnumerable <ColumnDeclaration> existingColumns, TableAlias newAlias, IEnumerable <TableAlias> existingAliases) { this.language = language; this.newAlias = newAlias; this.existingAliases = new HashSet <TableAlias>(existingAliases); this.map = new Dictionary <ColumnExpression, ColumnExpression>(); if (existingColumns != null) { this.columns = new List <ColumnDeclaration>(existingColumns); this.columnNames = new HashSet <string>(existingColumns.Select(c => c.Name)); } else { this.columns = new List <ColumnDeclaration>(); this.columnNames = new HashSet <string>(); } this.candidates = Nominator.Nominate(language, affinity, expression); }
/// <summary> /// Performs evaluation & replacement of independent sub-trees /// </summary> /// <param name="expression">The root of the expression tree.</param> /// <param name="fnCanBeEvaluated">A function that decides whether a given expression node can be part of the local function.</param> /// <returns>A new tree with sub-trees evaluated and replaced.</returns> public static Expression PartialEval(Expression expression, Func <Expression, bool> fnCanBeEvaluated) { HashSet <Expression> expns = new Nominator(fnCanBeEvaluated).Nominate(expression); return(new SubtreeEvaluator(expns).Eval(expression)); }
/// <summary> /// Performs evaluation & replacement of independent sub-trees /// </summary> /// <param name="expression"> The root of the expression tree. </param> /// <param name="fnCanBeEvaluated"> A function that decides whether a given expression node can be part of the local function. </param> /// <returns> A new tree with sub-trees evaluated and replaced. </returns> public static Expression PartialEval(Expression expression, Func<Expression, bool> fnCanBeEvaluated) { var nominator = new Nominator(fnCanBeEvaluated); var subtreeEvaluator = new SubtreeEvaluator(nominator.Nominate(expression)); return subtreeEvaluator.Eval(expression); }
public static Expression Evaluate(Expression expression) { var nominator = new Nominator(expression, exp => exp.NodeType != ExpressionType.Parameter); return new SubtreeEvaluator(nominator.Candidates).Visit(expression); }
public static Expression Evaluate(Expression expression) { var nominator = new Nominator(expression, exp => exp.NodeType != ExpressionType.Parameter); return(new SubtreeEvaluator(nominator.Candidates).Visit(expression)); }
//Set Player who use ColdRoom public void Interact(PlayerController pController) { gameManager.FreeMouse(); player = pController; if (player.pDatas.objectInHand == null) { ui.DisplayUiMenu(); // Display Menu } else // put object in coldRoom { Gastro gastroInHand = pController.pDatas.gastroInHand; if (gastroInHand == null) { Aliment foodToAdd = player.pDatas.objectInHand.GetComponent <Aliment>(); Nominator nominator = player.pDatas.objectInHand.GetComponent <Nominator>(); if (foodToAdd == null) // EXIT IF NO ALIMENT FOUND { GameManager.Instance.PopUp.CreateText("Imossible de placer " + nominator.customName + " dans la chambre froide", 50, new Vector2(0, 300), 3.0f); return; } photonView.RPC("PutObjectInColdRoom", RpcTarget.Others, player.photonView.OwnerActorNr); if ((foodToAdd.alimentState == AlimentState.Stack || foodToAdd.alimentState == AlimentState.Box)) // unlimited Food { if (!foodsStocked.Contains(foodToAdd.CreateKeyPairValue())) { AddFood(foodToAdd.CreateKeyPairValue(), true); player.pInteract.ReleaseObject(true, true, false); foodToAdd.GetComponent <Poolable>().DelObject(); // !!! chose : put food in pool (or put it on shelf) GeneralError.ErrorNoOutfit(pController); GameManager.Instance.PopUp.CreateText(nominator.customName + " déposé", 50, new Vector2(0, 300), 3.0f); } else { player.pInteract.ReleaseObject(true, true, false); foodToAdd.GetComponent <Poolable>().DelObject(); // !!! chose : put food in pool (or put it on shelf) GeneralError.ErrorNoOutfit(pController); GameManager.Instance.PopUp.CreateText(nominator.customName + " déposé", 50, new Vector2(0, 300), 3.0f); } } else // limited food { if (!limitedFoodsStocked.ContainsKey(foodToAdd.CreateKeyPairValue())) //first deposit { AddFood(foodToAdd.CreateKeyPairValue(), true); player.pInteract.ReleaseObject(true, true, false); foodToAdd.GetComponent <Poolable>().DelObject(); // !!! chose : put food in pool (or put it on shelf) GeneralError.ErrorNoOutfit(pController); GameManager.Instance.PopUp.CreateText(nominator.customName + " déposé", 50, new Vector2(0, 300), 3.0f); } else { limitedFoodsStocked[foodToAdd.CreateKeyPairValue()] += 1; player.pInteract.ReleaseObject(true, true, false); foodToAdd.GetComponent <Poolable>().DelObject(); // !!! chose : put food in pool (or put it on shelf) GeneralError.ErrorNoOutfit(pController); GameManager.Instance.PopUp.CreateText(nominator.customName + " déposé", 50, new Vector2(0, 300), 3.0f); } } } else { GameManager.Instance.PopUp.CreateText("Il n'est pas possible de déposer/utiliser un gastro ici", 50, new Vector2(0, 300), 3.0f); } } }
internal FieldProjector(Func<Expression, bool> fnCanBeField) { this.nominator = new Nominator(fnCanBeField); }
/// <summary> /// Performs evaluation & replacement of independent sub-trees /// </summary> /// <param name="expression">The root of the expression tree.</param> /// <param name="fnCanBeEvaluated"> /// A function that decides whether a given expression node can be part of the local /// function. /// </param> /// <returns>A new tree with sub-trees evaluated and replaced.</returns> static public Expression PartialEval(Expression expression, Func <Expression, bool> fnCanBeEvaluated) { return(SubtreeEvaluator.Eval(expression, Nominator.Nominate(fnCanBeEvaluated, expression))); }
public static HashSet<Expression> Nominate(Expression node) { var nominator = new Nominator(); nominator.Visit(node); return nominator._candidates; }
internal static Expression PartialEval(Expression expression, Func<Expression, bool> canBeEvaluated) { Nominator nominator = new Nominator(canBeEvaluated); return new SubtreeEvaluator(nominator.Nominate(expression)).Eval(expression); }
internal ColumnProjector(Expression expression, string newAlias, IEnumerable <string> existingAliases) { _candidates = Nominator.Nominate(existingAliases, expression); _newAlias = newAlias; }
public static HashSet<Expression> Nominate(Func<Expression, bool> canBeEvaluated, Expression expression) { Nominator nominator = new Nominator(canBeEvaluated); nominator.Visit(expression); return nominator._candidates; }
internal static HashSet<Expression> Nominate(QueryLanguage language, Expression expression) { Nominator nominator = new Nominator(language); nominator.Visit(expression); return nominator.candidates; }
/// <summary> /// Performs evaluation and replacement of independent sub-trees /// </summary> /// <param name="expression">The root of the expression tree.</param> /// <param name="fnCanBeEvaluated">A function that decides whether a given expression node can be part of the local function.</param> /// <returns>A new tree with sub-trees evaluated and replaced.</returns> public static Expression Eval(Expression expression, Func <Expression, bool> fnCanBeEvaluated) { return(SubtreeEvaluator.Eval(Nominator.Nominate(fnCanBeEvaluated, expression), expression)); }
public static Expression PartialEval(Expression expression) { Nominator nominator = new Nominator(); SubtreeEvaluator evaluator = new SubtreeEvaluator(nominator.Nominate(expression)); return evaluator.Eval(expression); }
internal static HashSet<Expression> Nominate(Func<Expression, bool> fnCanBeEvaluated, Expression expression) { Nominator nominator = new Nominator(fnCanBeEvaluated); nominator.Visit(expression); return nominator.candidates; }
internal static HashSet<Expression> Nominate(Expression expression) { Nominator nominator = new Nominator(); nominator.Visit(expression); return nominator.candidates; }
/// <summary> /// Performs evaluation & replacement of independent sub-trees /// </summary> /// <param name="expression">The root of the expression tree.</param> /// <param name="fnCanBeEvaluated">A function that decides whether a given expression node can be part of the local function.</param> /// <returns>A new tree with sub-trees evaluated and replaced.</returns> public static Expression PartialEval(Expression expression, Func <Expression, bool> fnCanBeEvaluated, TextWriter logger) { return(SubtreeEvaluator.Eval(Nominator.Nominate(fnCanBeEvaluated, expression, logger), expression, logger)); }
/// <summary> /// Performs evaluation & replacement of independent sub-trees /// </summary> /// <param name="expression">The root of the expression tree.</param> /// <param name="fnCanBeEvaluated">A function that decides whether a given expression node can be part of the local function.</param> /// <returns>A new tree with sub-trees evaluated and replaced.</returns> public static Expression ReduceSubtrees( Expression expression, Func<Expression, bool> fnCanBeEvaluated ) { HashSet<Expression> nominations = new Nominator(fnCanBeEvaluated).Nominate(expression); return new SubtreeEvaluator( nominations ).Eval( expression ); }
public Award(Story awardedTo, Nominator awardedBy) {
internal ColumnProjector(Func <Expression, bool> fnCanBeColumn) { this.nominator = new Nominator(fnCanBeColumn); }