예제 #1
0
 //-----------------------------------------------
 public void AddVariable(CDefinitionProprieteDynamiqueVariableFormule variable)
 {
     if (m_listeVariables.FirstOrDefault(v => v.Nom.ToUpper() == variable.Nom.ToUpper()) == null)
     {
         m_listeVariables.Add(variable);
     }
 }
        public void SetValeurVariable(CDefinitionProprieteDynamique defProp, object valeur)
        {
            CDefinitionProprieteDynamiqueVariableFormule defFormule = defProp as CDefinitionProprieteDynamiqueVariableFormule;

            if (defFormule != null)
            {
                m_tableValeursVariables[defFormule.Nom.ToUpper()] = valeur;
            }
        }
        /// /////////////////////////////////////////////////////////
        protected object GetValeurChamp(object source, CDefinitionProprieteDynamique propriete)
        {
            CDefinitionProprieteDynamiqueVariableFormule defFormule = propriete as CDefinitionProprieteDynamiqueVariableFormule;

            if (defFormule != null)
            {
                return(GetValeurVariable(defFormule));
            }
            if (source != null && m_bUseOptimiseurs)
            {
                Type   tp     = source.GetType();
                string strKey = tp.ToString() + "/" + propriete.NomPropriete;
                IOptimiseurGetValueDynamic optimiseur = null;
                bool bDejaCherche = false;
                if (m_dicOptimiseurs.TryGetValue(strKey, out optimiseur))
                {
                    bDejaCherche = true;
                }
                if (!bDejaCherche)
                {
                    optimiseur = CInterpreteurProprieteDynamique.GetOptimiseur(tp, propriete.NomPropriete);
                    m_dicOptimiseurs[strKey] = optimiseur;
                }
                if (optimiseur != null)
                {
                    return(optimiseur.GetValue(source));
                }
            }
            CResultAErreur result = CInterpreteurProprieteDynamique.GetValue(source, propriete, m_cache);

            if (result)
            {
                return(result.Data);
            }
            if (m_oldInterpreteur != null)
            {
                return(m_oldInterpreteur.GetValue(source, propriete));
            }
            return(null);
        }
예제 #4
0
        //-----------------------------------------------
        public void ReplaceVariable(CDefinitionProprieteDynamiqueVariableFormule oldVar,
                                    CDefinitionProprieteDynamiqueVariableFormule newVar)
        {
            int?nIndex = null;

            if (oldVar != null)
            {
                nIndex = m_listeVariables.IndexOf(oldVar);
                if (nIndex < 0)
                {
                    nIndex = null;
                }
                m_listeVariables.Remove(oldVar);
            }
            if (nIndex == null || m_listeRepresentations.Count - 1 < nIndex.Value)
            {
                m_listeVariables.Add(newVar);
            }
            else
            {
                m_listeVariables.Insert(nIndex.Value, newVar);
            }
        }
예제 #5
0
 public void AddVariable(CDefinitionProprieteDynamiqueVariableFormule def)
 {
     m_tableVariables[def.Nom.ToUpper()] = def;
     m_cacheDefs.Clear();
 }
예제 #6
0
        /// //////////////////////////////////////////
        public override CResultAErreur AfterAnalyse(CAnalyseurSyntaxique analyseur)
        {
            CResultAErreur result     = CResultAErreur.True;
            bool           bIsTableau = false;
            Type           tp         = null;
            CAnalyseurSyntaxiqueExpression analyseurExpression = analyseur as CAnalyseurSyntaxiqueExpression;

            if (analyseurExpression != null)
            {
                C2iExpressionChamp champ = Parametres2i[0] as C2iExpressionChamp;
                //Vérifie que les paramètres sont bien des constantes string
                bool bParamOk = false;
                if (Parametres.Count >= 2)
                {
                    if (Parametres[0] is C2iExpressionChamp &&
                        (Parametres[1] is C2iExpressionConstante || Parametres[1] is C2iExpressionTypesDynamics) &&
                        (Parametres.Count != 3 || Parametres[2] is C2iExpressionConstante || Parametres[2] is C2iExpressionVrai || Parametres[2] is C2iExpressionFaux))
                    {
                        if (Parametres[1] is C2iExpressionTypesDynamics)
                        {
                            tp = ((C2iExpressionTypesDynamics)Parametres[1]).TypeReprésenté;
                        }
                        else if (Parametres[1] is Type)
                        {
                            tp = Parametres[1] as Type;
                        }
                        else
                        {
                            string strType = ((C2iExpressionConstante)Parametres2i[1]).Valeur.ToString();
                            tp = CActivatorSurChaine.GetType(strType, true);
                        }
                        if (tp == null)
                        {
                            result.EmpileErreur(I.T("The @1 type doesn't exist|136", Parametres[1].ToString()));
                            return(result);
                        }
                        else
                        {
                            if (Parametres.Count == 3 &&
                                Parametres2i[2] is C2iExpressionConstante)
                            {
                                if (((C2iExpressionConstante)Parametres[2]).Valeur is int)
                                {
                                    bIsTableau = (int)(((C2iExpressionConstante)Parametres[2]).Valeur) != 0;
                                }
                                if (((C2iExpressionConstante)Parametres[2]).Valeur is bool)
                                {
                                    bIsTableau = (bool)((C2iExpressionConstante)Parametres[2]).Valeur;
                                }
                            }
                            if (Parametres.Count == 3 && Parametres[2] is C2iExpressionVrai)
                            {
                                bIsTableau = true;
                            }
                            if (Parametres.Count == 3 && Parametres[2]  is C2iExpressionFaux)
                            {
                                bIsTableau = false;
                            }
                            bParamOk = true;
                        }
                    }
                }
                if (!bParamOk)
                {
                    result.EmpileErreur(I.T("The Var function paramters are invalid (two constant string are awaited and possibly one Boolean for the table)|138"));
                    return(result);
                }

                CDefinitionProprieteDynamiqueVariableFormule def = new CDefinitionProprieteDynamiqueVariableFormule(
                    champ.DefinitionPropriete.Nom,
                    new CTypeResultatExpression(tp, bIsTableau),
                    false);
                champ.DefinitionPropriete = def;
                analyseurExpression.AddVariable(def);
            }
            return(base.AfterAnalyse(analyseur));
        }
 public object GetValeurVariable(CDefinitionProprieteDynamiqueVariableFormule def)
 {
     return(m_tableValeursVariables[def.Nom.ToUpper()]);
 }
예제 #8
0
 /// /////////////////////////////////////////////////
 public void AddVariable(CDefinitionProprieteDynamiqueVariableFormule def)
 {
     m_contexteAnalyse.AddVariable(def);
 }
예제 #9
0
        /// //////////////////////////////////////////
        protected override CResultAErreur ProtectedEval(CContexteEvaluationExpression ctx)
        {
            CResultAErreur result = CResultAErreur.True;

            try
            {
                C2iExpressionChamp champFinal = null;
                object             objSource  = ctx.ObjetSource;
                result = GetSourceEtChampFinal(Parametres2i[0], ctx, ref objSource, ref champFinal);
                if (!result)
                {
                    return(result);
                }
                if (champFinal == null)
                {
                    result.EmpileErreur(I.T("Impossible to affect a value to @1|133", Parametres2i[0].ToString()));
                    return(result);
                }

                result = Parametres2i[1].Eval(ctx);
                if (!result)
                {
                    return(result);
                }
                object valeur = result.Data;
                CDefinitionProprieteDynamiqueVariableFormule propFormule = champFinal.DefinitionPropriete as CDefinitionProprieteDynamiqueVariableFormule;
                if (propFormule != null)
                {
                    ctx.SetValeurVariable(propFormule, valeur);
                }
                else
                {
                    if (objSource == null)
                    {
                        return(result);
                    }
                    SynchronizationContext c = ctx.SynchronizationContext;

                    if (c != null)
                    {
                        c.Post(x => CInterpreteurProprieteDynamique.SetValue(objSource, champFinal.DefinitionPropriete.NomPropriete, valeur), null);
                    }
                    else
                    {
                        result = CInterpreteurProprieteDynamique.SetValue(objSource, champFinal.DefinitionPropriete.NomPropriete, valeur);
                    }
                }
                if (result)
                {
                    result.Data = valeur;
                    if (objSource != null)
                    {
                        ctx.Cache.ResetCache(objSource);
                    }
                }
            }
            catch (Exception e)
            {
                result.EmpileErreur(new CErreurException(e));
            }
            return(result);
        }
예제 #10
0
        //--------------------------------------------------
        /// <summary>
        /// crée les éléments graphiques d'une formule
        /// </summary>
        /// <param name="formule"></param>
        public void InitFromFormule(C2iExpression formule)
        {
            m_listeRepresentations.Clear();
            m_listeVariables.Clear();
            if (formule == null)
            {
                return;
            }
            ArrayList lst = formule.ExtractExpressionsType(typeof(C2iExpressionVariable));

            foreach (C2iExpressionVariable variable in lst)
            {
                if (variable.Parametres.Count > 0)
                {
                    C2iExpressionChamp champ = variable.Parametres[0] as C2iExpressionChamp;
                    if (champ != null)
                    {
                        CDefinitionProprieteDynamiqueVariableFormule def = champ.DefinitionPropriete as CDefinitionProprieteDynamiqueVariableFormule;
                        if (def != null)
                        {
                            m_listeVariables.Add(def);
                        }
                    }
                }
            }
            C2iExpressionBegin begin = formule as C2iExpressionBegin;

            m_strIdStartPoint = "";
            int nX = 100;
            int nY = 20;

            if (begin != null)
            {
                CRepresentationExpressionGraphique previous = null;
                foreach (C2iExpression action in begin.Parametres)
                {
                    if (!(action is C2iExpressionVariable))
                    {
                        CRepresentationExpressionGraphique rep = new CRepresentationExpressionGraphique();
                        rep.Position = new Point(nX, nY);
                        AddChild(rep);
                        rep.Parent  = this;
                        rep.Formule = action;
                        nY          = rep.RectangleAbsolu.Bottom;
                        foreach (CRepresentationExpressionGraphique repTmp in m_listeRepresentations)
                        {
                            if (repTmp.RectangleAbsolu.Bottom > nY)
                            {
                                nY = rep.RectangleAbsolu.Bottom;
                            }
                        }
                        nY += 20;
                        if (previous == null)
                        {
                            StartPoint = rep;
                        }
                        else
                        {
                            previous.Next = rep;
                        }
                        previous = rep;
                    }
                }
            }
            else
            {
                CRepresentationExpressionGraphique rep = new CRepresentationExpressionGraphique();
                rep.Position = new Point(nX, nY);
                AddChild(rep);
                rep.Parent  = this;
                rep.Formule = formule;
                StartPoint  = rep;
            }
        }
예제 #11
0
 //-----------------------------------------------
 public void RemoveVariable(CDefinitionProprieteDynamiqueVariableFormule variable)
 {
     m_listeVariables.Remove(variable);
 }