Example #1
0
        public static Transicao EditaTransicao(Transicao t, Automato aut)
        {
            AlteraTransicao at = new AlteraTransicao();

            at.MontaCombos(aut);
            if (t != null)
            {
                at.cmbEstOr.SelectedItem = t.EstadoOrigem;
                // at.cmbEstDest.SelectedItem = t.EstadoDestino;
                at.cmbSimbolo.SelectedItem = t.Simbolo;
            }

            at.ShowDialog();
            if (at.Ok)
            {
                if (t == null)
                {
                    t = new Transicao();
                }

                t.EstadoOrigem = (Estado)at.cmbEstOr.SelectedItem;
                // t.EstadoDestino = (Estado)at.cmbEstDest.SelectedItem;
                t.Simbolo = (Simbolo)at.cmbSimbolo.SelectedItem;
                return(t);
            }
            else
            {
                return(null);
            }
        }
Example #2
0
        public static Transicao EditaTransicao(Transicao t, Automato aut)
        {
            AlteraTransicao at = new AlteraTransicao();
            at.MontaCombos(aut);
            if (t != null)
            {
                at.cmbEstOr.SelectedItem = t.EstadoOrigem;
               // at.cmbEstDest.SelectedItem = t.EstadoDestino;
                at.cmbSimbolo.SelectedItem = t.Simbolo;
            }

            at.ShowDialog();
            if (at.Ok)
            {
                if (t == null)
                {
                    t = new Transicao();
                }

                t.EstadoOrigem = (Estado)at.cmbEstOr.SelectedItem;
               // t.EstadoDestino = (Estado)at.cmbEstDest.SelectedItem;
                t.Simbolo = (Simbolo)at.cmbSimbolo.SelectedItem;
                return t;
            }
            else {
                return null;
            }
        }
Example #3
0
 public void setTransicao(Transicao t)
 {
     if (Transicoes.ContainsKey(t.Simbolo.simbolo))
     {
         Transicoes[t.Simbolo.simbolo] = t;
     }
     else
     {
         Transicoes.Add(t.Simbolo.simbolo, t);
     }
 }
Example #4
0
 public void SyncTransicao(Transicao t)
 {
     if (Transicoes.ContainsKey(t.Simbolo.simbolo))
     {
         Transicao tt = Transicoes[t.Simbolo.simbolo]; //Transições existentes
         foreach (Estado e in t.EstadosDestino)
         {                                             //Transições novas
             if (!tt.EstadosDestino.Contains(e))
             {                                         //Se não existe, adiciona
                 tt.EstadosDestino.Add(e);
             }
         }
     }
     else
     {
         Transicoes.Add(t.Simbolo.simbolo, t);
     }
 }
Example #5
0
        public override bool Equals(object obj)
        {
            // bool ret = false;

            if (obj == null)
            {
                return(false);
            }

            Transicao c = (Transicao)obj;

            //TODO: Correct this
            if (!c.EstadosDestino.Equals(this.EstadosDestino))
            {
                return(false);
            }

            if (!c.EstadoOrigem.Equals(this.EstadoOrigem))
            {
                return(false);
            }

            /*
             * bool found = false;
             *
             * foreach (Simbolo s in this.Simbolos) {
             *  found = false;
             *  foreach (Simbolo ss in c.Simbolos)
             *  {
             *      if (s.Equals(ss)) {
             *          found = true;
             *      }
             *  }
             *  if (!found) {
             *      return false;
             *  }
             * }
             */
            if (Simbolo.Equals(c.Simbolo))
            {
                return(true);
            }
            return(false);
        }
Example #6
0
        private void EditaTransicao()
        {
            //  try
            {
                Estado    e = getSelectedEstado();
                Transicao tr_ed;

                if (e.Transicoes.ContainsKey(dataGridView1.Columns[lastColumnIdx].Name))
                {
                    tr_ed = e.Transicoes[dataGridView1.Columns[lastColumnIdx].Name];
                }
                else
                {
                    tr_ed         = new Transicao(e);
                    tr_ed.Simbolo = AutomatoInstanciado.Alfabeto[dataGridView1.Columns[lastColumnIdx].Name];
                }

                BuscaEstado b = new BuscaEstado();
                b.MontaCombo(AutomatoInstanciado);

                b.ShowDialog();
                if (b.Ok)
                {
                    tr_ed.AddEstadoDest(b.getSelected());
                    e.SyncTransicao(tr_ed);
                }
                else if (b.Excluir)
                {
                    if (tr_ed.EstadosDestino.Contains(b.getSelected()))
                    {
                        tr_ed.EstadosDestino.Remove(b.getSelected());
                    }
                    if (tr_ed.EstadosDestino.Count == 0)
                    {
                        e.Transicoes.Remove(tr_ed.Simbolo.simbolo);
                    }
                }
                AtualizaLastCell();
            }
            //  catch (Exception e)
            {
                //  MessageBox.Show(e.Message);
            }
        }
Example #7
0
        public void EliminarE(Dictionary <string, Simbolo> Alfabeto)
        {
            //Testa-se o estado atual com cada simbolo do alfabeto
            foreach (Simbolo s in Alfabeto.Values)
            {
                //Encontra todos alcançáveis com movimentos vazios
                foreach (Estado e in getEstadosVazios())
                {
                    if (!s.isVazio)
                    {
                        //Encontra todos estados alcançáveis com esse símbolo
                        foreach (Estado ee in e.getEstadosDestinosRebuilded(s))
                        {
                            //Para cado estado alcaçado verifica-se os vazios e
                            // adiciona na lista como destino do estado this.
                            foreach (Estado eee in ee.getEstadosVazios())
                            {
                                //Adiciona novas transições ou novos estados destino
                                if (!this.Transicoes.ContainsKey(s.simbolo))
                                {
                                    Transicao t = new Transicao(this);
                                    t.Simbolo = s;
                                    t.AddEstadoDest(eee);
                                    this.Transicoes.Add(s.simbolo, t);
                                }
                                else
                                {
                                    this.Transicoes[s.simbolo].AddEstadoDest(eee);
                                }
                            }
                        }
                    }

                    //Se era possível chegar a algun estado final passando por E,
                    // então esse estado deve ser final também.
                    if (e.isFinal)
                    {
                        this.isFinal = true;
                    }
                }
            }
        }
Example #8
0
        public Automato ConvertSaveDataAutomato(SaveDataAutomato sa)
        {
            Automato aut = new Automato();

            foreach (string s in sa.Alfabeto)
            {
                Simbolo si = new Simbolo(s);
                aut.Alfabeto.Add(s, si);
            }

            foreach (string estado in sa.Estados)
            {
                Estado e = new Estado(estado);
                e.isFinal   = sa.EstadosFinais.Contains(estado);
                e.isInicial = sa.EstadoInicial == estado;
                aut.Estados.Add(estado, e);
            }

            foreach (Estado e in aut.Estados.Values)
            {
                foreach (SaveDataTransicao t in sa.Transicoes)
                {
                    if (t.EstadoOrigem == e.Nome)
                    {
                        Transicao tr = new Transicao(e);
                        tr.Simbolo = aut.Alfabeto[t.Simbolo];
                        foreach (string d in t.EstadosDestino)
                        {
                            tr.EstadosDestino.Add(aut.Estados[d]);
                        }
                        e.Transicoes.Add(tr.Simbolo.simbolo, tr);
                    }
                }
            }

            if (sa.EstadoInicial != null && sa.EstadoInicial != "")
            {
                aut.EstadoInicial = aut.Estados[sa.EstadoInicial];
            }
            return(aut);
        }
Example #9
0
        private void AtualizaLastCell()
        {
            string s = "";
            Estado e = getSelectedEstado();

            if (e.Transicoes.ContainsKey(dataGridView1.Columns[lastColumnIdx].Name))
            {
                Transicao t = e.Transicoes[dataGridView1.Columns[lastColumnIdx].Name];
                foreach (Estado ee in t.EstadosDestino)
                {
                    s += ee.Nome + ", ";
                }
            }
            if (s != "")
            {
                s = s.Substring(0, s.Length - 2);
            }

            dataGridView1.Rows[lastRowIdx].Cells[lastColumnIdx].Value = s;
            AtualizaDetalhes();
        }
Example #10
0
        public void CriaNovoEstado(Transicao progenitor)
        {
            string nome_novo_estado = "";
            Dictionary <string, Transicao> transicoes = new Dictionary <string, Transicao>();
            bool EhFinal = false;

            foreach (Estado e in progenitor.EstadosDestino)
            {
                nome_novo_estado += nome_novo_estado + e.Nome + "_";
                if (e.isFinal)
                {
                    EhFinal = true;
                }
                foreach (Transicao t in e.Transicoes.Values)
                {
                    if (!transicoes.ContainsKey(t.Simbolo.simbolo))
                    {
                        transicoes.Add(t.Simbolo.simbolo, t);
                    }
                }
            }

            if (nome_novo_estado != "")
            {
                nome_novo_estado = nome_novo_estado.Substring(0, nome_novo_estado.Length - 1);
                //  transicoes.
            }
            //Verificar se esse estado já não foi criado, caso tenha sido,
            // as transições deve apontar para lah.


            Estado novoEstado = new Estado(nome_novo_estado);

            novoEstado.Transicoes = transicoes;
            novoEstado.isFinal    = EhFinal;
            novoEstado.isInicial  = false;

            progenitor.EstadosDestino.Clear();
            progenitor.EstadosDestino.Add(novoEstado);
        }
Example #11
0
        public void AtualizaAutomato()
        {
            dataGridView1.Rows.Clear();
            dataGridView1.Columns.Clear();

            foreach (Simbolo s in AutomatoInstanciado.Alfabeto.Values)
            {
                dataGridView1.Columns.Add(s.ToString(), s.ToString());
            }

            foreach (Estado e in AutomatoInstanciado.Estados.Values)
            {
                int pos = dataGridView1.Rows.Add();
                dataGridView1.Rows[pos].HeaderCell.Value = e.Nome;
                dataGridView1.Rows[pos].Tag = e.Nome;

                for (int cidx = 0; cidx < dataGridView1.Columns.Count; cidx++)
                {
                    String s = "";
                    if (e.Transicoes.ContainsKey(dataGridView1.Columns[cidx].Name))
                    {
                        Transicao t = e.Transicoes[dataGridView1.Columns[cidx].Name];
                        foreach (Estado ee in t.EstadosDestino)
                        {
                            s += ee.Nome + ", ";
                        }
                    }
                    if (s != "")
                    {
                        s = s.Substring(0, s.Length - 2);
                    }

                    dataGridView1.Rows[pos].Cells[cidx].Value = s;
                }
            }

            RefreshRows();
            AtualizaDetalhes();
            RefreshAlfabeto();
        }
Example #12
0
        public Estado ProxEst(Estado e, Simbolo s, Automato aut)
        {
            //Procura todos destinos para a consulta atual
            List <Estado> dest = aut.getEstadosDestinos(e.EstadosUnificados, s);


            bool EhFinal = false;

            foreach (Estado eee in dest)
            {
                if (eee.isFinal)
                {
                    EhFinal = true;
                    break;
                }
            }


            if (dest.Count == 0)
            {
                return(null);
            }

            //Gera o nome do novo estado
            string nomestados = getStringEstado(dest);

            Estado estadonovo;

            //Verifica se o novo estado já foi criado

            //Se ainda não foi, o novo estado é criado
            if (EstadosNovos.ContainsKey(nomestados))
            {
                estadonovo = EstadosNovos[nomestados];
            }
            else
            {
                estadonovo = new Estado(nomestados);
            }

            estadonovo.isFinal |= EhFinal;

            //Os estados unificados do pai são guardados no novo estado gerado.
            estadonovo.EstadosGerador_Pais = e.EstadosUnificados;

            //Os estados que foram referenciados para montar este são guardados.
            estadonovo.EstadosUnificados = getEstadosOrigem(dest);

            //As as transições do estado criador são apagadas.
            //    e.Transicoes.Clear();


            //Um única nova transição é criada
            Transicao nova = new Transicao(e);

            nova.EstadosDestino.Add(estadonovo);//O estado novo será destruido mais adiantes, corrigir as referências
            nova.Simbolo = s;

            //A transição é adicionada para o simbolo que está sendo pesquisado.
            e.Transicoes.Add(s.simbolo, nova);

            return(estadonovo);
        }
Example #13
0
        private void EditaTransicao()
        {
            //  try
            {
                Estado e = getSelectedEstado();
                Transicao tr_ed;

                if (e.Transicoes.ContainsKey(dataGridView1.Columns[lastColumnIdx].Name))
                {
                    tr_ed = e.Transicoes[dataGridView1.Columns[lastColumnIdx].Name];
                }
                else
                {
                    tr_ed = new Transicao(e);
                    tr_ed.Simbolo = AutomatoInstanciado.Alfabeto[dataGridView1.Columns[lastColumnIdx].Name];
                }

                BuscaEstado b = new BuscaEstado();
                b.MontaCombo(AutomatoInstanciado);

                b.ShowDialog();
                if (b.Ok)
                {

                    tr_ed.AddEstadoDest(b.getSelected());
                    e.SyncTransicao(tr_ed);
                }
                else if (b.Excluir)
                {
                    if (tr_ed.EstadosDestino.Contains(b.getSelected()))
                    {
                        tr_ed.EstadosDestino.Remove(b.getSelected());
                    }
                    if (tr_ed.EstadosDestino.Count == 0)
                    {
                        e.Transicoes.Remove(tr_ed.Simbolo.simbolo);
                    }
                }
                AtualizaLastCell();
            }
            //  catch (Exception e)
            {

                //  MessageBox.Show(e.Message);
            }
        }