/// //////////////////////////////////////////////////////////////
protected override sc2i.common.CResultAErreur MySerialize(sc2i.common.C2iSerializer serializer)
{
int nVersion = GetNumVersion();
CResultAErreur result = serializer.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
int nX, nY;
nX = m_lastPointArrivee.X;
nY = m_lastPointArrivee.Y;
serializer.TraiteInt(ref nX);
serializer.TraiteInt(ref nY);
m_lastPointArrivee.X = nX;
m_lastPointArrivee.Y = nY;
nX = m_lastPointDepart.X;
nY = m_lastPointDepart.Y;
serializer.TraiteInt(ref nX);
serializer.TraiteInt(ref nY);
m_lastPointDepart.X = nX;
m_lastPointDepart.Y = nY;
return(result);
}
//------------------------------------------------------
protected override sc2i.common.CResultAErreur MySerialize(sc2i.common.C2iSerializer serializer)
{
int nVersion = GetNumVersion();
CResultAErreur result = serializer.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
serializer.TraiteString(ref m_strIdUniverselEtape);
if (serializer.Mode == ModeSerialisation.Lecture && m_strIdUniverselEtape.Length > 0)
{
serializer.TrackDbKeyReaded(m_strIdUniverselEtape);
}
if (serializer.Mode == ModeSerialisation.Lecture)
{
m_typeEtape = null;
}
int nCol = m_backColor.ToArgb();
serializer.TraiteInt(ref nCol);
m_backColor = Color.FromArgb(nCol);
nCol = m_foreColor.ToArgb();
serializer.TraiteInt(ref nCol);
m_foreColor = Color.FromArgb(nCol);
return(result);
}
//----------------------------------------
protected override CResultAErreur MySerialize(sc2i.common.C2iSerializer serializer)
{
int nVersion = GetNumVersion();
CResultAErreur result = serializer.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
result = base.MySerialize(serializer);
if (!result)
{
return(result);
}
int nCol = BackColor.ToArgb();
serializer.TraiteInt(ref nCol);
m_backColor = Color.FromArgb(nCol);
nCol = ForeColor.ToArgb();
serializer.TraiteInt(ref nCol);
m_foreColor = Color.FromArgb(nCol);
int nBorder = (int)BorderStyle;
serializer.TraiteInt(ref nBorder);
BorderStyle = (EBorderStyle)nBorder;
result = serializer.TraiteListe <I2iObjetGraphique>(m_listeChilds);
return(result);
}
//-------------------------------------------------
protected override CResultAErreur MySerialize(sc2i.common.C2iSerializer serializer)
{
int nVersion = GetNumVersion();
CResultAErreur result = serializer.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
serializer.TraiteString(ref m_strIdUniverselLien);
if (serializer.Mode == ModeSerialisation.Lecture)
{
m_lien = null;
m_strIdUniverselDest = "";
m_strIdUniverselSource = "";
}
int nCol = m_couleurLien.ToArgb();
serializer.TraiteInt(ref nCol);
m_couleurLien = Color.FromArgb(nCol);
serializer.TraiteInt(ref m_nEpaisseurLien);
if (nVersion >= 1)
{
int nModeSortie = (int)m_modeSortie;
serializer.TraiteInt(ref nModeSortie);
m_modeSortie = (EModeSortieLien)nModeSortie;
}
return(result);
}
/// //////////////////////////////////////////////////////////////
protected override sc2i.common.CResultAErreur MySerialize(sc2i.common.C2iSerializer serializer)
{
int nVersion = GetNumVersion();
CResultAErreur result = serializer.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
serializer.TraiteInt(ref m_nIdActionArrivee);
serializer.TraiteInt(ref m_nIdActionDepart);
int nX, nY;
AssurePositionOk();
nX = m_lastPointArrivee.X;
nY = m_lastPointArrivee.Y;
serializer.TraiteInt(ref nX);
serializer.TraiteInt(ref nY);
m_lastPointArrivee.X = nX;
m_lastPointArrivee.Y = nY;
nX = m_lastPointDepart.X;
nY = m_lastPointDepart.Y;
serializer.TraiteInt(ref nX);
serializer.TraiteInt(ref nY);
m_lastPointDepart.X = nX;
m_lastPointDepart.Y = nY;
if (nVersion > 0)
{
serializer.TraiteInt(ref m_nId);
}
else
{
if (m_process != null)
{
m_nId = m_process.GetIdNouvelObjetDeProcess();
}
else
{
m_nId = -1;
}
}
if (nVersion >= 2)
{
int nTmp = (int)m_modeSortie;
serializer.TraiteInt(ref nTmp);
m_modeSortie = (EModeSortieLien)nTmp;
}
if (serializer.Mode == ModeSerialisation.Lecture)
{
m_bPositionInvalide = true;
}
return(result);
}
/// ///////////////////////////////////////////////
protected override sc2i.common.CResultAErreur MySerialize(sc2i.common.C2iSerializer serializer)
{
int nVersion = GetNumVersion();
CResultAErreur result = serializer.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
result = base.MySerialize(serializer);
if (!result)
{
return(result);
}
if (nVersion < 1 && serializer.Mode == ModeSerialisation.Lecture)
{
int nIdTemp = -1;
serializer.TraiteInt(ref nIdTemp);
m_strIdVariableForResult = nIdTemp.ToString();
}
else
{
serializer.TraiteString(ref m_strIdVariableForResult);
}
return(result);
}
public override CResultAErreur Serialize(sc2i.common.C2iSerializer serializer)
{
int nVersion = GetNumVersion();
CResultAErreur result = serializer.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
result = base.Serialize(serializer);
if (!result)
{
return(result);
}
int nTmp = (int)m_orientation;
serializer.TraiteInt(ref nTmp);
m_orientation = (EGraduationOrientation)nTmp;
nTmp = (int)m_HorizontalAlignment;
serializer.TraiteInt(ref nTmp);
m_HorizontalAlignment = (E3DAlignement)nTmp;
nTmp = (int)m_VerticalAlignment;
serializer.TraiteInt(ref nTmp);
m_VerticalAlignment = (E3DAlignement)nTmp;
nTmp = (int)DepthAlignment;
serializer.TraiteInt(ref nTmp);
m_DepthAlignment = (E3DAlignement)nTmp;
nTmp = (int)m_faceAlignement;
serializer.TraiteInt(ref nTmp);
m_faceAlignement = (EFaceVueDynamique)nTmp;
if (nVersion > 0)
{
string strTmp = AssociatedCoordinatePrefixes;
serializer.TraiteString(ref strTmp);
AssociatedCoordinatePrefixes = strTmp;
}
return(result);
}
//----------------------------------------------------
internal static void ReadFromOldId(C2iSerializer ser, ref CDbKey key)
{
int nTmp = 0;
ser.TraiteInt(ref nTmp);
if (nTmp >= 0)
{
key = new CDbKey(nTmp);
}
return;
}
//---------------------------------------------------
public override CResultAErreur MySerialize(sc2i.common.C2iSerializer serializer)
{
int nVersion = GetNumVersion();
CResultAErreur result = serializer.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
result = base.MySerialize(serializer);
if (!result)
{
return(result);
}
if (nVersion < 3)
{
// TESTDBKEYTODO
serializer.ReadDbKeyFromOldId(ref m_dbKeyTypeProjet, typeof(CTypeProjet));
}
else
{
serializer.TraiteDbKey(ref m_dbKeyTypeProjet);
}
int nId = m_nIdChampProjet == null ? -1 : m_nIdChampProjet.Value;
serializer.TraiteInt(ref nId);
if (serializer.Mode == ModeSerialisation.Lecture)
{
m_nIdChampProjet = nId >= 0 ? (int?)nId : null;
}
result = serializer.TraiteListe <CAffectationsProprietes>(m_listeAffectations);
if (!result)
{
return(result);
}
if (nVersion >= 1)
{
result = serializer.TraiteObject <C2iExpression>(ref m_formuleGanttId);
}
if (!result)
{
return(result);
}
if (nVersion >= 2)
{
serializer.TraiteBool(ref m_bGererIterations);
}
return(result);
}
//---------------------------------------------------
public CResultAErreur Serialize(sc2i.common.C2iSerializer serializer)
{
int nVersion = GetNumVersion();
CResultAErreur result = serializer.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
serializer.TraiteInt(ref m_nIdChampCustom);
serializer.TraiteString(ref m_strNomColonne);
serializer.TraiteType(ref m_typeDonnee);
return(result);
}
//---------------------------------------------------
public override CResultAErreur MySerialize(sc2i.common.C2iSerializer serializer)
{
int nVersion = GetNumVersion();
CResultAErreur result = serializer.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
serializer.TraiteString(ref m_strCleStepToStop);
int nAction = (int)TypeAction;
serializer.TraiteInt(ref nAction);
TypeAction = (ETypeActionExterneOnWorkflowStep)nAction;
return(result);
}
//------------------------------------------------
public CResultAErreur Serialize(sc2i.common.C2iSerializer serializer)
{
int nVersion = GetNumVersion();
CResultAErreur result = serializer.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
result = serializer.TraiteObject <CEasyQuery>(ref m_query);
if (result)
{
result = serializer.TraiteObject <CListeQuerySource>(ref m_listeSources);
}
if (!result)
{
return(result);
}
int nNbTables = m_listeTablesARetourner.Count;
serializer.TraiteInt(ref nNbTables);
switch (serializer.Mode)
{
case ModeSerialisation.Ecriture:
foreach (string strTable in m_listeTablesARetourner)
{
string strTmp = strTable;
serializer.TraiteString(ref strTmp);
}
break;
case ModeSerialisation.Lecture:
m_listeTablesARetourner.Clear();
for (int n = 0; n < nNbTables; n++)
{
string strTmp = "";
serializer.TraiteString(ref strTmp);
m_listeTablesARetourner.Add(strTmp);
}
break;
}
return(result);
}
//--------------------------------------------------
public CResultAErreur Serialize(C2iSerializer serializer)
{
int nVersion = GetNumVersion();
CResultAErreur result = serializer.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
int nNb = Count;
serializer.TraiteInt(ref nNb);
switch (serializer.Mode)
{
case ModeSerialisation.Lecture:
Clear();
for (int n = 0; n < nNb; n++)
{
CDbKey key = null;
serializer.TraiteDbKey(ref key);
if (key != null)
{
Add(key);
}
}
break;
case ModeSerialisation.Ecriture:
foreach (CDbKey key in this)
{
CDbKey tmp = key;
serializer.TraiteDbKey(ref tmp);
}
break;
}
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);
}
/// /////////////////////////////////////////////////////////
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);
}
/// ////////////////////////////////////////////////////////
protected override CResultAErreur MySerialize(sc2i.common.C2iSerializer serializer)
{
int nVersion = GetNumVersion();
CResultAErreur result = serializer.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
if (serializer.Mode == ModeSerialisation.Lecture &&
serializer.GetObjetAttache(typeof(CContexteDonnee)) != null)
{
ContexteDonnee = (CContexteDonnee)serializer.GetObjetAttache(typeof(CContexteDonnee));
}
else
{
ContexteDonnee = CContexteDonneeSysteme.GetInstance();
}
serializer.TraiteInt(ref m_nIdNextObjet);
if (nVersion > 0)
{
bool bHasType = TypeCible != null;
serializer.TraiteBool(ref bHasType);
if (bHasType)
{
serializer.TraiteType(ref m_typeCible);
}
else
{
m_typeCible = null;
}
}
else
{
m_typeCible = null;
}
//Lit les variables en premier car on en a besoin dans les actions
serializer.AttacheObjet(typeof(IElementAVariablesDynamiquesBase), this);
if (result)
{
result = serializer.TraiteArrayListOf2iSerializable(m_listeVariables, this);
}
foreach (IVariableDynamique variable in m_listeVariables)
{
if (variable.IdVariable == c_strIdVariableElement) //TESTDBKEYOK
{
m_variableCible = (CVariableProcessTypeComplexe)variable;
}
}
if (serializer.Mode == ModeSerialisation.Lecture)
{
foreach (IVariableDynamique var in m_listeVariables)
{
if (var.IdVariable == c_strIdVariableElement && var is CVariableProcessTypeComplexe)
{
m_variableCible = (CVariableProcessTypeComplexe)var;
m_typeCible = m_variableCible.TypeDonnee.TypeDotNetNatif;
m_bSurTableauDeCible = m_variableCible.TypeDonnee.IsArrayOfTypeNatif;
}
}
}
result = serializer.TraiteArrayListOf2iSerializable(m_listeActions, this);
if (result)
{
result = serializer.TraiteArrayListOf2iSerializable(m_listeLiensActions, this);
}
serializer.DetacheObjet(typeof(IElementAVariablesDynamiquesBase), this);
//Lit les valeurs des variables
if (nVersion > 2)
{
result = SerializeValeursVariables(nVersion, serializer);
}
if (nVersion >= 3)
{
serializer.TraiteBool(ref m_bModeAsynchrone);
}
else
{
m_bModeAsynchrone = false;
}
if (nVersion >= 4)
{
serializer.TraiteString(ref m_strLibelle);
}
AssureVariableCible();
if (nVersion >= 5)
{
I2iSerializable objet = m_infoDeclencheur;
serializer.TraiteObject(ref objet);
m_infoDeclencheur = (CInfoDeclencheurProcess)objet;
}
if (nVersion >= 7)
{
serializer.TraiteBool(ref m_bSurTableauDeCible);
}
else
{
m_bSurTableauDeCible = false;
}
if (nVersion >= 9)
{
serializer.TraiteString(ref m_strLastErreur);
}
else
{
m_strLastErreur = "";
}
if (nVersion >= 10)
{
if (nVersion < 14 && serializer.Mode == ModeSerialisation.Lecture)
{
int nIdTemp = -1;
serializer.TraiteInt(ref nIdTemp);
m_strIdVariableRetour = nIdTemp.ToString();
}
else
{
serializer.TraiteString(ref m_strIdVariableRetour);
}
}
Dictionary <int, I2iObjetGraphique> dicIdToObjet = null;
if (nVersion >= 12)
{
int nbEle = m_ordreZ.Count;
serializer.TraiteInt(ref nbEle);
if (serializer.Mode == ModeSerialisation.Lecture)
{
dicIdToObjet = new Dictionary <int, I2iObjetGraphique>();
foreach (CAction action in ListeActions)
{
dicIdToObjet[action.IdObjetProcess] = action;
}
foreach (CLienAction lien in ListeLiens)
{
dicIdToObjet[lien.IdObjetProcess] = lien;
}
m_ordreZ.Clear();
for (int n = 0; n < nbEle; n++)
{
int nId = 0;
serializer.TraiteInt(ref nId);
I2iObjetGraphique objTmp = null;
if (dicIdToObjet.TryGetValue(nId, out objTmp))
{
m_ordreZ.Add((IObjetDeProcess)objTmp);
}
}
}
else if (serializer.Mode == ModeSerialisation.Ecriture)
{
foreach (IObjetDeProcess objet in m_ordreZ)
{
int nCopy = objet.IdObjetProcess;
serializer.TraiteInt(ref nCopy);
}
}
}
else
{
m_ordreZ = new List <IObjetDeProcess>();
foreach (CAction action in ListeActions)
{
m_ordreZ.Add(action);
}
foreach (CLienAction lien in ListeLiens)
{
m_ordreZ.Add(lien);
}
}
if (nVersion >= 13)
{
serializer.TraiteBool(ref m_bModeTransactionnel);
}
else
{
m_bModeTransactionnel = false;
}
return(result);
}
/// //////////////////////////////////////
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 CResultAErreur Serialize(sc2i.common.C2iSerializer serializer)
{
CResultAErreur result = CResultAErreur.True;
int nVersion = GetNumVersion();
result = serializer.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
// Traite la liste des Ids de Types d'Alarmes
int nNbTypeAlarme = m_listeIdTypesAlarmes.Count;
serializer.TraiteInt(ref nNbTypeAlarme);
switch (serializer.Mode)
{
case ModeSerialisation.Ecriture:
foreach (CDbKey dbKey in m_listeIdTypesAlarmes)
{
CDbKey dbKeyTmp = dbKey;
serializer.TraiteDbKey(ref dbKeyTmp);
}
break;
case ModeSerialisation.Lecture:
m_listeIdTypesAlarmes.Clear();
for (int nVal = 0; nVal < nNbTypeAlarme; nVal++)
{
CDbKey dbKeyTmp = null;
serializer.TraiteDbKey(ref dbKeyTmp);
m_listeIdTypesAlarmes.Add(dbKeyTmp);
}
break;
}
// Traite la liste des Ids de Site
int nNbSites = m_listeIdSites.Count;
serializer.TraiteInt(ref nNbSites);
switch (serializer.Mode)
{
case ModeSerialisation.Ecriture:
foreach (CDbKey dbKey in m_listeIdSites)
{
CDbKey dbKeyTmp = dbKey;
serializer.TraiteDbKey(ref dbKeyTmp);
}
break;
case ModeSerialisation.Lecture:
m_listeIdSites.Clear();
for (int nVal = 0; nVal < nNbSites; nVal++)
{
CDbKey dbKeyTmp = null;
if (nVersion < 1)
{
serializer.ReadDbKeyFromOldId(ref dbKeyTmp, null);
}
else
{
serializer.TraiteDbKey(ref dbKeyTmp);
}
m_listeIdSites.Add(dbKeyTmp);
}
break;
}
// Traite la liste des Ids d'Equipements Logiques
int nNbEqpt = m_listeIdEquipementsLogiques.Count;
serializer.TraiteInt(ref nNbEqpt);
switch (serializer.Mode)
{
case ModeSerialisation.Ecriture:
foreach (CDbKey dbKey in m_listeIdEquipementsLogiques)
{
CDbKey dbKeyTemp = dbKey;
serializer.TraiteDbKey(ref dbKeyTemp);
}
break;
case ModeSerialisation.Lecture:
m_listeIdEquipementsLogiques.Clear();
for (int nVal = 0; nVal < nNbEqpt; nVal++)
{
CDbKey dbKeyTmp = null;
if (nVersion < 1)
{
serializer.ReadDbKeyFromOldId(ref dbKeyTmp, null);
}
else
{
serializer.TraiteDbKey(ref dbKeyTmp);
}
m_listeIdEquipementsLogiques.Add(dbKeyTmp);
}
break;
}
// Traite la liste des Ids de Liens Résaux
int nNbLiens = m_listeIdLiensReseau.Count;
serializer.TraiteInt(ref nNbLiens);
switch (serializer.Mode)
{
case ModeSerialisation.Ecriture:
foreach (CDbKey dbKey in m_listeIdLiensReseau)
{
CDbKey dbKeyTmp = dbKey;
serializer.TraiteDbKey(ref dbKeyTmp);
}
break;
case ModeSerialisation.Lecture:
m_listeIdLiensReseau.Clear();
for (int nVal = 0; nVal < nNbLiens; nVal++)
{
CDbKey dbKeyTmp = null;
if (nVersion < 1)
{
serializer.ReadDbKeyFromOldId(ref dbKeyTmp, null);
}
else
{
serializer.TraiteDbKey(ref dbKeyTmp);
}
m_listeIdLiensReseau.Add(dbKeyTmp);
}
break;
}
// Traite la liste des Ids d'Entité SNMP
int nNbEntites = m_listeIdEntitesSnmp.Count;
serializer.TraiteInt(ref nNbEntites);
switch (serializer.Mode)
{
case ModeSerialisation.Ecriture:
foreach (CDbKey dbKey in m_listeIdEntitesSnmp)
{
CDbKey dbKeyTmp = dbKey;
serializer.TraiteDbKey(ref dbKeyTmp);
}
break;
case ModeSerialisation.Lecture:
m_listeIdEntitesSnmp.Clear();
for (int nVal = 0; nVal < nNbEntites; nVal++)
{
CDbKey dbKeyTmp = null;
if (nVersion < 1)
{
serializer.ReadDbKeyFromOldId(ref dbKeyTmp, null);
}
else
{
serializer.TraiteDbKey(ref dbKeyTmp);
}
m_listeIdEntitesSnmp.Add(dbKeyTmp);
}
break;
}
return(result);
}
