//IQueue.h
#pragma once
#include "IFileSerializable.h"

/// Interface que define o comportamento de uma queue
/// Versão 1.1 (12/04/2010)

template <class T>
class IQueue: public IFileSerializable{
public:
    /// Construtores a implementar:
    /// - omissão
    /// - cópia
    /// - Eventualmente, de conversão tais como:
    /// Bag     -> Queue
    /// Set     -> Queue
    /// Sequence -> Queue
    /// Dictionary (Dict)   -> Queue

    /// Métodos para a Queue

    /// Método que permite verificar se a Queue está vazia.
    /// @return Devolve true se a Queue estiver vazia e false caso contrário.
    virtual bool empty()const=0;

    /// Método que permite verificar se a Queue está cheia.
    /// @return Devolve true se a Queue estiver cheia e false caso contrário.
    virtual bool full()const=0;

    /// Método que permite determinar o número de elementos da Queue
    /// @return Devolve o número de elementos existentes na Queue.
    virtual int count()const=0;

    /// Método que permite remover todos os elementos da Queue.
    /// @return Devolve o número de elementos removidos.
    virtual int remAll()=0;

    /// Método que permite adicionar um novo elemento à queue.
    /// @param c Elemento a adicionar à queue.
    /// @return Devolve true se o elemento c efectivamente adicionado e false caso contrário.
    virtual bool enqueue(const T &c)=0;

    /// Método que permite remover um elemento da queue.
    /// @param c Elemento removido da queue.
    /// @return Devolve true se efectivamente remover um elemento da queue e false caso contrário.
    virtual bool dequeue(T &c)=0;

    /// Método que permite aceder ao próximo elemento a ser removido da queue.
    /// @param c Próximo elemento a ser removido da queue.
    /// @return Devolve true se existir o elemento c e false caso contrário.
    virtual bool head(T &c)=0;

    /// Métodos entre Queues

    /// Método que permite fazer a concatenação de duas queues.
    /// @param q Queue cujos elementos serão concatenados com o objecto.
    /// @return Devolve a referência do objecto (Queue sobre a qual se fez a concatenação),
    /// contendo já os elementos da Queue que entra como parâmetro.
    virtual IQueue<T> &concate(IQueue<T> &q)=0;

    /// Método que permite verificar se duas Queues são iguais.
    /// @param q Queue com a qual o objecto vai ser comparado.
    /// @return Devolve true se as Queues são iguais e false caso contrário.
    virtual bool equal(IQueue<T> &q)const=0;

    /// Redefinição de operadores

    /// Sobrecarga de operador ! - Permitindo verificar se a Queue está vazia.
    /// @return Devolve true se a Queue estiver vazia e false caso contrário.
    virtual bool operator!()const=0;

    /// Sobrecarga do operador () - Permitindo adicionar um novo elemento à Queue.
    /// @param c Parâmetro a adicionar à Queue (deve ficar armazenado na Queue uma cópia de c).
    /// @return Devolve true se o elemento for efectivamente inserido e false caso contrário.
    virtual bool operator()(T &c)=0;

    /// Sobrecarga do operador [] - Permitindo remover um elemento da Queue.
    /// @param c Elemento removido da Queue.
    /// @return Devolve true se efectivamente for devolvido um elemento e false caso contrário.
    virtual bool operator[](T &c)=0;

    /// Sobrecarga do operador = - Permitindo fazer a atribuição entre Queues.
    /// @param q Identifica a Queue a atribuir ao objecto.
    /// @return Devolve a referência do objecto (já após a atribuição).
    //virtual IQueue<T>& operator=(IQueue<T> &q)=0;

    /// Sobrecarga do operador = - Permitindo fazer a atribuição de um Bag à Queue.
    /// @param b Identifica o Bag a atribuir ao objecto.
    /// @return Devolve a referência do objecto (já após a atribuição).
    // virtual IQueue<T>& operator=(IBag<T> &b)=0;

    /// Sobrecarga do operador = - Permitindo fazer a atribuição de um Set à Queue.
    /// @param s Identifica o Set a atribuir ao objecto.
    /// @return Devolve a referência do objecto (já após a atribuição).
    // virtual IQueue<T>& operator=(ISet<T> &s)=0;

    /// Sobrecarga do operador = - Permitindo fazer a atribuição de uma Sequence à Queue.
    /// @param s Identifica a Sequence a atribuir ao objecto.
    /// Nota: Na queue devem ficar guardados os valores associados aos índices.
    /// @return Devolve a referência do objecto (já após a atribuição).
    // virtual IQueue<T>& operator=(ISeq<T> &s)=0;

    /// Sobrecarga do operador += - Permitindo fazer a concatenação entre duas Queues.
    /// @param q Queue cujos elementos serão concatenados com o objecto.
    /// @return Devolve a referência do objecto (Queue sobre a qual se fez a concatenação),
    /// contendo já os elementos da Queue que entra como parâmetro.
    virtual IQueue<T>& operator+=(IQueue<T> &q)=0;

    /// Sobrecarga do operador == - Permitindo verificar se duas Queue são iguais.
    /// @param q Queue com a qual o objecto vai ser comparado.
    /// @return Devolve true se as Queues forem iguais e false caso contrário.
    virtual bool operator==(IQueue<T> &q)const=0;

    /// Sobrecarga do operador != - Permitindo verificar se duas Queues são diferentes.
    /// @param q Queue com a qual o objecto vai ser comparado.
    /// @return Devolve true se as Queues forem diferentes e false caso contrário.
    virtual bool operator!=(IQueue<T> &q)const=0;

    /// Métodos amigáveis
    //// friend ostream& operator<< <T>(ostream&,IQueue<T>&);
};