Example #1
0
        public Retorno listarVizinhoVertice(Vertice v)
        {
            Retorno retorno = new Retorno(true);

            try
            {
                Monitor.Enter(VariaveisGlobais.locker);
                atualizarGrafo();
            }
            catch (Exception ex)
            {
                VariaveisGlobais.telaPrincipal.AtualizarLog("Não foi possível ler o grafo! " + ex.Message);
            }
            finally
            {
                Monitor.Exit(VariaveisGlobais.locker);
            }

            List <Vertice> vizinhos = new List <Vertice>();

            List <Aresta> arestas = null;

            //Todas as arestas do vertice
            arestas = this.Arestas.Where(p => p.VerticeInicio == v.Nome).ToList();

            if (arestas != null)
            {
                foreach (Aresta item in arestas)
                {
                    Vertice v1 = this.Vertices.Where(p => p.Nome == item.VerticeFim).FirstOrDefault();

                    if (v1 != null)
                    {
                        vizinhos.Add(v1);
                    }
                    else
                    {
                        int     servidor = Uteis.GetServidor(item.VerticeFim.ToString());
                        Retorno r        = Uteis.enviarRequisicaoParaServidor(servidor + 1);

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

                        v1 = grafo.Vertices.Where(p => p.Nome == item.VerticeFim).FirstOrDefault();

                        vizinhos.Add(v1);
                    }
                }
            }

            //Serializado em uma lista de vertices
            retorno.Retorno_ = JsonConvert.SerializeObject(vizinhos);

            return(retorno);
        }
Example #2
0
        public Retorno listarVerticesAresta(Aresta a)
        {
            Retorno retorno = new Retorno(true);

            try
            {
                Monitor.Enter(VariaveisGlobais.locker);
                atualizarGrafo();
            }
            catch (Exception ex)
            {
                VariaveisGlobais.telaPrincipal.AtualizarLog("Não foi possível ler o grafo! " + ex.Message);
            }
            finally
            {
                Monitor.Exit(VariaveisGlobais.locker);
            }

            List <Vertice> vertices = new List <Vertice>();

            Vertice vOrigem  = null;
            Vertice vDestino = null;

            Aresta arestaCorrente = Arestas.Where(p => p.Descricao == a.Descricao).FirstOrDefault();

            if (arestaCorrente == null)
            {
                retorno.Sucesso  = false;
                retorno.Mensagem = "A aresta informada não existe!";

                return(retorno);
            }

            vOrigem = Vertices.Where(p => p.Nome == arestaCorrente.VerticeInicio).FirstOrDefault();

            if (vOrigem != null)
            {
                int servidor = Uteis.GetServidor(arestaCorrente.VerticeFim.ToString());

                if ((servidor + 1) == VariaveisGlobais.servidorLocal.Identificador)
                {
                    vDestino = Vertices.Where(p => p.Nome == arestaCorrente.VerticeFim).FirstOrDefault();
                }
                else
                {
                    Retorno r = Uteis.enviarRequisicaoParaServidor(servidor + 1);

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

                        vDestino = grafo.Vertices.Where(p => p.Nome == arestaCorrente.VerticeFim).FirstOrDefault();
                    }
                }

                vertices.Add(vOrigem);
                vertices.Add(vDestino);

                //Serializado como uma lista de vertices
                retorno.Sucesso  = true;
                retorno.Retorno_ = JsonConvert.SerializeObject(vertices);
            }
            else
            {
                retorno.Sucesso = false;
            }

            return(retorno);
        }
Example #3
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);
        }