UNIT uCola;

INTERFACE
USES uElem,uPrior;
    TYPE

        TNodo = ^TAlmacen;

        TAlmacen = RECORD
            info:TElem;
            sig:TNodo;
            prior:TPrior;
        END;

        TCola = RECORD
            cab,fin:TNodo;
        END;

    PROCEDURE CrearColaVacia (VAR cola:TCola);

    PROCEDURE InsertarFinal (VAR cola:TCola; elem:TElem);

    FUNCTION EsColaVacia (cola:TCola):boolean;

    PROCEDURE QuitarCola (VAR cola:TCola);

    PROCEDURE PrimeroDeLaCola (cola:TCola;VAR primer:TElem);

    PROCEDURE BorrarCola (VAR cola:TCola);

    PROCEDURE MostrarCola (cola:TCola);

    PROCEDURE CopiarCola (cola:TCola; VAR colaCopia:TCola);

    FUNCTION ColasIguales (cola1,cola2:TCola):boolean;

    PROCEDURE InsertarSegunPrioridad (VAR cola:TCola; elem:TElem; prior:TPrior);

IMPLEMENTATION

    PROCEDURE CrearColaVacia (VAR cola:TCola);
        BEGIN
            cola.cab := NIL;
            cola.fin := NIL;
        END;{CrearColaVacia}

    PROCEDURE InsertarFinal (VAR cola:TCola; elem:TElem);
        VAR
            aux:TNodo;
        BEGIN

            new(aux);
            Asignar(aux^.info,elem);
            aux^.sig := NIL;

            IF NOT(EsColaVacia(cola)) THEN
                cola.fin^.sig := aux
            ELSE
                cola.cab := aux;


            cola.fin := aux;

        END;{InsertarFinal}

    FUNCTION EsColaVacia (cola:TCola):boolean;
        BEGIN
            EsColaVacia := (cola.cab = NIL);
        END;{EsColaVacia}

    PROCEDURE QuitarCola (VAR cola:TCola);
        VAR
            aux:TNodo;
        BEGIN
            IF NOT(EsColaVacia(cola)) THEN
                BEGIN
                    aux := cola.cab;


                    IF NOT(cola.cab = cola.fin) THEN
                            cola.cab := cola.cab^.sig
                    ELSE
                        BEGIN
                            cola.cab := NIL;
                            cola.fin := NIL;

                        END;
                    dispose(aux);

                END;
        END;{QuitarCola}

    PROCEDURE PrimeroDeLaCola (cola:TCola;VAR primer:TElem);
        BEGIN
            IF NOT(EsColaVacia(cola)) THEN
                primer := cola.cab^.info;
        END;{PrimeroDeLaCola}

    PROCEDURE MostrarCola (cola:TCola);
        BEGIN
            WHILE NOT(EsColaVacia(cola)) DO
                BEGIN
                    writeln(cola.cab^.info);
                    cola.cab := cola.cab^.sig;
                END;{WHILE}
        END;{MostrarCola}

    PROCEDURE BorrarCola (VAR cola:TCola);
        BEGIN
            WHILE NOT(EsColaVacia(cola)) DO
                BEGIN
                    QuitarCola(cola);
                END;{WHILE}
        END;{BorrarCola}

    PROCEDURE CopiarCola (cola:TCola; VAR colaCopia:TCola);
        VAR
            aux2:TNodo;
        BEGIN
            CrearColaVacia(colaCopia);
            WHILE NOT(EsColaVacia(cola)) DO
                BEGIN

                    new(aux2);
                    Asignar(aux2^.info,cola.cab^.info);
                    aux2^.sig := NIL;

                    IF EsColaVacia(colaCopia) THEN
                        BEGIN

                            colaCopia.cab := aux2;
                            colaCopia.fin := aux2;


                        END{IF}
                    ELSE
                        colaCopia.fin^.sig := aux2;

                    colaCopia.fin := aux2;
                    cola.cab := cola.cab^.sig;

                END;{WHILE}

        END;{CopiarCola}

    FUNCTION ColasIguales (cola1,cola2:TCola):boolean;
        VAR
            indicador:boolean;
        BEGIN
            IF (EsColaVacia(cola1)) AND (EsColaVacia(cola2)) THEN
                ColasIguales := TRUE
            ELSE
                IF ( NOT(EsColaVacia(cola1)) AND (EsColaVacia(cola2)) ) OR ( (EsColaVacia(cola1)) AND NOT(EsColaVacia(cola2)) ) THEN
                    ColasIguales := FALSE
                ELSE
                    BEGIN
                        indicador := TRUE;
                        WHILE (indicador=TRUE) AND (NOT(EsColaVacia(cola1)) AND NOT(EsColaVacia(cola2))) DO
                            BEGIN
                                indicador := Iguales(cola1.cab^.info , cola2.cab^.info);

                                cola1.cab := cola1.cab^.sig;

                                cola2.cab := cola2.cab^.sig;

                                IF ( NOT(EsColaVacia(cola1)) AND (EsColaVacia(cola2)) ) OR ( (EsColaVacia(cola1)) AND NOT(EsColaVacia(cola2)) ) THEN
                                    indicador := FALSE

                            END;{WHILE}

                        ColasIguales := indicador;
                    END;{ELSE}

        END;{ColasIguales}



    PROCEDURE InsertarSegunPrioridad (VAR cola:TCola; elem:TElem; prior:TPrior);
        VAR
            aux,act,ant:TNodo;
        BEGIN
            IF EsColaVacia(cola) THEN
                BEGIN
                    new(aux);
                    Asignar(aux^.info,elem);
                    AsignarPrior(aux^.prior,prior);
                    aux^.sig := NIL;
                    cola.cab := aux;
                    cola.fin := aux;
                END {IF}
            ELSE
                BEGIN
                    ant := NIL;
                    act := cola.cab;
                    WHILE ( act <> NIL ) AND (MayorPrior(prior,act^.prior) = FALSE ) DO
                        BEGIN
                            ant := act;
                            act := act^.sig;
                        END;{WHILE}

                    new(aux);
                    Asignar(aux^.info,elem);
                    AsignarPrior(aux^.prior,prior);

                    IF act<>NIL THEN
                        IF (Igual(act^.prior,prior)) THEN
                            BEGIN
                                aux^.sig := act^.sig;
                                act^.sig := aux;

                                IF act=cola.fin THEN
                                        cola.fin := aux;
                            END

                    ELSE
                        IF (ant=NIL) THEN
                            BEGIN
                                aux^.sig := cola.cab;

                                cola.cab := aux;
                            END

                        ELSE

                            IF (ant<>NIL) THEN
                                BEGIN

                                    ant^.sig := aux;
                                    aux^.sig := act;

                                END

                            ELSE

                            {IF act=NIL THEN}
                                BEGIN

                                    ant^.sig := aux;
                                    aux^.sig := NIL;

                                    cola.fin := aux;

                                END;
            END;

        END; {InsertarSegunPrioridad}




END.