public CElementDeArbreOperationnelEntite(
CElementDeArbreOperationnel elementParent,
CComposantDeGrapheReseau composant)
: base(elementParent)
{
m_composant = composant;
}
public override void Simplifier()
{
m_elementDeArbre.Simplifier();
CElementDeArbreOperationnelOperateur op = m_elementDeArbre as CElementDeArbreOperationnelOperateur;
if (op != null && op.Fils.Count() == 1)
{
ElementDeArbre = op.Fils.ElementAt(0);
}
}
public bool CombineKeyEgal(CElementDeArbreOperationnelOperateur operateur, CElementDeArbreOperationnel autreElement)
{
if (autreElement.GetKeyFactorisation() != GetKeyFactorisation())
{
return(false);
}
operateur.AddFils(ElementDeArbre);
operateur.AddFils(((CElementDeArbreOperationnelSousSchema)autreElement).ElementDeArbre);
ElementDeArbre = operateur;
operateur.Simplifier();
return(true);
}
public CElementDeArbreOperationnelTrue(CElementDeArbreOperationnel elementParent)
: base(elementParent)
{
}
public CElementDeArbreOperationnelSousSchema(CElementDeArbreOperationnel elementParent)
: base(elementParent)
{
}
//-------------------------------------------------
/// <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);
}
public CElementDeArbreOperationnelOperateurEt(CElementDeArbreOperationnel elementParent)
: base(elementParent)
{
}
//------------------------------------------------------
public void RemoveFils(CElementDeArbreOperationnel element)
{
m_listeFils.Remove(element);
}
//------------------------------------------------------
public void AddFils(CElementDeArbreOperationnel element)
{
m_listeFils.Add(element);
element.SetElementParent(this);
}
public override void Simplifier()
{
//Simplifie les fils
foreach (CElementDeArbreOperationnel elt in Fils)
{
elt.Simplifier();
}
m_listeFils.Sort();
//Si c'est un OU et qu'il contient un 1, le ou ne sert à rien
//1+a+b+c = 1
if (GetType() == typeof(CElementDeArbreOperationnelOperateurOu))
{
if (m_listeFils.ToArray().FirstOrDefault(f => f is CElementDeArbreOperationnelTrue) != null)
{
m_listeFils.Clear();
return;
}
}
bool bChange = true;
while (bChange)
{
bChange = false;
/*Fait remonter les fils du même type sur ses propres paramètres
* suivant la règle a+(b+c) = a+b+c et a.(b.c) = a.b.c
* */
foreach (CElementDeArbreOperationnelOperateur element in from f in m_listeFils.ToArray()
where
f.GetType() == GetType()
select f as CElementDeArbreOperationnelOperateur)
{
foreach (CElementDeArbreOperationnel fils in element.Fils)
{
AddFils(fils);
}
RemoveFils(element);
bChange = true;
}
/*Supprime les doublons
* suivant la règle a+a = a et a.a = a ou les combine, s'il s'agit de trucs
* plus compliqués (comme des sous schémas)
* */
Dictionary <string, CElementDeArbreOperationnel> dicElements = new Dictionary <string, CElementDeArbreOperationnel>();
foreach (CElementDeArbreOperationnel element in m_listeFils.ToArray())
{
if (dicElements.Keys.Contains(element.GetKeyFactorisation()))
{
IElementDeArbreOperationnelAEgaliteComplexe elementComplexe = element as IElementDeArbreOperationnelAEgaliteComplexe;
if (elementComplexe != null)
{
IElementDeArbreOperationnelAEgaliteComplexe autreElement = dicElements[element.GetKeyFactorisation()] as IElementDeArbreOperationnelAEgaliteComplexe;
CElementDeArbreOperationnelOperateur op;
if (GetType() == typeof(CElementDeArbreOperationnelOperateurEt))
{
op = new CElementDeArbreOperationnelOperateurOu(null);
}
else
{
op = new CElementDeArbreOperationnelOperateurEt(null);
}
if (autreElement.CombineKeyEgal(op, element))
{
RemoveFils(element);
}
bChange = true;
}
else
{
CElementDeArbreOperationnel autreElement = dicElements[element.GetKeyFactorisation()];
if (autreElement.GetFullKey() == element.GetFullKey())
{
RemoveFils(element);
bChange = true;
}
}
}
else
{
dicElements[element.GetKeyFactorisation()] = element;
}
}
//Supprime les opérateurs avec un zéro ou seul paramètere
foreach (CElementDeArbreOperationnelOperateur element in from f in m_listeFils.ToArray()
where
typeof(CElementDeArbreOperationnelOperateur).IsAssignableFrom(f.GetType()) &&
((CElementDeArbreOperationnelOperateur)f).Fils.Count() <= 1
select f as CElementDeArbreOperationnelOperateur)
{
if (element.Fils.Count() == 1)
{
AddFils(element.Fils.ElementAt(0));
}
m_listeFils.Remove(element);
bChange = true;
}
if (GetType() == typeof(CElementDeArbreOperationnelOperateurEt))
{
foreach (CElementDeArbreOperationnelTrue opTrue in from f in Fils
where f is CElementDeArbreOperationnelTrue
select f as CElementDeArbreOperationnelTrue)
{
RemoveFils(opTrue);
bChange = true;
}
}
}
//if ( TypeOperateur == ETypeOperateur.OU )
Factoriser();
m_listeFils.Sort();
}
