Merge pull request #14 from Steva0/Nodi-Array-Alberto

LinkedList completata e classi errori + modifiche minime classi michele

Author: MochaSummer2588

include/DispositivoNonTrovatoException.h

@@ -0,0 +1,13 @@
+#ifndef DISPOSITIVONONTROVATOEXCEPTION_H
+#define DISPOSITIVONONTROVATOEXCEPTION_H
+
+#include <stdexcept>
+#include <string>
+
+class DispositivoNonTrovatoException : public std::invalid_argument
+{
+    public:
+    DispositivoNonTrovatoException(): std::invalid_argument("Dispositivo non trovato!") { }
+};
+
+#endif // DISPOSITIVONONTROVATOEXCEPTION_H

include/LinkedList.h

@@ -0,0 +1,61 @@
+#ifndef LINKED_LIST_H
+#define LINKED_LIST_H
+#include "CreaDispositivo.h"
+#include "DispositivoNonTrovatoException.h"
+#include "ListaVuotaException.h"
+#include <iostream>
+#include <ostream>
+
+
+class LinkedList
+{
+    friend std::ostream& operator<<(std::ostream& os, const LinkedList& list);
+    
+    private:
+    class Node
+    {
+        public:
+        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
+    void connectBefore(Node* p, Node* q);                                   //connette prima di p il nodo q
+
+    public:
+    //Costruttore
+    LinkedList();
+    LinkedList(Dispositivo& dispositivo);
+
+    //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
+    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
+    bool isEmpty() const;                                                   //controlla se la lista è vuota
+    double show(std::string nome) const;                                    //mostra il consumo di un dispositivo
+    double showAll() const;                                                 //mostra il consumo totale della lista
+
+    //Distruttiri
+    ~LinkedList();
+};
+
+//overloading operator<<
+std::ostream& operator<<(std::ostream& os, const LinkedList& list);
+
+#endif // LINKED_LIST_H

include/ListaDispositivi.h

@@ -18,7 +18,7 @@ const std::vector<std::pair<std::string, std::tuple<double, int, bool>>> disposi
     {"Frigorifero", {-0.4, 0, true}},  
     {"Forno a microonde", {-0.8, 2, false}},  
     {"Asciugatrice", {-0.5, 60, false}},  
-    {"Televisore", {-0.2, 0, false}} 
+    {"Televisore", {-0.2, 60, false}} 
 };
 
 // Mappa per tenere traccia del numero di serie specifico per ogni tipo di dispositivo

include/ListaVuotaException.h

@@ -0,0 +1,12 @@
+#ifndef LISTAVUOTAEXCEPTION_H
+#define LISTAVUOTAEXCEPTION_H
+
+#include <stdexcept>
+
+class ListaVuotaException: public std::out_of_range
+{
+    public:
+    ListaVuotaException(): std::out_of_range("La lista è vuota.") { }
+};
+
+#endif // LISTAVUOTAEXCEPTION_H

src/Dispositivo.cpp

@@ -127,7 +127,7 @@ void Dispositivo::setTimerOff() {
 }
 
 void Dispositivo::setOrarioAccensione(int minuti) {
-    if (minuti < 0 || minuti >= MAX_MINUTI_GIORNATA) {
+    if (minuti < 0 || minuti >= MINUTI_GIORNATA) {
         throw std::invalid_argument("Orario di accensione non valido.");
     }
     orarioAccensione = minuti;
@@ -137,7 +137,7 @@ void Dispositivo::setOrarioAccensione(int minuti) {
 }
 
 void Dispositivo::setOrarioSpegnimento(int minuti) {
-    if (minuti < 0 || minuti >= MAX_MINUTI_GIORNATA) {
+    if (minuti < 0 || minuti >= MINUTI_GIORNATA) {
         throw std::invalid_argument("Orario di spegnimento non valido.");
     }
     if (!sempreAcceso && minuti <= orarioAccensione) {

src/LinkedList.cpp

@@ -0,0 +1,214 @@
+#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::Node& LinkedList::Node::operator=(const Node& data)
+{
+    prev = data.prev;
+    next = data.next;
+    disp = data.disp;
+    return *this;
+}
+
+LinkedList::Node::~Node()
+{
+    delete disp;
+}
+
+LinkedList::LinkedList(): head{nullptr}, tail{nullptr}
+{ }
+
+LinkedList::LinkedList(Dispositivo& dispositivo)
+{ 
+    head = tail = new Node(dispositivo);
+}
+
+void LinkedList::insert(Dispositivo& dispositivo)
+{
+    Node* newNode = new Node(dispositivo);
+    if(isEmpty())
+    {
+        head = tail = newNode;
+        return;
+    }
+
+    //Trova il punto di inserimento
+    Node* current = head;
+    while(current && current->disp->getOrarioAccensione() <= dispositivo.getOrarioAccensione())
+    {
+        current = current->next;
+    }
+
+    if(current == head)      //significa che lo aggiungo all'inizio di tutti, quindi prima di head
+    {
+        newNode->next = head;
+        head->prev = newNode;
+        head = newNode;
+    }
+    else if(current == nullptr)  //significa che lo aggiungo alla fine di tutti, quindi dopo tail
+    {
+        tail->next = newNode;
+        newNode->prev = tail;
+        tail = newNode;
+    }
+    else
+    {
+        connectBefore(current, newNode);
+    }
+}
+
+Dispositivo* LinkedList::removeDispositivo(const string nome)
+{
+    if(isEmpty())
+    {
+        throw ListaVuotaException();
+    }
+
+    Node* current = searchDispositivo(nome);
+
+    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;
+    }
+}
+
+vector<Dispositivo*> LinkedList::removeAllDispositiviOff(const int currentTime)
+{
+    if(isEmpty())
+    {
+        throw ListaVuotaException();
+    }
+
+    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;
+        }
+    }
+
+    return dispositiviSpenti;
+}
+
+
+void LinkedList::removeTimer(const string nome)
+{
+    if(isEmpty())
+    {
+        throw ListaVuotaException();
+    }
+
+    Node* current = searchDispositivo(nome);
+
+    current->disp->setTimerOff();
+}
+
+void LinkedList::removeAllTimers()
+{
+    if(isEmpty())
+    {
+        throw ListaVuotaException();
+    }
+
+    Node* current = head;
+    while(current)
+    {
+        current->disp->setTimerOff();
+        current = current->next;
+    }
+}
+
+bool LinkedList::isEmpty() const
+{
+    return (head == nullptr);
+}
+
+ostream& operator<<(ostream& os, const LinkedList& list)
+{
+    if(list.isEmpty())
+    {
+        os << "Linked List is Empty!";
+    }
+    else 
+    {
+        LinkedList::Node* iteratorList = list.head;
+        while(iteratorList != nullptr)
+        {
+            os << iteratorList->disp->getNome() << " ";
+            iteratorList = iteratorList->next;
+        }
+
+    }
+
+    return os;
+}
+
+void LinkedList::connectBefore(Node* p, Node* q)
+{
+    p->prev->next = q;
+    q->prev = p->prev;
+
+    q->next = p;
+    p->prev = q;
+}
+
+LinkedList::Node* LinkedList::searchDispositivo(const std::string nome) const
+{
+    if(isEmpty())
+    {
+        throw ListaVuotaException();
+    }
+
+    Node* current = head;
+    while(current && current->disp->getNome() != nome)
+    {
+        current = current->next;
+    }
+
+    if(current == nullptr)
+    {
+        throw DispositivoNonTrovatoException();
+    }
+
+    return current;
+}
+
+
+LinkedList::~LinkedList()
+{
+    Node* current = head;
+    while(current)
+    {
+        Node* temp = current;
+        current = current->next;
+        delete temp;
+    }
+}

src/mainNode.cpp

@@ -0,0 +1,49 @@
+//Alberto Bortoletto
+#include "../include/LinkedList.h"
+#include <iostream>
+
+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;
+    
+    
+}