internal static HashSet <Expression> Nominate(Func <Expression, bool> fnCanBeEvaluated, Expression expression)
            {
                Nominator nominator = new Nominator(fnCanBeEvaluated);

                nominator.Visit(expression);
                return(nominator.candidates);
            }
Пример #2
0
        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));
        }
Пример #3
0
            public static HashSet <Expression> Nominate(Expression expression, Func <Expression, bool> fnCanBeEvaluated)
            {
                var visitor = new Nominator(fnCanBeEvaluated);

                visitor.Visit(expression);
                return(visitor.candidates);
            }
Пример #4
0
            internal static HashSet <Expression> Nominate(Func <Expression, bool> fnCanBeColumn, Expression expression)
            {
                var nominator = new Nominator(fnCanBeColumn);

                nominator.Visit(expression);
                return(nominator.candidates);
            }
Пример #5
0
            public static HashSet <Expression> Nominate(Expression node)
            {
                var nominator = new Nominator();

                nominator.Visit(node);
                return(nominator._candidates);
            }
Пример #6
0
        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));
 }
Пример #10
0
 /// <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));
 }
Пример #11
0
 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);
 }
Пример #12
0
 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));
        }
Пример #14
0
            public static HashSet <Expression> Nominate(QueryLanguage language, Expression expression)
            {
                var nominator = new Nominator(language);

                if (nominator != null)
                {
                    nominator.Visit(expression);
                }

                return(nominator.candidates);
            }
Пример #15
0
 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);
     }
 }
Пример #17
0
            /// <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);
            }
Пример #18
0
        public override string ToString()
        {
            string result = "";

            if (!Sign)
            {
                result += "-";
            }

            result += Nominator.ToString();
            result += "/";
            result += Denominator.ToString();

            return(result);
        }
Пример #19
0
        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);
        }
Пример #20
0
 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);
 }
Пример #21
0
 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);
 }
Пример #22
0
 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);
 }
Пример #23
0
        /// <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));
        }
Пример #24
0
 /// <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);
 }
Пример #25
0
        public static Expression Evaluate(Expression expression)
        {
            var nominator = new Nominator(expression, exp => exp.NodeType != ExpressionType.Parameter);

            return new SubtreeEvaluator(nominator.Candidates).Visit(expression);
        }
Пример #26
0
        public static Expression Evaluate(Expression expression)
        {
            var nominator = new Nominator(expression, exp => exp.NodeType != ExpressionType.Parameter);

            return(new SubtreeEvaluator(nominator.Candidates).Visit(expression));
        }
Пример #27
0
    //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);
            }
        }
    }
Пример #28
0
 internal FieldProjector(Func<Expression, bool> fnCanBeField)
 {
     this.nominator = new Nominator(fnCanBeField);
 }
Пример #29
0
 /// <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)));
 }
Пример #30
0
 public static HashSet<Expression> Nominate(Expression node)
 {
     var nominator = new Nominator();
     nominator.Visit(node);
     return nominator._candidates;
 }
Пример #31
0
 internal static Expression PartialEval(Expression expression, Func<Expression, bool> canBeEvaluated)
 {
     Nominator nominator = new Nominator(canBeEvaluated);
     return new SubtreeEvaluator(nominator.Nominate(expression)).Eval(expression);
 }
Пример #32
0
 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;
 }
Пример #35
0
 /// <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));
 }
Пример #36
0
 public static Expression PartialEval(Expression expression)
 {
     Nominator nominator = new Nominator();
     SubtreeEvaluator evaluator = new SubtreeEvaluator(nominator.Nominate(expression));
     return evaluator.Eval(expression);
 }
Пример #37
0
 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;
			}
Пример #39
0
        /// <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));
        }
Пример #40
0
 /// <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 );
 }
Пример #41
0
 public Award(Story awardedTo, Nominator awardedBy)
 {
Пример #42
0
 internal ColumnProjector(Func <Expression, bool> fnCanBeColumn)
 {
     this.nominator = new Nominator(fnCanBeColumn);
 }