Пример #1
0
        //Retorna positivo caso seja uma folha (sem filhos) para avisar para apagar os nós sem next hop acima
        public bool DeleteLeaf(Leaf curleaf, string prefix)
        {
            bool delete = false;

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

            //Verificar para onde seguir só caso ainda não ter atingindo o destino
            if (prefix.Length > 0)
            {
                char next = prefix[0];

                prefix = prefix.Substring(1);

                if (next == '0')
                {
                    delete = DeleteLeaf(curleaf.GetLeft(), prefix);

                    if (delete)
                    {
                        curleaf.SetLeft(null);
                    }
                }
                else if (next == '1')
                {
                    delete = DeleteLeaf(curleaf.GetRight(), prefix);

                    if (delete)
                    {
                        curleaf.SetRight(null);
                    }
                }

                //Cancelar delete progressivo caso se tenha atingido um nó a meio com next hop
                if (curleaf.GetNextHop() != -1 || curleaf.GetLeft() != null || curleaf.GetRight() != null)
                {
                    delete = false;
                }
            }
            else
            {
                //Só pedir para apagar nós sem next hop anteriores caso esta seja uma folha
                if (curleaf.GetLeft() == null && curleaf.GetRight() == null)
                {
                    delete = true;
                }
                else
                {
                    curleaf.SetNextHop(-1);
                }
            }

            return(delete);
        }
Пример #2
0
        public void InsertLeaf(string prefix, int nextHop)
        {
            // Caso o prefixo seja o default, insere na raiz
            if (prefix[0] == 'e')
            {
                root.SetNextHop(nextHop);
            }
            else
            {
                // Verifica que a raiz foi criada. Pode não ter acontecido se se estiver a inserir numa árvore vazia
                // Ou seja, que foi totalmente apagada
                if (root == null)
                {
                    root = new Leaf();
                }

                // Inicializa a variável auxiliar que vai percorrer a árvore à raiz
                Leaf aux = root;

                // Percorre a árvore para inserir o prefixo
                for (int i = 0; i < prefix.Length; i++)
                {
                    if (prefix[i] == '1')
                    {
                        if (aux.GetRight() == null)
                        {
                            aux.SetRight(new Leaf());
                        }

                        aux = aux.GetRight();
                    }
                    else if (prefix[i] == '0')
                    {
                        if (aux.GetLeft() == null)
                        {
                            aux.SetLeft(new Leaf());
                        }

                        aux = aux.GetLeft();
                    }
                    else
                    {
                        Console.WriteLine("There's an error in the prefix you tried to insert. Please fix it by only using the binary numeral system.");
                        return;
                    }
                }

                aux.SetNextHop(nextHop);
            }
        }
Пример #3
0
        public bool DeleteDefault(Leaf curLeaf, int newDefault)
        {
            bool delete;

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

            // Inicializar a variável que vai percorrer a árvore à raiz
            if (curLeaf.GetNextHop() == newDefault)
            {
                return(true);
            }

            if (curLeaf.GetLeft() != null)
            {
                delete = DeleteDefault(curLeaf.GetLeft(), newDefault);
                // O garbage collector vai apagar os nós seguintes ao pôr a raíz de cada sub-árvore a null
                if (delete)
                {
                    curLeaf.SetLeft(null);
                }
            }

            if (curLeaf.GetRight() != null)
            {
                delete = DeleteDefault(curLeaf.GetRight(), newDefault);
                if (delete)
                {
                    curLeaf.SetRight(null);
                }
            }

            return(false);
        }
Пример #4
0
        public List <int> ORTCIter(Leaf curLeaf, int nextHop)
        {
            List <int> leftVal, rightVal;

            //Atualizar valor do next hop a propagar
            if (curLeaf.GetNextHop() != -1)
            {
                nextHop = curLeaf.GetNextHop();
            }

            //Verificar se nos encontramos num nó só com um filho e adicionar um caso seja esse o caso
            if (curLeaf.GetLeft() == null && curLeaf.GetRight() != null)
            {
                if (nextHop != -1)
                {
                    curLeaf.SetLeft(new Leaf(nextHop));
                }
            }
            else if (curLeaf.GetLeft() != null && curLeaf.GetRight() == null)
            {
                if (nextHop != -1)
                {
                    curLeaf.SetRight(new Leaf(nextHop));
                }
            }

            if (curLeaf.GetLeft() != null && curLeaf.GetRight() != null)
            {
                List <int> intersect = new List <int>();

                leftVal  = ORTCIter(curLeaf.GetLeft(), nextHop);
                rightVal = ORTCIter(curLeaf.GetRight(), nextHop);

                // Caso não seja uma folha, é necessário eliminar o Next Hop do nó atual
                curLeaf.SetNextHop(-1);

                //Verificar se toda a lista contenha o mesmo nexthop, caso sim pode-se truncar por aqui
                //facilmente verificavel caso ambos só transmitão um valor e este seja igual
                if (leftVal[0] == rightVal[0] && leftVal.Count == 1 && rightVal.Count == 1 && leftVal[0] != -1)
                {
                    curLeaf.SetNextHop(leftVal[0]);
                    curLeaf.SetLeft(null);
                    curLeaf.SetRight(null);
                }

                //caso haja interseçao, manter a interseçao, caso nao manter a união
                intersect = leftVal.Intersect <int>(rightVal).ToList <int>();

                //Mudar valor do prefixo e caso esse seja o caso para um dos valores da interseçao

                /*if (curLeaf == root && intersect.Count != 0)
                 *  curLeaf.SetNextHop(intersect[0]);*/

                if (intersect.Count != 0)
                {
                    if (intersect[0] != -1)
                    {
                        curLeaf.SetNextHop(intersect[0]);
                        bool delete = DeleteDefault(curLeaf.GetLeft(), intersect[0]);
                        if (delete)
                        {
                            curLeaf.SetLeft(null);
                        }
                        delete = DeleteDefault(curLeaf.GetRight(), intersect[0]);
                        if (delete)
                        {
                            curLeaf.SetRight(null);
                        }
                    }
                }
                else
                {
                    intersect = leftVal.Union <int>(rightVal).ToList <int>();


                    // Para conseguirmos ter um default

                    /*if (curLeaf == root && intersect[0] != -1)
                     * {
                     *  curLeaf.SetNextHop(intersect[0]);
                     *  bool delete = DeleteDefault(curLeaf.GetLeft(), intersect[0]);
                     *  if (delete)
                     *      curLeaf.SetLeft(null);
                     *  delete = DeleteDefault(curLeaf.GetRight(), intersect[0]);
                     *  if (delete)
                     *      curLeaf.SetRight(null);
                     * }*/

                    if (curLeaf == root && !intersect.Contains(-1))
                    {
                        curLeaf.SetNextHop(intersect[0]);
                        bool delete = DeleteDefault(curLeaf.GetLeft(), intersect[0]);
                        if (delete)
                        {
                            curLeaf.SetLeft(null);
                        }
                        delete = DeleteDefault(curLeaf.GetRight(), intersect[0]);
                        if (delete)
                        {
                            curLeaf.SetRight(null);
                        }
                    }
                }

                return(intersect);
            }
            else
            {
                //List<int> newList = new List<int>();

                //newList.Add(nextHop);


                curLeaf.possibleNextHops = new List <int>();

                curLeaf.possibleNextHops.Add(nextHop);

                return(curLeaf.possibleNextHops);
            }
        }