Esempio n. 1
0
        //Demais métodos
        public Retorno excluirGrafo()
        {
            Retorno retorno = new Retorno(true);

            this.Vertices.Clear();
            this.Arestas.Clear();

            try
            {
                Monitor.Enter(VariaveisGlobais.locker);

                if (!Uteis.escreverGrafoArquivo(this))
                {
                    VariaveisGlobais.telaPrincipal.AtualizarLog("Não foi possível excluir o grafo!");
                    retorno.Sucesso  = false;
                    retorno.Mensagem = "Não foi possível excluir o grafo!";
                    return(retorno);
                }
            }catch (Exception ex)
            {
                VariaveisGlobais.telaPrincipal.AtualizarLog("Não foi possível excluir o grafo! " + ex.Message);
                retorno.Sucesso  = false;
                retorno.Mensagem = "Não foi possível excluir o grafo! " + ex.Message;
                return(retorno);
            }
            finally
            {
                Monitor.Exit(VariaveisGlobais.locker);
            }

            VariaveisGlobais.telaPrincipal.AtualizarLog("Grafo excluído com sucesso!");
            retorno.Mensagem = "Grafo excluido com sucesso!";

            return(retorno);
        }
Esempio n. 2
0
        //Método para Vértices
        public Retorno insertVertice(Vertice v)
        {
            Retorno retorno = new Retorno(true);

            try
            {
                Monitor.Enter(VariaveisGlobais.lockerVertice);

                this.atualizarGrafo();

                Vertice aux = null;

                if (this.Vertices.Count > 0)
                {
                    aux = this.Vertices.Where(p => p.Nome == v.Nome).FirstOrDefault();
                }

                if (aux != null)
                {
                    //Implica que já existe outro vertice com o mesmo nome
                    VariaveisGlobais.telaPrincipal.AtualizarLog("Não foi possível inserir o vértice " + v.Nome + ". O nome destinado ao vértice já foi utilizado!");
                    retorno.Sucesso  = false;
                    retorno.Mensagem = "O nome destinado ao vértice já foi utilizado!";
                    return(retorno);
                }

                this.Vertices.Add(v);

                if (!Uteis.escreverGrafoArquivo(this))
                {
                    VariaveisGlobais.telaPrincipal.AtualizarLog("Não foi possível gravar o vértice " + v.Nome + " no arquivo!");
                    retorno.Sucesso  = false;
                    retorno.Mensagem = "Não foi possível gravar o vértice no arquivo!";
                    return(retorno);
                }
            }
            catch (Exception ex)
            {
                VariaveisGlobais.telaPrincipal.AtualizarLog(ex.Message);
                retorno.Sucesso  = false;
                retorno.Mensagem = "Não foi possível inserir o vértice! " + ex.Message;
                return(retorno);
            }
            finally
            {
                Monitor.Exit(VariaveisGlobais.lockerVertice);
            }

            VariaveisGlobais.telaPrincipal.AtualizarLog("Vértice " + v.Nome + " cadastrado com sucesso!");
            retorno.Mensagem = "Vértice cadastrado com sucesso!";

            return(retorno);
        }
Esempio n. 3
0
        public Retorno updateVertice(Vertice v)
        {
            Retorno retorno = new Retorno(true);

            try
            {
                Monitor.Enter(VariaveisGlobais.lockerVertice);

                atualizarGrafo();

                Vertice aux = null;
                aux = this.Vertices.Where(p => p.Nome == v.Nome).FirstOrDefault();

                if (aux != null && this.Vertices.Remove(aux))
                {
                    this.Vertices.Add(v);
                }
                else
                {
                    Console.WriteLine("Erro ao atualizar o vértice!");
                    VariaveisGlobais.telaPrincipal.AtualizarLog("Erro ao atualizar o vértice " + v.Nome + "!");
                    retorno.Sucesso  = false;
                    retorno.Mensagem = "Erro ao atualizar o vértice!";
                    return(retorno);
                }

                if (!Uteis.escreverGrafoArquivo(this))
                {
                    VariaveisGlobais.telaPrincipal.AtualizarLog("Não foi possível atualizar o vértice " + v.Nome + " no arquivo!");
                    retorno.Sucesso  = false;
                    retorno.Mensagem = "Não foi possível atualizar o vértice no arquivo!";
                    return(retorno);
                }
            }
            catch (Exception ex)
            {
                VariaveisGlobais.telaPrincipal.AtualizarLog(ex.Message);
                retorno.Sucesso  = false;
                retorno.Mensagem = "Não foi possível atualizar o vértice! " + ex.Message;
                return(retorno);
            }
            finally
            {
                Monitor.Exit(VariaveisGlobais.lockerVertice);
            }

            VariaveisGlobais.telaPrincipal.AtualizarLog("Vértice " + v.Nome + " atualizado com sucesso!");
            retorno.Mensagem = "Vértice atualizado com sucesso!";

            return(retorno);
        }
Esempio n. 4
0
        public Retorno updateAresta(Aresta a)
        {
            Retorno retorno = new Retorno(true);

            try
            {
                Monitor.Enter(VariaveisGlobais.lockerAresta);

                atualizarGrafo();

                Aresta aux = null;
                aux = this.Arestas.Where(p => p.Descricao == a.Descricao).FirstOrDefault();

                if (aux != null && this.Arestas.Remove(aux))
                {
                    this.Arestas.Add(a);
                }
                else
                {
                    VariaveisGlobais.telaPrincipal.AtualizarLog("Erro ao atualizar a aresta " + a.Descricao + "!");
                    retorno.Sucesso  = false;
                    retorno.Mensagem = "Erro ao atualizar a aresta!";
                    return(retorno);
                }

                if (!Uteis.escreverGrafoArquivo(this))
                {
                    VariaveisGlobais.telaPrincipal.AtualizarLog("Não foi possível atualizar a aresta " + a.Descricao + " no arquivo!");
                    retorno.Sucesso  = false;
                    retorno.Mensagem = "Não foi possível atualizar a aresta no arquivo!";
                    return(retorno);
                }
            }catch (Exception ex)
            {
                VariaveisGlobais.telaPrincipal.AtualizarLog(ex.Message);
                retorno.Sucesso  = false;
                retorno.Mensagem = "Não foi possível atualizar a aresta! " + ex.Message;
                return(retorno);
            }
            finally
            {
                Monitor.Exit(VariaveisGlobais.lockerAresta);
            }

            VariaveisGlobais.telaPrincipal.AtualizarLog("Aresta " + a.Descricao + " atualizado com sucesso!");
            retorno.Mensagem = "Aresta atualizado com sucesso!";

            return(retorno);
        }
Esempio n. 5
0
        //Métodos para Arestas
        public Retorno insertAresta(Aresta a)
        {
            Retorno retorno = new Retorno(true);

            try
            {
                Monitor.Enter(VariaveisGlobais.lockerAresta);

                atualizarGrafo();

                Vertice v1 = null;
                Vertice v2 = null;

                v1 = this.Vertices.Where(p => p.Nome == a.VerticeInicio).FirstOrDefault();
                v2 = this.Vertices.Where(p => p.Nome == a.VerticeFim).FirstOrDefault();

                //Devemos verificar se o vértice de destino existe em algum outro servidor
                if (v2 == null)
                {
                    int servidor = Uteis.GetServidor(a.VerticeFim.ToString());

                    Retorno r = Uteis.enviarRequisicaoParaServidor(servidor + 1);

                    if (r.Sucesso)
                    {
                        GrafoAtributo grafo = JsonConvert.DeserializeObject <GrafoAtributo>(r.Retorno_);

                        v2 = grafo.Vertices.Where(p => p.Nome == a.VerticeFim).FirstOrDefault();
                    }
                }

                if (v1 == null || v2 == null)
                {
                    //Implica que algum vértice informado não existe
                    VariaveisGlobais.telaPrincipal.AtualizarLog("Não foi possível cadastrar a aresta " + a.Descricao + ".Algum dos vértices informados não existe!");
                    retorno.Sucesso  = false;
                    retorno.Mensagem = "Algum dos vértices informados não existe!";
                    return(retorno);
                }

                this.Arestas.Add(a);

                if (!Uteis.escreverGrafoArquivo(this))
                {
                    VariaveisGlobais.telaPrincipal.AtualizarLog("Não foi possível gravar a aresta " + a.Descricao + " no arquivo!");
                    retorno.Sucesso  = false;
                    retorno.Mensagem = "Não foi possível gravar a aresta no arquivo!";
                    return(retorno);
                }
            }
            catch (Exception ex)
            {
                VariaveisGlobais.telaPrincipal.AtualizarLog(ex.Message);
                retorno.Sucesso  = false;
                retorno.Mensagem = "Não foi possível gravar a aresta! " + ex.Message;
                return(retorno);
            }
            finally
            {
                Monitor.Exit(VariaveisGlobais.lockerAresta);
            }

            VariaveisGlobais.telaPrincipal.AtualizarLog("Aresta " + a.Descricao + " cadastrado com sucesso!");
            retorno.Mensagem = "Aresta cadastrado com sucesso!";

            return(retorno);
        }
Esempio n. 6
0
        public Retorno deleteVertice(Vertice v)
        {
            Retorno retorno = new Retorno(true);

            try
            {
                Monitor.Enter(VariaveisGlobais.lockerVertice);

                atualizarGrafo();

                Vertice aux = null;
                aux = this.Vertices.Where(p => p.Nome == v.Nome).FirstOrDefault();

                //Remover todas as arestas que possuem ligação com o vértice em questão
                List <Aresta> paraRemover = new List <Aresta>();
                foreach (Aresta item in this.Arestas)
                {
                    if (item.VerticeInicio == aux.Nome || item.VerticeFim == aux.Nome)
                    {
                        paraRemover.Add(item);
                    }
                }

                //Remover arestas bidirecionais que estão em outros servidores
                foreach (Aresta item in paraRemover)
                {
                    if (item.FlagBidirecional)
                    {
                        if (item.VerticeInicio == aux.Nome)
                        {
                            int servidor = Uteis.GetServidor(item.VerticeFim.ToString());

                            Uteis.enviarRequisicaoParaServidor_DeleteAresta(servidor, item);
                        }
                        else
                        {
                            int servidor = Uteis.GetServidor(item.VerticeInicio.ToString());

                            Uteis.enviarRequisicaoParaServidor_DeleteAresta(servidor, item);
                        }
                    }
                }

                this.Arestas = this.Arestas.Except(paraRemover).ToList();

                if (aux == null || !this.Vertices.Remove(aux))
                {
                    VariaveisGlobais.telaPrincipal.AtualizarLog("Não foi possível excluir o vértice " + v.Nome + " !");
                    retorno.Sucesso  = false;
                    retorno.Mensagem = "Não foi possível excluir o vértice!";
                    return(retorno);
                }

                if (!Uteis.escreverGrafoArquivo(this))
                {
                    VariaveisGlobais.telaPrincipal.AtualizarLog("Não foi possível remover o vértice " + v.Nome + " no arquivo!");
                    retorno.Sucesso  = false;
                    retorno.Mensagem = "Não foi possível remover o vértice no arquivo!";
                    return(retorno);
                }
            }catch (Exception ex)
            {
                VariaveisGlobais.telaPrincipal.AtualizarLog(ex.Message);
                retorno.Sucesso  = false;
                retorno.Mensagem = "Não foi possível remover o vértice! " + ex.Message;
                return(retorno);
            }
            finally
            {
                Monitor.Exit(VariaveisGlobais.lockerVertice);
            }

            VariaveisGlobais.telaPrincipal.AtualizarLog("Vértice " + v.Nome + " excluído com sucesso!");
            retorno.Mensagem = "Vértice excluído com sucesso!";

            return(retorno);
        }