private void testToolStripMenuItem_Click(object sender, EventArgs e)
{
((C2iExpressionGraphique)ObjetEdite).RefreshFormuleFinale();
C2iExpression formule = ((C2iExpressionGraphique)ObjetEdite).FormuleFinale;
if (formule != null)
{
if (MessageBox.Show(formule.GetString() + "\nTest ?", "", MessageBoxButtons.YesNo) == DialogResult.Yes)
{
CContexteEvaluationExpression ctx = new CContexteEvaluationExpression(m_objetAnalyse != null?m_objetAnalyse.ElementAVariableInstance:null);
sc2i.common.CResultAErreur result = formule.Eval(ctx);
if (!result)
{
CFormAfficheErreur.Show(result.Erreur);
}
else
{
MessageBox.Show(result.Data == null ? "null" : result.Data.ToString());
}
}
}
}
/// //////////////////////////////////////
public CResultAErreur Serialize(C2iSerializer serializer)
{
int nVersion = GetNumVersion();
CResultAErreur result = serializer.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
int nRestriction = (int)RestrictionGlobale;
serializer.TraiteInt(ref nRestriction);
RestrictionUtilisateur = (ERestriction)nRestriction;
serializer.TraiteType(ref m_type);
int nNb = m_tableRestrictions.Count;
serializer.TraiteInt(ref nNb);
switch (serializer.Mode)
{
case ModeSerialisation.Ecriture:
foreach (string strKey in m_tableRestrictions.Keys)
{
string strTmp = strKey;
nRestriction = (int)m_tableRestrictions[strKey];
serializer.TraiteString(ref strTmp);
serializer.TraiteInt(ref nRestriction);
}
break;
case ModeSerialisation.Lecture:
m_tableRestrictions.Clear();
for (int nKey = 0; nKey < nNb; nKey++)
{
string strKey = "";
int nRest = 0;
serializer.TraiteString(ref strKey);
if (nVersion < 3 && m_convertisseurCle != null)
{
strKey = m_convertisseurCle.GetCleRestrictionCompatible(strKey);
}
serializer.TraiteInt(ref nRest);
m_tableRestrictions[strKey] = (ERestriction)nRest;
}
break;
}
if (nVersion >= 1)
{
serializer.TraiteInt(ref m_nPriorite);
serializer.TraiteBool(ref m_bSurchageComplete);
}
if (nVersion >= 2)
{
int nNbExceptions = m_dicContextesExceptions.Count;
switch (serializer.Mode)
{
case ModeSerialisation.Ecriture:
serializer.TraiteInt(ref nNbExceptions);
foreach (string strTmp in m_dicContextesExceptions.Keys)
{
string strText = strTmp;
serializer.TraiteString(ref strText);
}
break;
case ModeSerialisation.Lecture:
serializer.TraiteInt(ref nNbExceptions);
List <String> lst = new List <string>();
for (int nException = 0; nException < nNbExceptions; nException++)
{
string strTmp = "";
serializer.TraiteString(ref strTmp);
lst.Add(strTmp);
}
ContextesException = lst.ToArray();
break;
}
}
return(result);
}
// //////////////////////////////////////////////
public virtual CResultAErreur TraiteObjetSimple(ref object obj, EnumTypeSimple typeSimple)
{
CResultAErreur result = CResultAErreur.True;
switch (typeSimple)
{
case EnumTypeSimple.Bool:
bool bVal = true;
if (Mode == ModeSerialisation.Ecriture)
{
bVal = (bool)obj;
}
TraiteBool(ref bVal);
obj = bVal;
break;
case EnumTypeSimple.Byte:
byte btVal = 0;
if (Mode == ModeSerialisation.Ecriture)
{
btVal = (byte)obj;
}
TraiteByte(ref btVal);
obj = btVal;
break;
case EnumTypeSimple.DateTime:
DateTime dtVal = DateTime.Now;
if (Mode == ModeSerialisation.Ecriture)
{
dtVal = (DateTime)obj;
}
TraiteDate(ref dtVal);
obj = dtVal;
break;
case EnumTypeSimple.Double:
double dVal = 0;
if (Mode == ModeSerialisation.Ecriture)
{
dVal = (double)obj;
}
TraiteDouble(ref dVal);
obj = dVal;
break;
case EnumTypeSimple.Int:
int nVal = 0;
if (Mode == ModeSerialisation.Ecriture)
{
nVal = (int)obj;
}
TraiteInt(ref nVal);
obj = nVal;
break;
case EnumTypeSimple.Null:
obj = null;
break;
case EnumTypeSimple.String:
string strVal = "";
if (Mode == ModeSerialisation.Ecriture)
{
strVal = (string)obj;
}
TraiteString(ref strVal);
obj = strVal;
break;
case EnumTypeSimple.Type:
Type tp = GetType();
if (Mode == ModeSerialisation.Ecriture)
{
tp = (Type)obj;
}
TraiteType(ref tp);
obj = tp;
break;
case EnumTypeSimple.Long:
long lVal = 0;
if (Mode == ModeSerialisation.Ecriture)
{
lVal = (long)obj;
}
TraiteLong(ref lVal);
obj = lVal;
break;
case EnumTypeSimple.Decimal:
Decimal dcVal = 0;
if (Mode == ModeSerialisation.Ecriture)
{
dcVal = (Decimal)obj;
}
TraiteDecimal(ref dcVal);
obj = dcVal;
break;
case EnumTypeSimple.Serializable:
I2iSerializable ser = obj as I2iSerializable;
result = TraiteObject(ref ser);
obj = ser;
break;
}
return(result);
}
/////////////////////////////////////////////////////////////////////////////
public static bool ToBool(CResultAErreur result)
{
return(result.m_bResult);
}
/// /////////////////////////////////////////////////////////
public CResultAErreur Serialize(C2iSerializer serializer)
{
int nVersion = GetNumVersion();
CResultAErreur result = serializer.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
int nNb = m_tableRestrictions.Count;
serializer.TraiteInt(ref nNb);
switch (serializer.Mode)
{
case ModeSerialisation.Ecriture:
foreach (Type tp in m_tableRestrictions.Keys)
{
Type tpTemp = tp;
I2iSerializable restriction = (I2iSerializable)m_tableRestrictions[tp];
serializer.TraiteType(ref tpTemp);
result = serializer.TraiteObject(ref restriction);
if (!result)
{
return(result);
}
}
break;
case ModeSerialisation.Lecture:
m_tableRestrictions.Clear();
for (int nType = 0; nType < nNb; nType++)
{
Type tp = null;
I2iSerializable rest = null;
serializer.TraiteType(ref tp);
result = serializer.TraiteObject(ref rest, tp);
if (!result)
{
return(result);
}
if (tp != null)
{
m_tableRestrictions[tp] = rest;
}
}
break;
}
if (nVersion >= 1)
{
serializer.TraiteBool(ref m_bIsAdministrateur);
}
if (nVersion >= 2)
{
bool bHasAnnulation = SeuilAnnulationPriorites != null;
serializer.TraiteBool(ref bHasAnnulation);
if (bHasAnnulation)
{
int nTmp = SeuilAnnulationPriorites == null ? 0 : (int)m_nSeuilAnnulationPriorites;
serializer.TraiteInt(ref nTmp);
SeuilAnnulationPriorites = nTmp;
}
}
return(result);
}
public CResultAErreur Serialize(C2iSerializer serializer)
{
int nVersion = GetNumVersion();
CResultAErreur result = serializer.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
if (serializer.Mode == ModeSerialisation.Ecriture)
{
result = VerifieCoherence();
}
if (!result)
{
return(result);
}
serializer.TraiteBool(ref m_bLignesString);
serializer.TraiteBool(ref m_bColonnesString);
serializer.TraiteDouble(ref m_dValeurDefaut);
int nRes = (int)MethodeResolutionLignes;
serializer.TraiteInt(ref nRes);
MethodeResolutionLignes = (MethodeResolutionValeurMatrice)nRes;
nRes = (int)MethodeResolutionColonne;
serializer.TraiteInt(ref nRes);
MethodeResolutionColonne = (MethodeResolutionValeurMatrice)nRes;
int nNbLignes = Lignes.Length;
serializer.TraiteInt(ref nNbLignes);
if (serializer.Mode == ModeSerialisation.Lecture)
{
m_lignes = new object[nNbLignes];
}
SerializeTable(serializer, m_lignes, LignesString);
int nNbColonnes = Colonnes.Length;
serializer.TraiteInt(ref nNbColonnes);
if (serializer.Mode == ModeSerialisation.Lecture)
{
m_colonnes = new object[nNbColonnes];
}
SerializeTable(serializer, m_colonnes, ColonnesString);
//Sérialization des valeurs
if (serializer.Mode == ModeSerialisation.Lecture)
{
m_valeurs = new double[nNbLignes, nNbColonnes];
}
for (int nLigne = 0; nLigne < nNbLignes; nLigne++)
{
for (int nCol = 0; nCol < nNbColonnes; nCol++)
{
double dVal = 0;
if (serializer.Mode == ModeSerialisation.Ecriture)
{
dVal = m_valeurs[nLigne, nCol];
}
serializer.TraiteDouble(ref dVal);
m_valeurs[nLigne, nCol] = dVal;
}
}
return(result);
}
//---------------------------------------------------
/// <summary>
/// Vérifie qu'il y a le bon nombre de ligne et de colonnes
/// dans les valeurs, que les colonnes et les lignes sont du bon type./
/// </summary>
/// <returns></returns>
public CResultAErreur VerifieCoherence()
{
CResultAErreur result = CResultAErreur.True;
if (m_lignes.Length == 0)
{
result.EmpileErreur(I.T("The array must contain at least a line|30047"));
}
if (m_colonnes.Length == 0)
{
result.EmpileErreur(I.T("The array must contain at least a column|30048"));
}
if (!result)
{
return(result);
}
if (m_valeurs.Length != m_lignes.Length * m_colonnes.Length)
{
result.EmpileErreur(I.T("The value array has an incorrect size|30049"));
}
Type tpLigne = LignesString?typeof(string):typeof(double);
Hashtable tableValeurs = new Hashtable();
foreach (object obj in m_lignes)
{
if (!obj.GetType().Equals(tpLigne))
{
result.EmpileErreur(I.T("At least one line header value is incorrect|30050"));
break;
}
if (tableValeurs[obj] != null)
{
result.EmpileErreur(I.T("At least one line header value is not unique|30051"));
break;
}
tableValeurs[obj] = true;
}
Type tpCol = ColonnesString?typeof(string):typeof(double);
tableValeurs.Clear();
foreach (object obj in m_colonnes)
{
if (!obj.GetType().Equals(tpCol))
{
result.EmpileErreur(I.T("At least one column header value is incorrect|30052"));
break;
}
if (tableValeurs[obj] != null)
{
result.EmpileErreur(I.T("At least one column header value is not unique|30053"));
break;
}
tableValeurs[obj] = true;
}
if (LignesString && MethodeResolutionLignes != MethodeResolutionValeurMatrice.ExactOuValeurDefaut)
{
result.EmpileErreur(I.T("The line resolution method is not compatible with text lines|30054"));
return(result);
}
if (ColonnesString && MethodeResolutionColonne != MethodeResolutionValeurMatrice.ExactOuValeurDefaut)
{
result.EmpileErreur(I.T("The column resolution method is not compatible with text columns|30055"));
return(result);
}
result = VerifieEnteteAvecMethode(Lignes, MethodeResolutionLignes);
if (!result)
{
result.EmpileErreur(I.T("Line header error|30114"));
}
result = VerifieEnteteAvecMethode(Colonnes, MethodeResolutionColonne);
if (!result)
{
result.EmpileErreur(I.T("Column header error|30115"));
}
return(result);
}
