//-----------------------------------------------------------
public override string GetStringDebugDescription()
{
string strTxt = "Sous schéma " + SmtSchema.Id + "/";
CNoeudDeGrapheReseau noeud = NoeudDepart;
if (noeud == null)
{
strTxt += "?";
}
else
{
strTxt += noeud.GetType().ToString() + "_" + noeud.IdObjet;
}
noeud = NoeudArrive;
strTxt += "->";
if (noeud == null)
{
strTxt += "?";
}
else
{
strTxt += noeud.GetType().ToString() + "_" + noeud.IdObjet;
}
return(strTxt);
}
public CPointAPointDeGraphe(
CNoeudDeGrapheReseau noeudDepart,
CNoeudDeGrapheReseau noeudArrive)
{
m_noeudArrivee = noeudArrive;
m_noeudDepart = noeudDepart;
m_nHashCode = (NoeudArrive.IdObjet.ToString() + "_" + NoeudDepart.IdObjet.ToString()).GetHashCode();
}
//-----------------------------------------------------------
public string GetKeyNoeud(CNoeudDeGrapheReseau noeud)
{
if (noeud == null)
{
return("");
}
string strKey = noeud.GetType().ToString();
strKey += "/" + noeud.IdSchemaReseau.ToString();
strKey += "/" + noeud.IdObjet.ToString();
return(strKey);
}
//-----------------------------------------------------------
private CNoeudDeGrapheReseau GetNoeudFromKey(string strKey)
{
string[] strDatas = strKey.Split('/');
if (strDatas.Length != 3)
{
return(null);
}
Type tp = CActivatorSurChaine.GetType(strDatas[0]);
if (tp == null)
{
return(null);
}
try{
int nIdSchema = Int32.Parse(strDatas[1]);
int nIdObjet = Int32.Parse(strDatas[2]);
CNoeudDeGrapheReseau noeud = Activator.CreateInstance(tp, new object[] { nIdObjet, nIdSchema, false }) as CNoeudDeGrapheReseau;
return(noeud);
}
catch (Exception e)
{
}
return(null);
}
//-----------------------------------------------------------------
/// <summary>
/// recalcule l'arbre opérationnel
/// </summary>
/// <param name="baseGraphes"></param>
/// <returns></returns>
public CResultAErreur RecalculeArbreOperationnelInContexte(CBaseGraphesReseau baseGraphes)
{
if (baseGraphes == null)
{
baseGraphes = new CBaseGraphesReseau();
}
CResultAErreur result = CResultAErreur.True;
CSchemaReseau schema = ObjetTimosAssocie;
//Supprime toutes les dépendances à des elements de graphe
result = CObjetDonneeAIdNumerique.Delete(ElementsDeGraphe, true);
if (!result)
{
return(result);
}
foreach (ESensAllerRetourLienReseau sens in Enum.GetValues(typeof(ESensAllerRetourLienReseau)))
{
ESensAllerRetourLienReseau?sensRetenu = null;
if (schema.LienReseau == null)
{
sensRetenu = sens;
}
//Calcule le graphe
CGrapheReseau graphe = baseGraphes.GetGrapheExistant(schema, sensRetenu);
if (graphe == null)
{
graphe = new CGrapheReseau(baseGraphes);
result = graphe.CalculeGraphe(schema, sensRetenu);
if (!result)
{
return(result);
}
}
CArbreOperationnel arbre = new CArbreOperationnel();
result = arbre.CalculArbreRedondanceAuto(schema, graphe);
if (!result)
{
return(result);
}
result = CSpvElementDeGraphe.CreateFromElementDeArbreOperationnel(this, arbre.ElementRacine, sensRetenu);
if (!result)
{
return(result);
}
if (schema.LienReseau != null)
{
break;
}
}
//Recalcule les éléments de graphe qui utilisent ce schéma
CListeObjetsDonnees lstEltsUtilisantLeSchema = new CListeObjetsDonnees(ContexteDonnee, typeof(CSpvElementDeGraphe));
lstEltsUtilisantLeSchema.Filtre = new CFiltreData(CSpvElementDeGraphe.c_champIdSchemaSmt + "=@1",
schema.Id);
foreach (CSpvElementDeGraphe elt in lstEltsUtilisantLeSchema.ToArrayList())
{
CSpvElementDeGrapheSousSchema eltSpvSousSchema = elt.GetElementDuBonType() as CSpvElementDeGrapheSousSchema;
if (eltSpvSousSchema != null)
{
CNoeudDeGrapheReseau noeudDepart = eltSpvSousSchema.NoeudDepart;
CNoeudDeGrapheReseau noeudArrive = eltSpvSousSchema.NoeudArrive;
CArbreOperationnel arbre = new CArbreOperationnel();
CGrapheReseau graphe = baseGraphes.GetGrapheExistant(schema, eltSpvSousSchema.SensGraphe);
if (graphe == null)
{
graphe = new CGrapheReseau(baseGraphes);
result = graphe.CalculeGraphe(schema, eltSpvSousSchema.SensGraphe);
if (!result)
{
return(result);
}
}
result = arbre.CalculArbreRedondanceAuto(schema, graphe, noeudDepart, noeudArrive);
if (!result)
{
return(result);
}
CElementDeArbreOperationnelSousSchema eltOp = new CElementDeArbreOperationnelSousSchema(null);
eltOp.ElementDeArbre = arbre.ElementRacine;
eltOp.IdSchema = schema.Id;
eltOp.NoeudArrive = noeudArrive;
eltOp.NoeudDepart = noeudDepart;
result = CObjetDonneeAIdNumerique.Delete(eltSpvSousSchema.ElementsFils, true);
if (!result)
{
return(result);
}
result = eltSpvSousSchema.FillFromElementDeGraphe(eltOp);
if (!result)
{
return(result);
}
}
}
return(result);
}
//-------------------------------------------------
/// <summary>
/// Calcule l'arbre entre deux noeuds pour un schéma
/// </summary>
/// <param name="schema"></param>
/// <param name="graphe"></param>
/// <param name="noeudDepart"></param>
/// <param name="noeudArrivee"></param>
/// <returns></returns>
public CResultAErreur CalculArbreRedondanceAuto(
CSchemaReseau schema,
CGrapheReseau graphe,
CNoeudDeGrapheReseau noeudDepart,
CNoeudDeGrapheReseau noeudArrivee)
{
CResultAErreur result = CResultAErreur.True;
CNoeudDeGrapheReseau[] noeudsEntree;
if (noeudDepart != null)
{
noeudsEntree = new CNoeudDeGrapheReseau[] { noeudDepart }
}
;
else if (schema.LienReseau == null) //Ce n'est pas un schéma de lien
{
noeudsEntree = graphe.GetNoeudsEntreeNiveau0();
}
else
{
noeudsEntree = new CNoeudDeGrapheReseau[] {
graphe.GetNoeudForElement(schema.LienReseau.Element1, schema)
};
}
CNoeudDeGrapheReseau[] noeudsSortie;
if (noeudArrivee != null)
{
noeudsSortie = new CNoeudDeGrapheReseau[] { noeudArrivee }
}
;
else if (schema.LienReseau == null) //Ce n'est pas un schéma de lien
{
noeudsSortie = graphe.GetNoeudsSortieNiveau0();
}
else
{
noeudsSortie = new CNoeudDeGrapheReseau[] {
graphe.GetNoeudForElement(schema.LienReseau.Element2, schema)
};
}
CElementDeArbreOperationnelOperateurEt eltSource = new CElementDeArbreOperationnelOperateurEt(null);
m_elementRacine = eltSource;
//Ajoute les éléments seuls
foreach (CNoeudDeGrapheReseau noeud in graphe.GetNoeudsIsoles())
{
if (schema.LienReseau == null || noeud.Equals(noeudsEntree[0]) || noeud.Equals(noeudsSortie[0]))
//si c'est un schéma de lien n'ajoute que les noeuds isolé correspondant à l'entrée ou à la sortie
{
CElementDeArbreOperationnelEntite composant = new CElementDeArbreOperationnelEntite(eltSource, noeud);
eltSource.AddFils(composant);
result = composant.GetElementCablage(graphe.SensDuGraphe, schema.ContexteDonnee);
if (!result)
{
return(result);
}
CElementDeArbreOperationnel elementCablage = result.Data as CElementDeArbreOperationnel;
if (elementCablage != null)
{
eltSource.AddFils(elementCablage);
}
}
}
foreach (CNoeudDeGrapheReseau noeudEntree in noeudsEntree)
{
foreach (CNoeudDeGrapheReseau noeudSortie in noeudsSortie)
{
List <CCheminDeGrapheReseau> chemins = graphe.GetChemins(noeudEntree, noeudSortie);
if (chemins.Count() > 0)
{
CElementDeArbreOperationnelOperateurOu ouPourExtremites = new CElementDeArbreOperationnelOperateurOu(eltSource);
eltSource.AddFils(ouPourExtremites);
foreach (CCheminDeGrapheReseau chemin in chemins) //parcours tous les chemins en mettant un ou dessus
{
Stack <CRacineDeSchema> lstRacines = new Stack <CRacineDeSchema>();
CRacineDeSchema racine = new CRacineDeSchema(schema.Id, null, new CElementDeArbreOperationnelOperateurEt(ouPourExtremites));
ouPourExtremites.AddFils(racine.ElementRacine);
lstRacines.Push(racine);
int nLien = 0;
foreach (CLienDeGrapheReseau lien in chemin.Liens)
{
CRacineDeSchema racineEnCours = lstRacines.Peek();
if (lien.EtapesNoeudDepart != null)
{
int[] idsSchemas = lien.EtapesNoeudDepart.IdsSchemas;
//Dépile les sous schémas
for (int nEtape = idsSchemas.Count() - 1; nEtape >= 0; nEtape--)
{
int nIdSchema = idsSchemas[nEtape];
if (racineEnCours.IdSchema != nIdSchema)
{
result.EmpileErreur(I.T("Bad path for link @1 in graph for @2 diagram|20050",
lien.IdLienReseau.ToString(), lien.IdSchemaReseau.ToString()));
return(result);
}
if (racineEnCours.ElementSousSchema != null)
{
racineEnCours.ElementSousSchema.NoeudArrive = lien.NoeudDepart;
}
lstRacines.Pop();
racineEnCours = lstRacines.Peek();
}
}
//Si les extremités du lien sont cablées, le lien est dans un et, sinon,
//il est directement sous la racine en cours
CElementDeArbreOperationnelOperateur elementParentDeLien = racineEnCours.ElementRacine;
//Si ce n'est pas le dernier lien, on ajoute que les cablages des noeuds de départ,
//Puisque le cablage du noeud d'arrivé sera le cablage du noeud de départ du prochain lien
//Par contre, si c'est le dernier lien du chemin, il faut ajouter ce cablage
if ((lien.NoeudDepart is CNoeudDeGrapheReseauSite && ((CNoeudDeGrapheReseauSite)lien.NoeudDepart).IsCable) ||
(nLien == chemin.Liens.Count() - 1 && (lien.NoeudArrive is CNoeudDeGrapheReseauSite && ((CNoeudDeGrapheReseauSite)lien.NoeudArrive).IsCable)))
{
elementParentDeLien = new CElementDeArbreOperationnelOperateurEt(racineEnCours.ElementRacine);
racineEnCours.ElementRacine.AddFils(elementParentDeLien);
}
elementParentDeLien.AddFils(new CElementDeArbreOperationnelEntite(elementParentDeLien, lien));
//Cablage du site entrée
CNoeudDeGrapheReseauSite noeudSite = lien.NoeudDepart as CNoeudDeGrapheReseauSite;
if (noeudSite != null && noeudSite.IsCable)
{
//Le noeud correspondant à l'élément est déjà dans le schéma du lien
CElementDeArbreOperationnelEntite elementNoeud = new CElementDeArbreOperationnelEntite(null, noeudSite);
result = elementNoeud.GetElementCablage(graphe.SensDuGraphe, schema.ContexteDonnee);
if (!result)
{
return(result);
}
CElementDeArbreOperationnel elementCablage = result.Data as CElementDeArbreOperationnel;
if (elementCablage != null)
{
elementParentDeLien.AddFils(elementCablage);
}
}
//Cablage du site sortie
noeudSite = lien.NoeudArrive as CNoeudDeGrapheReseauSite;
if (noeudSite != null && noeudSite.IsCable && nLien == chemin.Liens.Count() - 1)
{
CElementDeArbreOperationnelEntite elementNoeud = new CElementDeArbreOperationnelEntite(null, noeudSite);
result = elementNoeud.GetElementCablage(graphe.SensDuGraphe, schema.ContexteDonnee);
if (!result)
{
return(result);
}
CElementDeArbreOperationnel elementCablage = result.Data as CElementDeArbreOperationnel;
if (elementCablage != null)
{
elementParentDeLien.AddFils(elementCablage);
}
}
if (lien.EtapesNoeudArrivee != null)
{
int[] idsSchemas = lien.EtapesNoeudArrivee.IdsSchemas;
foreach (int nIdSchema in idsSchemas)
{
CElementDeArbreOperationnelSousSchema eltSousSchema = new CElementDeArbreOperationnelSousSchema(racineEnCours.ElementRacine);
eltSousSchema.NoeudDepart = lien.NoeudArrive;
eltSousSchema.ElementDeArbre = new CElementDeArbreOperationnelOperateurEt(racine.ElementRacine);
eltSousSchema.IdSchema = nIdSchema;
CRacineDeSchema newRacine = new CRacineDeSchema(
nIdSchema,
eltSousSchema,
eltSousSchema.ElementDeArbre as CElementDeArbreOperationnelOperateur);
lstRacines.Push(newRacine);
racineEnCours.ElementRacine.AddFils(eltSousSchema);
racineEnCours = newRacine;
}
}
nLien++;
}
}
}
}
}
eltSource.Simplifier();
return(result);
}