AlarmData.h

Go to the documentation of this file.

#pragma once
 
#pragma region INCLUSIONS
// Classe per sfruttare la sincronizzazione online dell'ora corrente per il corretto funzionamento della sveglia
/*
Classe di autori 'Grandieri Andrea', 'Barsotti Mirko', 'Erba Lorenzo' per la sincronizzazione online dell'ora corrente.
Verr� utilizzata anche per il corretto funzionamento della sveglia.
*/
#include "Clock.h"
#pragma endregion INCLUSIONS
 
// Namespace di protezione dalle inclusioni multiple con nominazione uguale
/*
I valori constexpr, come spiegato appena sopra, equivalgono alla direttiva '#define'. Questo pu� creare problemi nel momento in cui un singolo file viene incluso
in una gerarchia di molti pi� file, dove si potrebbe riscontrare la presenza di constexpr appartenenti a file diversi ma con gli stessi nomi! Questa ripetitivit� dei nomi deriva
dagli standard di nominazione. Per evitare, quindi, conflitti di multipla definizione, andremo ad utilizzare un 'namespace', che, come dice il nome, fornisce uno SPAZIO per i NOMI del nostro
file in cui il 'namespace' � stato dichiarato ed implementato.
Mantieniamo comunque la specificazione 'static', per evitare errori di linker in caso di inclusioni multiple di questa unit� di traslazione [file].
*/
namespace AlarmData__file
{
    // Espressione costante (equivalente della direttiva '#define') per la definizione del valore '_initvalue'.
    // Questo valore rappresenta il valore assegnato agli attributi 'm_Hour', 'm_Minute' durante la fase di costruzione
    // attraverso il costruttore di default.
    // All'attributo 'm_State' verr� assegnato il valore booleano default 'false'.
    static constexpr auto _initvalue = 0;
 
    // Espressione costante rappresentante il valore massimo che pu� essere attribuito all'attributo 'm_Hour' della classe "AlarmData" --> _24HOURS
    static constexpr auto _24HOURS_hourlimiter = 23;
    // Espressione costante rappresentante il valore massimo che pu� essere attribuito all'attributo 'm_Hour' della classe "AlarmData" --> _12HOURS
    static constexpr auto _12HOURS_hourlimiter = 12;
 
    // Espressione costante rappresentante il valore massimo che pu� essere attribuito all'attributo 'm_Minute' della classe "AlarmData" --> _12HOURS / _24HOURS
    static constexpr auto _minutelimiter = 59;
 
    // Valore costante per la formattazione "elegante" del formato --> 12h
    static constexpr auto _ElegantAdj /*Adjustment*/ = 10;
 
    // Espressione costante rappresentante un valore di controllo per l'accettazione della stringa nel metodo 'set_SliderValue' della classe "Slider"
    static constexpr auto _length_short = 5;
 
    // Espressione costante rappresentante un valore di controllo per l'accettazione della stringa nel metodo 'set_SliderValue' della classe "Slider"
    static constexpr auto _length_long = 7;
 
    // Espressione costante rappresentante un valore di controllo per l'accettazione della stringa nel metodo 'set_SliderValue' della classe "Slider"
    static constexpr auto _characteratpositiontwo = ':';
 
    // Valore costante che viene ritornato in caso di invalidità riscontrata nell'oggetto durante il dereferenziamento
    // per la chiamata dei metodi.
    // Il valore invalido utilizzato è un valore impossibile, cioè che non potrebbe essere mai restituito naturalmente.+
    static constexpr int _invalidvalue = -1;
}
 
class AlarmData
{
    /*Enumerazioni*/
    /*
    Una enumerazione permette una gestione pi� intelligente degli "switcher" forniti all'utente finale.
    Tramite nomi significativi, si gestiscono gli "switcher" appunto con dei nomi, utilizzati per mascherare i valori di enumerazione meno significativi per l'utente.
    Anche qua si applica la staticit� descritta successivamente. Una classe di enumarazione � automaticamente statica.
    */
public:
    enum class AlarmState
    {
        ONLINE, 
        OFFLINE
    };
 
    /*Attributi*/
private:
    // Variabile per contenere l'ora impostata per il trigger della sveglia formato --> 'hh'
    /*
    Questa variabile conterr� il valore dell'ora impostata per il trigger della sveglia.
    Conterr� l'informazione riguardante solamente l'ORA 'h'. 
    Il tipo della variabile � 'unsigned int' perch� non avrebbe senso ammettere anche valori negativi, non essendo possibili.
    */
    unsigned int m_Hour;
 
    // Variabile per contenere l'ora impostata per il trigger della sveglia formato --> 'mm'
    /*
    Questa variabile conterr� il valore dell'ora impostata per il trigger della sveglia.
    Conterr� l'informazioni rigurdante solamente i MINUTI 'm'.
    Il tipo della variabile � 'unsigned int' perch� non avrebbe senso ammettere anche valori negativi, non essendo possibili.
    */
    unsigned int m_Minute;
 
    // Variabile per contenere il periodo dell'ora (solo per 12h)
    Clock::TimePeriod m_Period;
 
    // Variabile per contenere il formato dell'ora (dal punto di vista della medesima classe AlarmData
    Clock::TimeFormat m_Format;
 
    // Variabile per segnalare lo stato della sveglia
    AlarmState m_State;
 
    /*Costruttori e Distruttori*/
public:
    // Costruttore default
    /*
    Il costruttore di default di questa classe inizializza un oggetto di classe "AlarmData" che rappresenta una sveglia.
    Inizialmente i valori degli attributi sono impostati al valore della constexpr '_initvalue'.
    Possono esistere contemporaneamente pi� istanze di questa classe, ognuna rappresentante una sveglia diversa.
    Nonostante ci�, bisogna prestare attenzione alla concorrenza di chiamata per i metodi della classe "Clock"
    */
    AlarmData();
 
    // Distruttore
    /*
    Il distruttore di questa classe semplicemente dealloca l'oggetto interessato. Questo provocher� la perdita di tutte le informazioni annesse.
    Per sicurezza, prima dell'effettiva deallocazione, la sveglia viene impostata su stato 'false'. Durante questa fase non potr� pi� entrare in fase di trigger.
    */
    ~AlarmData();
 
    /*Value Setters*/
public:
    // Permette l'impostazione dell'ora per il trigger della sveglia
    // set_Time (1)
    bool set_Time(const unsigned int& t_Hour, const unsigned int& t_Minute, const Clock::TimePeriod& t_Period = Clock::TimePeriod::NOT_USED);
 
    //set_Time (2)
    bool set_Time(const String& t_Value, const Clock::TimePeriod& t_Period = Clock::TimePeriod::NOT_USED);
 
    // Permette l'impostazione dello stato della sveglia
    /*
    Questo metodo permette di impostare lo stato della sveglia tramite il valore dell'attributo 'm_State'.
    Questo metodo restituisce un valore booleano per indicare se il valore fornito come parametro 't_State' ha provocato o meno un cambiamento nel valore
    precedente di 'm_State'. Quindi, si avr� in ritorno il valore 'false' se il 't_State' risulter� uguale a 'm_State'.
    */
    bool set_State(const AlarmState& t_State);
 
    /*Metodi*/
public:
    // Restituisce, in tipo 'String' [stringa], l'ora impostata per il trigger della sveglia
    String get_SetTime();
 
    // Controlla se la sveglia � in trigger oppure no al momento della chiamata del medesimo metodo
    /*
    Questo metodo informa se la sveglia � in trigger oppure no al momento della sua chiamata.
    Questo significa che questo metodo NON esegue alcuna operazione di effettivo trigger della sveglia, ma informa se c'� nel momento della chiamata.
    In questo modo, nel caso la sveglia sia in trigger, si potr� procedere con l'implementazione (manuale, dell'utente) delle operazioni desiderate da e
    eseguire.
    Restituisce:
    - 'true' --> sveglia in trigger nel momento della chiamata
    - 'false' --> sveglia non in trigger nel momento della chiamata
    */
    bool Check();
 
    // Aggiorna il formato dell'ora dal punto di vista di AlarmData
    bool UpdateFormat();
 
    /*Invalidator*/
    /*
    L'invalidatore consiste in quel valore che viene ritornato ogni qualvolta una chiamata da parte dell'utente ai metodi non produce il risultato atteso.
    E' importante specificare che, l'invalidatore, pur essendo costante, non deve essere dichiarato come 'constexpr' perchè NON deve seguire le regole di
    comportamento della direttiva '#define'. Il compilatore NON deve sostituire il nome dell'attributo con un valore numerico costante --> i.e. RVALUE!!
    L'invalidatore deve essere un vero e proprio attributo della classe, che però non deve mai appartenere ad uno specifico oggetto. Per questo deve essere sempre
    specificato come statico. Ovviamente, avrà una locazione nel Data Segment, sarà quindi globale ma statico (valido sono in questa unità di traslazione (file)) e utilizzabile
    solamente nell'ambito della classe di dichiarazione.
    */
    /*Attributo*/
private:
    // Valore costante che viene ritornato in caso di invalidità riscontrata nell'oggetto durante il dereferenziamento
    // per la chiamata dei metodi.
    // Il valore invalido utilizzato è un valore impossibile, cioè che non potrebbe essere mai restituito naturalmente.
    static const int m_CoreInvalidator;
 
    /*getter*/
public:
    // Metodo per il ritorno del valore dell'Invalidatore. Verrà ritornata una referenza [reference --> '&'] costante, in modo tale da ottimizzare il processo e,
    // allo stesso tempo evitare modifiche inappropriate.
    /*
    Un'altra particolarità di questo metodo sta nel fatto che è definita come 'inline'. Questa keyword comunica al compilatore, ovunque trovi una chiamata
    a questo metodo, di NON effettuare una vera e propria chiamata, ma di sostituire la porzione del codice per la chiamata con il BODY del metodo (la implementazione stessa).
    Questa tecnica risulta molto utile per funzioni che effettuano pochissime operazioni e sono sottoposte a frequenti chiamate.
    Anche qua, per via della staticità, viene applicata la gestione analizzata prima.
    */
    /*L'invalidatore del CORE (questa unità di traslazione [file]) prende il nome di 'CoreInvalidator' (i.e. 'invalidatore del nucleo').
    Questo è reso necessario per l'identificazione della differenza tra invalidatore del WRAPPER e invalidatore del CORE.
    Come riportato nel brief del WRAPPER, l'unico invalidatore al quale l'utente deve aver accesso è quello del WRAPPER 'Invalidator'.
    L'invalidatore del CORE 'CoreInvalidator' è necessario solamente per la gestione dell'invalidatore del WRAPPER 'Invalidator' che dipende in parte (non in ogni caso, ma solo in alcuni)
    dall'invalidatore del CORE 'CoreInvalidator'. L'invalidatore del CORE non deve essere disponibile all'utente.*/
    static inline const int& get_CoreInvalidator();
};
 
// Dichiarazione delle variabili GLOBALI STATICHE 
// Risiederanno nel Data Segment
const int AlarmData::m_CoreInvalidator = AlarmData__file::_invalidvalue;