Ejercicio

PAQUETE.HPP

#ifndef PAQUETE_HPP_INCLUDED
#define PAQUETE_HPP_INCLUDED
#include <iostream>



enum Excepcion {ERROR_EN_PAQUETE,LISTA_VACIA};



    class Paquete{
    public:

        Paquete(const std::string& ide, const unsigned ordi, const std::string& cont);
        Paquete(const Paquete& p);
        std::string get_id() const;
        unsigned get_ord() const;
        std::string get_contenido() const;
        std::string str() const;
        friend bool operator < (const Paquete& p, const Paquete& q);

    private:

        std::string id;
        unsigned ord;
        std::string contenido;

            };



#endif // PAQUETE_HPP_INCLUDED

PAQUETE.CPP

#include <sstream>
#include "Paquete.hpp"



using namespace std;

    Paquete::Paquete(const string& ide, const unsigned ordi, const string& cont){
        if (ide == "" or ordi < 0) throw ERROR_EN_PAQUETE;
        id = ide;
        ord = ordi;
        contenido = cont;
        }

    Paquete::Paquete(const Paquete& p){
        id = p.id;
        ord = p.ord;
        contenido = p.contenido;
        }

    string Paquete::get_id() const{
        return id;
        }

    unsigned Paquete::get_ord() const{
            return ord;
        }

    string Paquete::get_contenido() const{
        return contenido;
        }

    string Paquete::str() const{
        ostringstream os;
        os << id << " " << ord << " " << contenido;
        return os.str();
        }

     bool operator < (const Paquete& p, const Paquete& q){
        return p.ord < q.ord;
        }

LISTAPAQUETE.HPP

#define LISTAPAQUETE_HPP_INCLUDED
#include "Paquete.hpp"
#include <iostream>






    class ListaPaquetes{
        public:

            ListaPaquetes();
            ListaPaquetes(const ListaPaquetes& lp);

LISTAPAQUETE.CPP

#include "ListaPaquete.hpp"
#include <sstream>

using namespace std;

            ListaPaquetes::ListaPaquetes():n_pack(0), _primero(NULL), _ultimo(NULL) //INICIALIZA LOS PUNTEROS, SIEMPRE A NULL, NO HAY NADA
            {}


            ListaPaquetes::ListaPaquetes(const ListaPaquetes& lp): n_pack(0), _primero(NULL), _ultimo(NULL){

                if (lp.n_pack > 0){
                    Nodo *ptr = lp._primero;// NODO EMPIEZA EN PRIMERO, DE lp, QUE ES EL QUE LE PASAMOS
                    while(ptr != NULL){         //Terminara cuando prt != NULL
                        add_pack(*(ptr->ppack));
                        ptr = ptr->sig;
            }
        }
    }


            ListaPaquetes::~ListaPaquetes(){
                if (n_pack > 0){
                    Nodo *ptr = _primero;
                    while(ptr != NULL){
                        _primero = _primero->sig; //Primero me cargo el packete y luego me cargo el puntero. avanzo el puntero.
                        delete (ptr->ppack);
                        delete ptr;
                        ptr = _primero;
                    }
            }
        }
            void ListaPaquetes::clear(){
                if (n_pack > 0){
                    Nodo *ptr = _primero;
                    while(ptr != NULL){
                        _primero = _primero->sig; //Primero me cargo el packete y luego me cargo el puntero. avanzo el puntero.
                        delete (ptr->ppack);
                        delete ptr;
                        ptr = _primero;
                    }
                    _primero = (NULL); //LIMPIO LA ESTRUCTURA.
                    _ultimo = _primero;
                    n_pack = 0;
            }
}
            bool ListaPaquetes::esta_vacia() const{
                if (n_pack == 0) throw LISTA_VACIA;
                return n_pack == 0;
                }

            string ListaPaquetes::primer_id(){
                return _primero->ppack->get_id();

            }


            void ListaPaquetes::add_pack(const Paquete& pq){
                Nodo *ptr = new Nodo;
                ptr->sig = NULL;
                ptr->ppack = new Paquete(pq);

                if (n_pack == 0) { //Comprobamos si el estado de la trasmsion esta por inicializar, caso NULL

                    _primero = ptr;
                }else{
                    _ultimo->sig = ptr;
            }
                    _ultimo = ptr;
                    ++ n_pack;
        }





        string ListaPaquetes::recuperar_mensaje(const string& id){
            ListaPaquetes ListaAuxiliar;
            Nodo *actual = _primero;
            Nodo *anterior = NULL;

            while(actual != NULL){
                if(actual->ppack->get_id() == id){
                   ListaAuxiliar.insert_pack(actual);
           /*VERIFICAR SI ES _primero y colocar _primero adecuadamente*/
                    if(actual == _primero){
                        _primero = _primero->sig;
            }
            /*AJUSTAR PUNTEROS DEL ANTERIOR AL BORRADO*/
                    else if (actual != _primero or actual != _ultimo){
                        anterior->sig = actual->sig;
            }
           /*VERIFICAR SI ES _ultimo y colocar _ultimo adecuadamente*/
                    else if(actual == _ultimo){
                        anterior->sig = actual->sig;
                        _ultimo = anterior;
            }


            --n_pack;
        }
            anterior = actual;
            actual = actual->sig;
    }
            actual = ListaAuxiliar._primero;
            ostringstream os;

            while (actual != NULL){
                os << actual->ppack->get_contenido();
                actual = actual->sig;

                }
                return os.str();

  }

 string ListaPaquetes::str() const{
    Nodo *actual = _primero;
    ostringstream os;

    while (actual != NULL) {
        os << actual->ppack->get_id() << " " << actual->ppack->get_ord() << " " <<  actual->ppack->get_contenido() << endl;
        actual = actual->sig;

        }

        return os.str();
 }
//AUX

void ListaPaquetes::insert_pack(Nodo *ppq){


    Nodo *aux;

    //Creacion
    if (_primero == NULL){
            _primero = ppq;
            aux = ppq;
            ppq->sig = NULL;
            _ultimo = ppq;

    }else{
        //Nuevo nodo menor al _primero
        if  (_primero->ppack->get_ord() > (ppq->ppack->get_ord())) {
                ppq->sig = _primero;
                _primero = ppq;

        }else{
            //Insercción normal.
            aux = _primero;
            //Búsqueda
            while(aux->sig!= NULL and (aux->sig->ppack->get_ord()) < (ppq->ppack->get_ord())) {
                aux = aux->sig;
            }
            ppq->sig = aux->sig;
            aux->sig = ppq;

            if(ppq->sig == NULL){
                _ultimo = ppq;
            }
        }
      }
    ++n_pack;
    }

RECEPTOR.HPP

#include "ListaPaquete.hpp"
#include <vector>

 //NO QUEREMOS STD


class Receptor{
    public:


        Receptor();
        Receptor(const Receptor& rc);
        ~Receptor();
        void clear();
        void add_pack(const Paquete& pq);
        std::string extraer_msgs();
        std::string str() const;

    private:

        ListaPaquetes transmisiones;
        std::vector<std::string> msgs_recibidos;


};

#endif // RECEPTOR_HPP_INCLUDED

RECEPTOR.CPP

#include "Receptor.hpp"
#include <iostream>

using namespace std;

        Receptor::Receptor(){}


        Receptor::Receptor(const Receptor& rc){}


        Receptor::~Receptor(){}


        void Receptor::clear(){}


        void Receptor::add_pack(const Paquete& pq){}


        string Receptor::extraer_msgs(){}


        string Receptor::str() const{}

MAIN MAIN MAIN MAIN MAIN MAIN MAIN MAIN MAIN

#include "ListaPaquete.hpp"
#include "Paquete.hpp"
#include "Receptor.cpp"

using namespace std;

int main()
{
    Paquete p1("id1", 1, "Esto ");
    Paquete p2("id1", 2, "es ");
    Paquete p3("id1", 3, "una prueba");

    Paquete q1("id2", 1, "Estamos ");
    Paquete q2("id2", 2, "a la ");
    Paquete q3("id2", 3, "espera");

    cout << "Se reciben paquetes ..................." << endl;
    Receptor tr;
    tr.add_pack(p1);
    tr.add_pack(q2);
    tr.add_pack(p3);
    tr.add_pack(q1);
    tr.add_pack(p2);
    tr.add_pack(q3);
    cout << endl;

    cout << "Estado del receptor ..................." << endl;
    cout << tr.str() << endl << endl ;

    cout << "Se extraen los mensajes del receptor..." << endl;
    tr.extraer_msgs();
    cout << endl;

    cout << "Estado del receptor ..................." << endl;
    cout << tr.str() << endl;

    return 0;
}


            ~ListaPaquetes();
            void clear();
            bool esta_vacia() const;
            std::string primer_id();
            void add_pack(const Paquete& pq);
            std::string recuperar_mensaje(const std::string& id);
            std::string str() const;


        private:

            struct Nodo{
            Paquete * ppack;
            Nodo * sig;
        };

        unsigned n_pack;
        Nodo *_primero, *_ultimo;
        void insert_pack(Nodo *ppq);

        };






#endif // LISTAPAQUETE_HPP_INCLUDED