/// /////////////////////////////////////////////////////////
        public CContexteEvaluationExpression(object objetSource, CCacheValeursProprietes cacheValeurs)
        {
            PushObjetSource(objetSource, true);
            if (OnNewContexteEvaluation != null)
            {
                OnNewContexteEvaluation(this);
            }
            if (cacheValeurs != null)
            {
                m_cache = cacheValeurs;
            }
            IAttacheurObjetsAContexteEvaluationExpression attacheur = objetSource as IAttacheurObjetsAContexteEvaluationExpression;

            if (attacheur != null)
            {
                attacheur.AttacheObjetsAContexteEvaluation(this);
            }
        }
Beispiel #2
0
        //----------------------------------------------------------
        /// <summary>
        /// Le data du result contient la valeur de la propriété pour l'objet
        /// </summary>
        /// <param name="objet"></param>
        /// <param name="strPropriete"></param>
        /// <returns></returns>
        public static CResultAErreur GetValue(object objet, string strProprieteComplete, CCacheValeursProprietes cache)
        {
            CResultAErreur          result       = CResultAErreur.True;
            IApplatisseurProprietes applatisseur = objet as IApplatisseurProprietes;

            if (applatisseur != null)
            {
                objet = applatisseur.GetObjetPourPropriete(strProprieteComplete);
            }
            if (cache != null && objet != null)
            {
                object valeur = cache.GetValeurCache(objet, strProprieteComplete);
                if (valeur != null)
                {
                    result.Data = valeur;
                    return(result);
                }
            }
            string[] strProprietes     = strProprieteComplete.Split('.');
            string   strPropriete      = strProprietes[0];
            string   strSuitePropriete = "";

            if (strProprieteComplete.Length > strPropriete.Length)
            {
                strSuitePropriete = strProprieteComplete.Substring(strPropriete.Length + 1);
            }
            string strCleType          = "";
            string strProprieteSansCle = "";

            if (CDefinitionProprieteDynamique.DecomposeNomProprieteUnique(strPropriete, ref strCleType, ref strProprieteSansCle))
            {
                object objetSource = null;
                if (cache != null)
                {
                    objetSource = cache.GetValeurCache(objet, strPropriete);
                }
                if (objetSource == null)
                {
                    strPropriete = strProprieteSansCle;
                    Type tpInterpreteur = null;
                    if (m_tableCleTypeToTypeInterpreteur.TryGetValue(strCleType.ToUpper(), out tpInterpreteur))
                    {
                        IInterpreteurProprieteDynamique interpreteur = Activator.CreateInstance(tpInterpreteur) as IInterpreteurProprieteDynamique;
                        if (interpreteur != null)
                        {
                            result = interpreteur.GetValue(objet, strPropriete);
                            if (!result)
                            {
                                return(result);
                            }
                            objetSource = result.Data;
                            if (result && cache != null)
                            {
                                cache.StockeValeurEnCache(objet, strProprietes[0], objetSource);
                            }
                        }
                    }
                    else
                    {
                        result.EmpileErreur(I.T("Can not find parser for @1|20001", strPropriete));
                        return(result);
                    }
                }
                if (objetSource != null && strSuitePropriete.Length > 0)
                {
                    result = GetValue(objetSource, strSuitePropriete);
                    if (result && cache != null)
                    {
                        cache.StockeValeurEnCache(objet, strProprieteComplete, result.Data);
                    }
                }
                return(result);
            }
            if (m_oldInterpreteur != null)
            {
                result.Data = m_oldInterpreteur.GetValue(objet, strProprieteComplete);
                return(result);
            }
            result.EmpileErreur(I.T("Bad property format (@1)|20000", strPropriete));
            return(result);
        }
Beispiel #3
0
 //----------------------------------------------------------
 public static CResultAErreur GetValue(object objet, CDefinitionProprieteDynamique defProp, CCacheValeursProprietes cache)
 {
     if (defProp != null)
     {
         CDefinitionMultiSourceForExpression source = objet as CDefinitionMultiSourceForExpression;
         if (source != null && !(defProp is CDefinitionProprieteDynamiqueSourceSupplementaire))
         {
             return(GetValue(source.ObjetPrincipal, defProp));
         }
         string strNomProp = defProp.NomPropriete;
         if (strNomProp.Length > 0 && strNomProp[0] != CDefinitionProprieteDynamique.c_strCaractereStartCleType &&
             m_oldInterpreteur != null)
         {
             CResultAErreur result = CResultAErreur.True;
             result.Data = m_oldInterpreteur.GetValue(objet, defProp);
             return(result);
         }
         return(GetValue(objet, strNomProp, cache));
     }
     return(CResultAErreur.True);
 }