コード例 #1
0
        //-----------------------------------------------------------
        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);
        }
コード例 #2
0
 public CPointAPointDeGraphe(
     CNoeudDeGrapheReseau noeudDepart,
     CNoeudDeGrapheReseau noeudArrive)
 {
     m_noeudArrivee = noeudArrive;
     m_noeudDepart  = noeudDepart;
     m_nHashCode    = (NoeudArrive.IdObjet.ToString() + "_" + NoeudDepart.IdObjet.ToString()).GetHashCode();
 }
コード例 #3
0
        //-----------------------------------------------------------
        public string GetKeyNoeud(CNoeudDeGrapheReseau noeud)
        {
            if (noeud == null)
            {
                return("");
            }
            string strKey = noeud.GetType().ToString();

            strKey += "/" + noeud.IdSchemaReseau.ToString();
            strKey += "/" + noeud.IdObjet.ToString();
            return(strKey);
        }
コード例 #4
0
        //-----------------------------------------------------------
        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);
        }
コード例 #5
0
ファイル: CSpvSchemaReseau.cs プロジェクト: ykebaili/Timos
        //-----------------------------------------------------------------
        /// <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);
        }
コード例 #6
0
ファイル: CArbreOperationnel.cs プロジェクト: ykebaili/Timos
        //-------------------------------------------------
        /// <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);
        }