//-------------------------------------------------
public CResultAErreur Serialize(C2iSerializer serializer)
{
int nVersion = GetNumVersion();
CResultAErreur result = serializer.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
serializer.TraiteListeInt(m_listeIdSitesVisibles);
serializer.TraiteListeInt(m_listeIdActeursVisibles);
serializer.TraiteListeInt(m_listeIdRessourcesVisibles);
serializer.TraiteDate(ref m_dateDebut);
serializer.TraiteDate(ref m_dateFin);
serializer.TraiteBool(ref m_bNonPlanifiesOnly);
serializer.TraiteBool(ref m_bNonAffectesOnly);
serializer.TraiteIntNullable(ref m_nIdListeFiltreInters);
result = serializer.TraiteObject <CFiltreDynamique>(ref m_filtreDynamiqueInters);
if (!result)
{
return(result);
}
serializer.TraiteString(ref m_strLibelleFiltreInters);
return(result);
}
//---------------------------------------------
public CResultAErreur Serialize(C2iSerializer serializer)
{
int nVersion = GetNumVersion();
CResultAErreur result = serializer.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
serializer.TraiteDate(ref m_dateDebut);
serializer.TraiteDate(ref m_dateFin);
return(result);
}
//--------------------------------------
public CResultAErreur Serialize(C2iSerializer serializer)
{
int nVersion = GetNumVersion();
CResultAErreur result = serializer.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
byte nTmp = (byte)TypeDonnee;
if (m_valeur == null)
{
nTmp = byte.MaxValue;
}
serializer.TraiteByte(ref nTmp);
if (nTmp != byte.MaxValue)
{
ETypeChampBasique typeDonnee = (ETypeChampBasique)nTmp;
switch (typeDonnee)
{
case ETypeChampBasique.String:
string strVal = StringValue;
serializer.TraiteString(ref strVal);
StringValue = strVal;
break;
case ETypeChampBasique.Int:
int nVal = IntValue == null ? 0 : IntValue.Value;
serializer.TraiteInt(ref nVal);
IntValue = nVal;
break;
case ETypeChampBasique.Decimal:
double fVal = DoubleValue == null ? 0.0 : DoubleValue.Value;
serializer.TraiteDouble(ref fVal);
DoubleValue = fVal;
break;
case ETypeChampBasique.Date:
DateTime dtValue = DateTimeValue == null ? default(DateTime) : DateTimeValue.Value;
serializer.TraiteDate(ref dtValue);
DateTimeValue = dtValue;
break;
case ETypeChampBasique.Bool:
bool bVal = BoolValue == null ? default(bool) : BoolValue.Value;
serializer.TraiteBool(ref bVal);
BoolValue = bVal;
break;
}
}
return(result);
}
public CResultAErreur Serialize(C2iSerializer serializer)
{
int nVersion = GetNumVersion();
CResultAErreur result = serializer.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
serializer.TraiteString(ref m_strNom);
serializer.TraiteDate(ref m_lastModifDate);
serializer.TraiteLong(ref m_nSize);
serializer.TraiteDbKey(ref m_keyObjetAssocie);
serializer.TraiteType(ref m_typeObjetAssocie);
serializer.TraiteDateTimeNullable(ref m_lastModifDateLorsDeImport);
serializer.TraiteString(ref m_strInfoImport);
return(result);
}
/// ///////////////////////////////////////////////////////
public override CResultAErreur Serialize(C2iSerializer serializer)
{
int nVersion = GetNumVersion();
CResultAErreur result = serializer.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
int nType = (int)ConstTypes.tNull;
if (serializer.Mode == ModeSerialisation.Ecriture)
{
if (m_valeur == null)
{
nType = (int)ConstTypes.tNull;
}
else if (m_valeur.GetType() == typeof(string))
{
nType = (int)ConstTypes.tString;
}
else if (m_valeur.GetType() == typeof(int))
{
nType = (int)ConstTypes.tInt;
}
else if (m_valeur.GetType() == typeof(bool))
{
nType = (int)ConstTypes.tBool;
}
else if (m_valeur.GetType() == typeof(DateTime))
{
nType = (int)ConstTypes.tDateTime;
}
else if (m_valeur.GetType() == typeof(double))
{
nType = (int)ConstTypes.tDouble;
}
else
{
throw new Exception(I.T("Constant type not managed : @1|110", m_valeur.GetType().ToString()));
}
}
serializer.TraiteInt(ref nType);
switch (serializer.Mode)
{
case ModeSerialisation.Ecriture:
switch ((ConstTypes)nType)
{
case ConstTypes.tBool:
bool b = (bool)m_valeur;
serializer.TraiteBool(ref b);
break;
case ConstTypes.tDateTime:
DateTime dt = (DateTime)m_valeur;
serializer.TraiteDate(ref dt);
break;
case ConstTypes.tDouble:
Double f = (double)m_valeur;
serializer.TraiteDouble(ref f);
break;
case ConstTypes.tInt:
int nVal = (int)m_valeur;
serializer.TraiteInt(ref nVal);
break;
case ConstTypes.tNull:
break;
case ConstTypes.tString:
string strVal = (string)m_valeur;
serializer.TraiteString(ref strVal);
break;
}
break;
case ModeSerialisation.Lecture:
switch ((ConstTypes)nType)
{
case ConstTypes.tBool:
bool b = false;
serializer.TraiteBool(ref b);
m_valeur = b;
break;
case ConstTypes.tDateTime:
DateTime dt = DateTime.Now;
serializer.TraiteDate(ref dt);
m_valeur = dt;
break;
case ConstTypes.tDouble:
double f = 0;
serializer.TraiteDouble(ref f);
m_valeur = f;
break;
case ConstTypes.tInt:
int nVal = 0;
serializer.TraiteInt(ref nVal);
m_valeur = nVal;
break;
case ConstTypes.tNull:
m_valeur = null;
break;
case ConstTypes.tString:
string strVal = "";
serializer.TraiteString(ref strVal);
m_valeur = strVal;
break;
}
break;
}
if (nVersion >= 1)
{
string strAvant = CaracteresControleAvant;
serializer.TraiteString(ref strAvant);
CaracteresControleAvant = strAvant;
}
return(result);
}