public CDefinitionProprieteDynamique
(
string strNomConvivial,
string strNomPropriete,
CTypeResultatExpression type,
bool bHasSubProprietes,
bool bIsReadOnly,
string strRubrique
)
{
m_strNomConvivial = strNomConvivial.Trim() == ""?strNomPropriete:strNomConvivial;
string strCle = "";
string strPropSansCle = "";
if (DecomposeNomProprieteUnique(strNomPropriete, ref strCle, ref strPropSansCle))
{
//Si la propriété contient déjà un type, et que ce n'est pas le même
//que le type de moi même, et qu'on n'appelle pas directement
//le constructeur de CDefintionProrieteDynamique mais celui d'une classe
//dérivée (dans ce cas CLEType != BS). En effet, on peut appeller un
//new CDefinitionProprieteDynamique directement en lui passant le CLETYPE,
//Mais qu'il ne s'agisse pas de BS. Dans ce cas, si pas de vérif, on créera
//une propriété avec #BS|#PP|Libelle par exemple si on a passé #PP comme nom
//de propriété
if (strCle != CleType && CleType != c_strCleType)
{
strNomPropriete = c_strCaractereStartCleType + CleType + c_strCaractereEndCleType + strNomPropriete;
}
}
else
{
strNomPropriete = c_strCaractereStartCleType + CleType + c_strCaractereEndCleType + strNomPropriete;
}
m_strNomPropriete = strNomPropriete;
m_typeDonnee = type;
m_bHasSubProprietes = bHasSubProprietes;
m_bIsReadOnly = bIsReadOnly;
m_strRubrique = strRubrique == null?"":strRubrique;
}
/// ///////////////////////////////////////////////////////////
public override CResultAErreur Serialize(C2iSerializer serializer)
{
int nVersion = GetNumVersion();
CResultAErreur result = serializer.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
result = base.Serialize(serializer);
if (!result)
{
return(result);
}
bool bHasTypeSource = m_objetPourAnalyseSource != null;
serializer.TraiteBool(ref bHasTypeSource);
if (bHasTypeSource)
{
switch (serializer.Mode)
{
case ModeSerialisation.Ecriture:
CTypeResultatExpression tp = m_objetPourAnalyseSource.TypeResultatExpression;
result = tp.Serialize(serializer);
break;
case ModeSerialisation.Lecture:
CTypeResultatExpression tpLecture = new CTypeResultatExpression();
result = tpLecture.Serialize(serializer);
m_objetPourAnalyseSource = new CObjetPourSousProprietes(tpLecture);
break;
}
}
else
{
m_objetPourAnalyseSource = null;
}
return(result);
}
///////////////////////////////////////////////
public void SetTypeDonnee(CTypeResultatExpression typeResultat)
{
m_typeDonnee = typeResultat;
}
/// ///////////////////////////////////////////////////////////
public override CResultAErreur VerifieParametres()
{
CResultAErreur result = CResultAErreur.True;
CInfo2iExpression info = GetInfos();
/*SC LE 9/1 : le nombre de paramètre est donnée par les définitions de paramètres
* if ( info.NbParametres != Parametres.Count )
* {
* string strMes = "Le nombre de paramètres est incorrect ("+info.NbParametres.ToString()+" attendu";
* if ( info.NbParametres > 1 )
* strMes+="s";
* result.EmpileErreur(strMes);
* return result;
* }*/
bool bSurchargeTrouvee = false;
foreach (CInfo2iDefinitionParametres defPar in info.InfosParametres)
{
if (defPar.TypesDonnees.Length <= Parametres.Count)
{
bSurchargeTrouvee = true;
int nParametre = 0;
foreach (C2iExpression exp in Parametres)
{
nParametre++;
if (exp == null)
{
result.EmpileErreur(I.T("The @1 parameter is null|105", nParametre.ToString()));
return(result);
}
else
{
if (nParametre <= defPar.TypesDonnees.Length)
{
CTypeResultatExpression typeAttendu = defPar.TypesDonnees[nParametre - 1];
if (exp.TypeDonnee != null && !exp.TypeDonnee.CanConvertTo(typeAttendu))
{
bSurchargeTrouvee = false;
break;
}
}
else if (GetNbParametresNecessaires() != -1)
{
bSurchargeTrouvee = false;
break;
}
}
}
}
if (bSurchargeTrouvee)
{
break;
}
}
if (!bSurchargeTrouvee)
{
result.EmpileErreur(I.T("No '@1' function overload match paramters|106", info.Texte));
}
return(result);
}
/// //////////////////////////////////////////
protected CTypeResultatExpression(CTypeResultatExpression tp, bool bIsArrayOfTypeNatif)
{
m_typeExpressionNatif = tp;
m_typeDotNetNatif = null;
m_bIsArray = bIsArrayOfTypeNatif;
}
/// //////////////////////////////////////////
public CTypeResultatExpression(Type tp, bool bIsArrayOfTypeNatif)
{
m_typeDotNetNatif = tp;
m_bIsArray = bIsArrayOfTypeNatif;
m_typeExpressionNatif = null;
}
/// ///////////////////////////////////////////////////////
public CInfo2iExpression(int nNiveau, string strIdExpression, string strTexte, CTypeResultatExpression typeDonnee, string strDescription, string strCategorie)
{
Init(nNiveau, strIdExpression, strTexte, typeDonnee, strDescription, strCategorie);
}
//-------------------------------------------------------------------------
public CInfoUnParametreExpression(string strNom, Type tp, bool bIsSortieSequence)
{
NomParametre = strNom;
TypeDonnee = new CTypeResultatExpression(tp, false);
IsSortieSequence = bIsSortieSequence;
}
//-------------------------------------------------------------------------
public CInfoUnParametreExpression(string strNom, Type tp)
{
NomParametre = strNom;
TypeDonnee = new CTypeResultatExpression(tp, false);
}
//-------------------------------------------------------------------------
public CInfoUnParametreExpression(string strNom, CTypeResultatExpression typeDonnee, bool bIsSortieSequence)
{
NomParametre = strNom;
TypeDonnee = typeDonnee;
IsSortieSequence = bIsSortieSequence;
}
//-------------------------------------------------------------------------
public CInfoUnParametreExpression(string strNom, CTypeResultatExpression typeDonnee)
{
NomParametre = strNom;
TypeDonnee = typeDonnee;
}
