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); }