public SubExpressionUpdate(ICalculator calculator, IFunction callFunction, string val, int propIndex, IVariable relative)
 {
     if (propIndex == -1 && callFunction is IVariableReferencePropertyUsage)
     {
         if (val != relative.Name)
         {
             // Compute dependicy properties before returning the variable
             // in order to receive correct values.
             object var = calculator.ComputeVariable(val, null);
             string[] props = ((IVariableReferencePropertyUsage)callFunction).GetDependices(var.GetType());
             if (props != null)
             {
                 foreach (string prop in props)
                 {
                     Expression exp = calculator.GetExpressionObject(val + "." + prop);
                     if (exp != null)
                         m_expressionList.Add(exp);
                 }
             }
         }
     }
     else if (propIndex > 0)
     {
         // Compute property dependices before this.
         string name = val.Substring(0, propIndex);
         if (name != relative.Name)
         {
             object var = calculator.ComputeVariable(name, null);
             if (var is IOptimizable)
             {
                 IOptimizable opt = (IOptimizable)var;
                 PropertyDependicy[] deps = opt.PropertyDependices;
                 string prop = val.Substring(propIndex + 1);
                 if (deps != null)
                 {
                     Expression[] exps = new Expression[1];
                     foreach (PropertyDependicy dep in deps)
                     {
                         if (dep.ParentProperty == prop)
                         {
                             Expression exp = calculator.GetExpressionObject(name + "." + dep.ChildProperty);
                             if (exp != null)
                                 m_expressionList.Add(exp);
                         }
                     }
                 }
             }
         }
     }
 }
Exemplo n.º 2
0
 //Get a table with all expressions.
 public Expression[] GetExpressions()
 {
     Expression[] expressions = new Expression[m_expressions.Count];
     m_expressions.Values.CopyTo(expressions, 0);
     return expressions;
 }
Exemplo n.º 3
0
 //Computes the value and puts the result to property.
 public void Assign(string key, string expression)
 {
     string name = key.Substring(0, key.LastIndexOf(PROPERTY_CHAR));
     string prop = key.Substring(key.LastIndexOf(PROPERTY_CHAR) + 1);
     IVariable var = base.Variable(name);
     try
     {
         System.Reflection.PropertyInfo propertyInfo = var.GetType().GetProperty(prop);
         Type type = propertyInfo.PropertyType;
         object calcValue = this.Compute(expression, var);
         if (object.ReferenceEquals(type, typeof(float)))
         {
             calcValue = Convert.ToSingle(calcValue);
         }
         else if (object.ReferenceEquals(type, typeof(int)))
         {
             calcValue = Convert.ToInt32(calcValue);
         }
         else if (!object.ReferenceEquals(type, typeof(string)) && calcValue is string)
         {
             calcValue = Convert.ToString(calcValue);
         }
         var.GetType().InvokeMember(prop, System.Reflection.BindingFlags.SetProperty, null, var, new object[] {calcValue});
     }
     catch (Exception ex)
     {
         //Collection exceptions.
         if (ex is ExpressionException)
         {
             m_exceptions.AddException((ExpressionException)ex);
         }
         else if (ex is MissingMemberException)
         {
             //Incompatible datatype between property and expression.
             ExpressionException expressionException = new ExpressionException("Expression result is not compatible with property", 0, expression.Length);
             Expression exp = new Expression();
             exp.SetExpression(key, expression, this);
             expressionException.Expression = exp;
             m_exceptions.AddException(expressionException);
         }
     }
 }
Exemplo n.º 4
0
 //Add a new expression.
 public void AddExpression(string key, string expression)
 {
     Expression expr = new Expression();
     expr.SetExpression(key, expression, this);
     this.m_expressions.Add(key, expr);
 }
Exemplo n.º 5
0
 public Expression[] GetExpressions()
 {
     //(16.10.2006 09:02)
     //Make thread safe.
     lock (this)
     {
         //Create a list with indirect expressions last.
         int directCount = m_direct.Count;
         Expression[] exps = new Expression[directCount];
         m_direct.CopyTo(exps, 0);
         return exps;
     }
 }
Exemplo n.º 6
0
 public void Add(string key, Expression exp)
 {
     //(16.10.2006 09:02)
     //Make thread safe.
     lock (this)
     {
         if (!m_computing.Contains(key))
         {
             m_computing.Add(key, key);
             m_direct.Enqueue(exp);
             //Reset the buffer before computing.
             exp.ResetBuffer();
         }
     }
 }
Exemplo n.º 7
0
        //Copies the optimize info to another optimize manager so
        //optimzing is not necessary. Expressions should be exactly the same.
        public void CopyInfoTo(OptimizeManager optimizeManager)
        {
            //Set the expressions that is not optimizable.
            Expression[] notOptimizables = new Expression[this.m_notOptimizables.Length];
            Calculator calc = optimizeManager.Calculator;
            for (int i = 0; i < this.m_notOptimizables.Length; i++)
            {
                notOptimizables[i] = calc.GetExpressionObject(this.m_notOptimizables[i].Key);
            }
            optimizeManager.m_notOptimizables = notOptimizables;

            optimizeManager.m_eventGraph = new Hashtable();
            foreach (DictionaryEntry entry in this.m_eventGraph)
            {
                ArrayList events = (ArrayList)entry.Value;
                ArrayList newEvents = new ArrayList();
                foreach (Expression exp in events)
                    newEvents.Add(calc.GetExpressionObject(exp.Key));
                optimizeManager.m_eventGraph[entry.Key] = newEvents;
            }

            //Set the object map.
            IVariable[] variables = optimizeManager.Calculator.GetVariables();
            foreach (IVariable variable in variables)
            {
                if (variable is IOptimizable)
                    ((IOptimizable)variable).PropertyChanged += new PropertyChangedEventHandler(optimizeManager.PropertyChanged);
            }

            //Copy object references.
            optimizeManager.m_objectReferences = new ArrayList();
            foreach (string objectReference in this.m_objectReferences)
                optimizeManager.m_objectReferences.Add(objectReference);

            //Clone compute list.
            //Shares indirection info, which makes computation faster in the start.
            // optimizeManager.m_computeList = this.m_computeList.Clone();
            optimizeManager.m_computeList = new ComputeList();
        }