Merge pull request #15 from Steva0/modifica-Test-e-mainNode

Steva0 · web-flow · commit c5c5fd45b875 · 2024-12-29T14:08:47.000+01:00
Modifica test e main node
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -12,14 +12,16 @@ set(SOURCES
     src/CreaDispositivo.cpp
     src/Dispositivo.cpp
     src/RicercaDispositivo.cpp
-    src/main.cpp
+    src/mainNode.cpp
+    src/LinkedList.cpp
 )
 
 set(HEADERS
     include/CreaDispositivo.h
     include/Dispositivo.h
     include/ListaDispositivi.h
     include/RicercaDispositivo.h
+    include/LinkedList.h
 )
 
 # Crea l'eseguibile
diff --git a/include/DispositivoNonTrovatoException.h b/include/DispositivoNonTrovatoException.h
diff --git a/include/LinkedList.h b/include/LinkedList.h
@@ -1,11 +1,9 @@
 #ifndef LINKED_LIST_H
 #define LINKED_LIST_H
 #include "CreaDispositivo.h"
-#include "DispositivoNonTrovatoException.h"
-#include "ListaVuotaException.h"
 #include <iostream>
 #include <ostream>
-
+#include <exception>
 
 class LinkedList
 {
@@ -18,22 +16,18 @@ class LinkedList
         Dispositivo* disp;
         Node* prev;
         Node* next;
+        
         Node(Dispositivo& data);
 
-        //copy constructor
-        Node(const Node& data);
-
-        //copy assignment
-        Node& operator=(const Node& data);
-
         ~Node();
     };
     
     Node* head;
     Node* tail;
 
     //Funzioni private
-    Node* searchDispositivo(const std::string nome) const;                  //cerca un dispositivo nella lista
+    Node* searchDispositivoName(const std::string nome) const;                  //cerca un dispositivo nella lista by NAME
+    Node* searchDispositivoId(const int id) const;                //cerca un dispositivo nella lista by ID
     void connectBefore(Node* p, Node* q);                                   //connette prima di p il nodo q
 
     public:
@@ -43,7 +37,8 @@ class LinkedList
 
     //Funzioni membro utili
     void insert(Dispositivo& dispositivo);                                  //inserisce un dispositivo in coda
-    Dispositivo* removeDispositivo(const std::string nome);                         //rimuove un dispositivo dalla lista accettando il nome del dispositivo
+    Dispositivo* removeDispositivoName(const std::string nome);                         //rimuove un dispositivo dalla lista accettando il nome del dispositivo by NAME
+    Dispositivo* removeDispositivoId(const int id);                         //rimuove un dispositivo dalla lista accettando il nome del dispositivo by ID
     std::vector<Dispositivo*> removeAllDispositiviOff(const int currentTime);     //rimuove tutti i dispositivi spenti (la cui ora e' prima dell'orario indicato)
     void removeTimer(const std::string nome);                               //rimuove il timer di un dispositivo
     void removeAllTimers();                                                 //rimuove tutti i timer
diff --git a/include/ListaVuotaException.h b/include/ListaVuotaException.h
diff --git a/src/LinkedList.cpp b/src/LinkedList.cpp
@@ -1,28 +1,17 @@
 #include "../include/LinkedList.h"
-using namespace std;
 
 LinkedList::Node::Node(Dispositivo& data): prev{nullptr}, next{nullptr}, disp{&data} 
 { }
 
-LinkedList::Node::Node(const Node& data): prev{data.prev}, next{data.next}, disp{data.disp}
+LinkedList::LinkedList(): head{nullptr}, tail{nullptr}
 { }
 
-LinkedList::Node& LinkedList::Node::operator=(const Node& data)
-{
-    prev = data.prev;
-    next = data.next;
-    disp = data.disp;
-    return *this;
-}
-
 LinkedList::Node::~Node()
 {
-    delete disp;
+    prev = nullptr;
+    next = nullptr;
 }
 
-LinkedList::LinkedList(): head{nullptr}, tail{nullptr}
-{ }
-
 LinkedList::LinkedList(Dispositivo& dispositivo)
 { 
     head = tail = new Node(dispositivo);
@@ -62,71 +51,98 @@ void LinkedList::insert(Dispositivo& dispositivo)
     }
 }
 
-Dispositivo* LinkedList::removeDispositivo(const string nome)
+Dispositivo* LinkedList::removeDispositivoName(const std::string nome)
+{
+    if(isEmpty())
+    {
+        throw std::out_of_range("Lista vuota!");
+    }
+
+    Node* current = searchDispositivoName(nome);
+
+    if(current == head)
+    {
+        head = head->next;
+        head->prev = nullptr;
+    }
+    else if(current == tail)
+    {
+        tail = tail->prev;
+        tail->next = nullptr;
+    }
+    else
+    {
+        current->prev->next = current->next;
+        current->next->prev = current->prev;
+    }
+
+    Dispositivo* disp = current->disp;
+    delete current;
+    return disp;
+}
+
+Dispositivo* LinkedList::removeDispositivoId(const int id)
 {
     if(isEmpty())
     {
-        throw ListaVuotaException();
+        throw std::out_of_range("Lista vuota!");
     }
 
-    Node* current = searchDispositivo(nome);
+    Node* current = searchDispositivoId(id);
 
     if(current == head)
     {
         head = head->next;
         head->prev = nullptr;
-        return current->disp;
     }
     else if(current == tail)
     {
         tail = tail->prev;
         tail->next = nullptr;
-        return current->disp;
     }
     else
     {
         current->prev->next = current->next;
         current->next->prev = current->prev;
-        return current->disp;
     }
+
+    Dispositivo* disp = current->disp;
+    delete current;
+    return disp;
 }
 
-vector<Dispositivo*> LinkedList::removeAllDispositiviOff(const int currentTime)
+std::vector<Dispositivo*> LinkedList::removeAllDispositiviOff(const int currentTime)
 {
     if(isEmpty())
     {
-        throw ListaVuotaException();
+        throw std::out_of_range("Lista vuota!");
     }
 
-    vector<Dispositivo*> dispositiviSpenti;
+    std::vector<Dispositivo*> dispositiviSpenti;
     Node* current = head;
     while(current)
     {
         if(current->disp->getOrarioSpegnimento() <= currentTime)
         {
             dispositiviSpenti.push_back(current->disp);
             Node* temp = current;
-            current = current->next;
-            removeDispositivo(temp->disp->getNome());
-        }
-        else
-        {
-            current = current->next;
+            removeDispositivoName(temp->disp->getNome());
         }
+        current = current->next;
     }
 
     return dispositiviSpenti;
 }
 
 
-void LinkedList::removeTimer(const string nome)
+void LinkedList::removeTimer(const std::string nome)
 {
     if(isEmpty())
     {
-        throw ListaVuotaException();
+        throw std::out_of_range("Lista vuota!");;
     }
 
-    Node* current = searchDispositivo(nome);
+    Node* current = searchDispositivoName(nome);
 
     current->disp->setTimerOff();
 }
@@ -135,7 +151,7 @@ void LinkedList::removeAllTimers()
 {
     if(isEmpty())
     {
-        throw ListaVuotaException();
+        throw std::out_of_range("Lista vuota!");;
     }
 
     Node* current = head;
@@ -151,7 +167,7 @@ bool LinkedList::isEmpty() const
     return (head == nullptr);
 }
 
-ostream& operator<<(ostream& os, const LinkedList& list)
+std::ostream& operator<<(std::ostream& os, const LinkedList& list)
 {
     if(list.isEmpty())
     {
@@ -180,11 +196,11 @@ void LinkedList::connectBefore(Node* p, Node* q)
     p->prev = q;
 }
 
-LinkedList::Node* LinkedList::searchDispositivo(const std::string nome) const
+LinkedList::Node* LinkedList::searchDispositivoName(const std::string nome) const
 {
     if(isEmpty())
     {
-        throw ListaVuotaException();
+        throw std::out_of_range("Lista vuota!");;
     }
 
     Node* current = head;
@@ -195,7 +211,28 @@ LinkedList::Node* LinkedList::searchDispositivo(const std::string nome) const
 
     if(current == nullptr)
     {
-        throw DispositivoNonTrovatoException();
+        throw std::invalid_argument("Dispositivo non trovato!");;
+    }
+
+    return current;
+}
+
+LinkedList::Node* LinkedList::searchDispositivoId(const int id) const
+{
+    if(isEmpty())
+    {
+        throw std::out_of_range("Lista vuota!");;
+    }
+
+    Node* current = head;
+    while(current && current->disp->getId() != id)
+    {
+        current = current->next;
+    }
+
+    if(current == nullptr)
+    {
+        throw std::invalid_argument("Dispositivo non trovato!");;
     }
 
     return current;
diff --git a/src/mainNode.cpp b/src/mainNode.cpp
@@ -6,44 +6,48 @@ using namespace std;
 
 int main()
 {
-    Dispositivo Frigorifero = CreaDispositivo::creaDispositivo("Frigrifero", 76);        //Manuale 
-    Dispositivo Lavatrice = CreaDispositivo::creaDispositivo("Lavtrice", 8);            //110 min 
-    Dispositivo ScaldaBagno = CreaDispositivo::creaDispositivo("Scalda bagno", 9);       //Manuale
-    Dispositivo Televisore = CreaDispositivo::creaDispositivo("Televisre", 4);          //60 min 
-    Dispositivo Asciugatrice = CreaDispositivo::creaDispositivo("Asciugatrice", 2);     //60 min
-    Dispositivo FornoMicroonde = CreaDispositivo::creaDispositivo("Forno a microonde", 1);   //2 min
-    
-    LinkedList list = LinkedList();
-
-    list.insert(Frigorifero);
-    cout << list << endl;
-
-    list.insert(Lavatrice);
-    cout << list << endl;
-
-    list.insert(ScaldaBagno);
-    cout << list << endl;
-
-    list.insert(Televisore);
-    cout << list << endl;
-
-    list.insert(FornoMicroonde);
-    cout << list << endl;
-
-    list.insert(Asciugatrice);
-    cout << list << endl;
-
-    list.removeDispositivo("Scaldabagno");
-    cout << list << endl;
-
-    cout << Televisore.getOrarioSpegnimento() << endl;
-
-    list.removeAllDispositiviOff(5);
-    cout << list << endl;
-
-    list.removeTimer("Asciugatrice");
-    cout << list << endl;
-    cout << Asciugatrice.getOrarioSpegnimento() << endl;
-    
-    
+    try {
+        Dispositivo Frigorifero = CreaDispositivo::creaDispositivo("Frigrifero", 76);        //Manuale 
+        Dispositivo Lavatrice = CreaDispositivo::creaDispositivo("Lavtrice", 8);            //110 min 
+        Dispositivo ScaldaBagno = CreaDispositivo::creaDispositivo("Scalda bagno", 9);       //Manuale
+        Dispositivo Televisore = CreaDispositivo::creaDispositivo("Televisre", 4);          //60 min 
+        Dispositivo Asciugatrice = CreaDispositivo::creaDispositivo("Asciugatrice", 2);     //60 min
+        Dispositivo FornoMicroonde = CreaDispositivo::creaDispositivo("Forno a microonde", 1);   //2 min
+        
+        LinkedList list = LinkedList();
+
+        list.insert(Frigorifero);
+        cout << list << endl;
+
+        list.insert(Lavatrice);
+        cout << list << endl;
+
+        list.insert(ScaldaBagno);
+        cout << list << endl;
+
+        list.insert(Televisore);
+        cout << list << endl;
+
+        list.insert(FornoMicroonde);
+        cout << list << endl;
+
+        list.insert(Asciugatrice);
+        cout << list << endl;
+
+        list.removeDispositivoName("Scaldabagno");
+        cout << list << endl;
+
+        cout << Televisore.getOrarioSpegnimento() << endl;
+
+        list.removeAllDispositiviOff(5);
+        cout << list << endl;
+
+        list.removeTimer("Asciugatrice");
+        cout << list << endl;
+        cout << Asciugatrice.getOrarioSpegnimento() << endl;
+    }
+    catch (exception& e) {
+        return 1;
+    }
+    return 0;
 }

Original file line number	Diff line number	Diff line change
`@@ -1,28 +1,17 @@`
`1`	`1`	`#include "../include/LinkedList.h"`
`2`		`-using namespace std;`
`3`	`2`
`4`	`3`	`LinkedList::Node::Node(Dispositivo& data): prev{nullptr}, next{nullptr}, disp{&data}`
`5`	`4`	`{ }`
`6`	`5`
`7`		`-LinkedList::Node::Node(const Node& data): prev{data.prev}, next{data.next}, disp{data.disp}`
	`6`	`+LinkedList::LinkedList(): head{nullptr}, tail{nullptr}`
`8`	`7`	`{ }`
`9`	`8`
`10`		`-LinkedList::Node& LinkedList::Node::operator=(const Node& data)`
`11`		`-{`
`12`		`- prev = data.prev;`
`13`		`- next = data.next;`
`14`		`- disp = data.disp;`
`15`		`- return *this;`
`16`		`-}`
`17`		`-`
`18`	`9`	`LinkedList::Node::~Node()`
`19`	`10`	`{`
`20`		`- delete disp;`
	`11`	`+ prev = nullptr;`
	`12`	`+ next = nullptr;`
`21`	`13`	`}`
`22`	`14`
`23`		`-LinkedList::LinkedList(): head{nullptr}, tail{nullptr}`
`24`		`-{ }`
`25`		`-`
`26`	`15`	`LinkedList::LinkedList(Dispositivo& dispositivo)`
`27`	`16`	`{`
`28`	`17`	`head = tail = new Node(dispositivo);`
`@@ -62,71 +51,98 @@ void LinkedList::insert(Dispositivo& dispositivo)`
`62`	`51`	`}`
`63`	`52`	`}`
`64`	`53`
`65`		`-Dispositivo* LinkedList::removeDispositivo(const string nome)`
	`54`	`+Dispositivo* LinkedList::removeDispositivoName(const std::string nome)`
	`55`	`+{`
	`56`	`+ if(isEmpty())`
	`57`	`+ {`
	`58`	`+ throw std::out_of_range("Lista vuota!");`
	`59`	`+ }`
	`60`	`+`
	`61`	`+ Node* current = searchDispositivoName(nome);`
	`62`	`+`
	`63`	`+ if(current == head)`
	`64`	`+ {`
	`65`	`+ head = head->next;`
	`66`	`+ head->prev = nullptr;`
	`67`	`+ }`
	`68`	`+ else if(current == tail)`
	`69`	`+ {`
	`70`	`+ tail = tail->prev;`
	`71`	`+ tail->next = nullptr;`
	`72`	`+ }`
	`73`	`+ else`
	`74`	`+ {`
	`75`	`+ current->prev->next = current->next;`
	`76`	`+ current->next->prev = current->prev;`
	`77`	`+ }`
	`78`	`+`
	`79`	`+ Dispositivo* disp = current->disp;`
	`80`	`+ delete current;`
	`81`	`+ return disp;`
	`82`	`+}`
	`83`	`+`
	`84`	`+Dispositivo* LinkedList::removeDispositivoId(const int id)`
`66`	`85`	`{`
`67`	`86`	`if(isEmpty())`
`68`	`87`	`{`
`69`		`- throw ListaVuotaException();`
	`88`	`+ throw std::out_of_range("Lista vuota!");`
`70`	`89`	`}`
`71`	`90`
`72`		`- Node* current = searchDispositivo(nome);`
	`91`	`+ Node* current = searchDispositivoId(id);`
`73`	`92`
`74`	`93`	`if(current == head)`
`75`	`94`	`{`
`76`	`95`	`head = head->next;`
`77`	`96`	`head->prev = nullptr;`
`78`		`- return current->disp;`
`79`	`97`	`}`
`80`	`98`	`else if(current == tail)`
`81`	`99`	`{`
`82`	`100`	`tail = tail->prev;`
`83`	`101`	`tail->next = nullptr;`
`84`		`- return current->disp;`
`85`	`102`	`}`
`86`	`103`	`else`
`87`	`104`	`{`
`88`	`105`	`current->prev->next = current->next;`
`89`	`106`	`current->next->prev = current->prev;`
`90`		`- return current->disp;`
`91`	`107`	`}`
	`108`	`+`
	`109`	`+ Dispositivo* disp = current->disp;`
	`110`	`+ delete current;`
	`111`	`+ return disp;`
`92`	`112`	`}`
`93`	`113`
`94`		`-vector<Dispositivo*> LinkedList::removeAllDispositiviOff(const int currentTime)`
	`114`	`+std::vector<Dispositivo*> LinkedList::removeAllDispositiviOff(const int currentTime)`
`95`	`115`	`{`
`96`	`116`	`if(isEmpty())`
`97`	`117`	`{`
`98`		`- throw ListaVuotaException();`
	`118`	`+ throw std::out_of_range("Lista vuota!");`
`99`	`119`	`}`
`100`	`120`
`101`		`- vector<Dispositivo*> dispositiviSpenti;`
	`121`	`+ std::vector<Dispositivo*> dispositiviSpenti;`
`102`	`122`	`Node* current = head;`
`103`	`123`	`while(current)`
`104`	`124`	`{`
`105`	`125`	`if(current->disp->getOrarioSpegnimento() <= currentTime)`
`106`	`126`	`{`
`107`	`127`	`dispositiviSpenti.push_back(current->disp);`
`108`	`128`	`Node* temp = current;`
`109`		`- current = current->next;`
`110`		`- removeDispositivo(temp->disp->getNome());`
`111`		`- }`
`112`		`- else`
`113`		`- {`
`114`		`- current = current->next;`
	`129`	`+ removeDispositivoName(temp->disp->getNome());`
`115`	`130`	`}`
	`131`	`+ current = current->next;`
`116`	`132`	`}`
`117`	`133`
`118`	`134`	`return dispositiviSpenti;`
`119`	`135`	`}`
`120`	`136`
`121`	`137`
`122`		`-void LinkedList::removeTimer(const string nome)`
	`138`	`+void LinkedList::removeTimer(const std::string nome)`
`123`	`139`	`{`
`124`	`140`	`if(isEmpty())`
`125`	`141`	`{`
`126`		`- throw ListaVuotaException();`
	`142`	`+ throw std::out_of_range("Lista vuota!");;`
`127`	`143`	`}`
`128`	`144`
`129`		`- Node* current = searchDispositivo(nome);`
	`145`	`+ Node* current = searchDispositivoName(nome);`
`130`	`146`
`131`	`147`	`current->disp->setTimerOff();`
`132`	`148`	`}`
`@@ -135,7 +151,7 @@ void LinkedList::removeAllTimers()`
`135`	`151`	`{`
`136`	`152`	`if(isEmpty())`
`137`	`153`	`{`
`138`		`- throw ListaVuotaException();`
	`154`	`+ throw std::out_of_range("Lista vuota!");;`
`139`	`155`	`}`
`140`	`156`
`141`	`157`	`Node* current = head;`
`@@ -151,7 +167,7 @@ bool LinkedList::isEmpty() const`
`151`	`167`	`return (head == nullptr);`
`152`	`168`	`}`
`153`	`169`
`154`		`-ostream& operator<<(ostream& os, const LinkedList& list)`
	`170`	`+std::ostream& operator<<(std::ostream& os, const LinkedList& list)`
`155`	`171`	`{`
`156`	`172`	`if(list.isEmpty())`
`157`	`173`	`{`
`@@ -180,11 +196,11 @@ void LinkedList::connectBefore(Node* p, Node* q)`
`180`	`196`	`p->prev = q;`
`181`	`197`	`}`
`182`	`198`
`183`		`-LinkedList::Node* LinkedList::searchDispositivo(const std::string nome) const`
	`199`	`+LinkedList::Node* LinkedList::searchDispositivoName(const std::string nome) const`
`184`	`200`	`{`
`185`	`201`	`if(isEmpty())`
`186`	`202`	`{`
`187`		`- throw ListaVuotaException();`
	`203`	`+ throw std::out_of_range("Lista vuota!");;`
`188`	`204`	`}`
`189`	`205`
`190`	`206`	`Node* current = head;`
`@@ -195,7 +211,28 @@ LinkedList::Node* LinkedList::searchDispositivo(const std::string nome) const`
`195`	`211`
`196`	`212`	`if(current == nullptr)`
`197`	`213`	`{`
`198`		`- throw DispositivoNonTrovatoException();`
	`214`	`+ throw std::invalid_argument("Dispositivo non trovato!");;`
	`215`	`+ }`
	`216`	`+`
	`217`	`+ return current;`
	`218`	`+}`
	`219`	`+`
	`220`	`+LinkedList::Node* LinkedList::searchDispositivoId(const int id) const`
	`221`	`+{`
	`222`	`+ if(isEmpty())`
	`223`	`+ {`
	`224`	`+ throw std::out_of_range("Lista vuota!");;`
	`225`	`+ }`
	`226`	`+`
	`227`	`+ Node* current = head;`
	`228`	`+ while(current && current->disp->getId() != id)`
	`229`	`+ {`
	`230`	`+ current = current->next;`
	`231`	`+ }`
	`232`	`+`
	`233`	`+ if(current == nullptr)`
	`234`	`+ {`
	`235`	`+ throw std::invalid_argument("Dispositivo non trovato!");;`
`199`	`236`	`}`
`200`	`237`
`201`	`238`	`return current;`