Clock.cpp

Go to the documentation of this file.

 
// Inclusione <automatica> dell'header che si sta implementando
#include "Clock.h"
 
// Implementazione del metodo 'Init' della categoria 'Init'
// Init (1) --> default
bool Clock::Init()
{
    // Se esiste, dealloco istanza corrente per 'm_NTPEntryPoint'
    if (m_NTPEntryPoint)
    {
        // Deallocazione
        // Arresta l'interrogazione del Time Server
        StopService();
        delete m_NTPEntryPoint;
 
        // Sanificazione manuale
        m_NTPEntryPoint = nullptr;
    }
 
    // Se esiste, dealloco istanza corrente per 'm_UDPProtocol'
    if (m_UDPProtocol)
    {
        // Deallocazione
        delete m_UDPProtocol;
 
        // Sanificazione manuale
        m_UDPProtocol = nullptr;
    }
 
    // Assegnazione constexpr agli attributi della classe (valori di default)
    m_PoolingZone = Clock__file::_PoolingZone;
    m_TimeOffset = Clock__file::_TimeOffset;
    m_UpdateInterval = Clock__file::_UpdateInterval;
    m_TimeFormat = TimeFormat::_24HOURS;
    m_Period = TimePeriod::NOT_USED;
 
    // Costruzione dell'oggetto di classe "WiFiUDP" con il rispettivo costruttore di default
    m_UDPProtocol = new WiFiUDP();
 
    // Costruzione dell'oggetto di classe "NTPClient" con il rispettivo costruttore parametrico
    // Verranno utilizzati i valori degli attributi 'm_UDPProtocol', 'm_PoolingZone', 'm_TimeOffset', 'm_UpdateInterval'
    m_NTPEntryPoint = new NTPClient(*m_UDPProtocol, m_PoolingZone, m_TimeOffset, m_UpdateInterval);
 
    // Dopo l'allocazione, controllo che effettivamente è andata a buon fine. Un puntatore nullo (i.e. 'nullptr') sarebbe indice di errori durante l'allocazione.
    if (m_UDPProtocol && m_NTPEntryPoint)
        // Inizia l'interrogazione del Time Server
        // L'interrogazione ha inizio solamente se presente una connessione ad Internet. In caso affermativo, la funzione 'StartService' ritornerà un valore booleano 'true'.
        // In caso negativo, un valore booleano 'false'.
        return StartService();
 
    return false;
}
 
// Implementazione del metodo 'Init' della categoria 'Init'
// Init (2) --> parametrico
bool Clock::Init(const TimeFormat& t_TimeFormat)
{
    // Se esiste, dealloco istanza corrente per 'm_NTPEntryPoint'
    if (m_NTPEntryPoint)
    {
        // Deallocazione
        // Arresta l'interrogazione del Time Server
        StopService();
        delete m_NTPEntryPoint;
 
        // Sanificazione manuale
        m_NTPEntryPoint = nullptr;
    }
 
    // Se esiste, dealloco istanza corrente per 'm_UDPProtocol'
    if (m_UDPProtocol)
    {
        // Deallocazione
        delete m_UDPProtocol;
 
        // Sanificazione manuale
        m_UDPProtocol = nullptr;
    }
 
    // Assegnazione constexpr agli attributi della classe (valori di default)
    m_PoolingZone = Clock__file::_PoolingZone;
    m_TimeOffset = Clock__file::_TimeOffset;
    m_UpdateInterval = Clock__file::_UpdateInterval;
    m_Period = TimePeriod::NOT_USED;
 
    // Assegnazione parametro 't_TimeFormat' all'attributo 'm_TimeFormat'
    m_TimeFormat = t_TimeFormat;
 
    // Costruzione dell'oggetto di classe "WiFiUDP" con il rispettivo costruttore di default
    m_UDPProtocol = new WiFiUDP();
 
    // Costruzione dell'oggetto di classe "NTPClient" con il rispettivo costruttore parametrico
    // Verranno utilizzati i valori degli attributi 'm_UDPProtocol', 'm_PoolingZone', 'm_TimeOffset', 'm_UpdateInterval'
    m_NTPEntryPoint = new NTPClient(*m_UDPProtocol, m_PoolingZone, m_TimeOffset, m_UpdateInterval);
 
    // Dopo l'allocazione, controllo che effettivamente è andata a buon fine. Un puntatore nullo (i.e. 'nullptr') sarebbe indice di errori durante l'allocazione.
    if (m_UDPProtocol && m_NTPEntryPoint)
        // Inizia l'interrogazione del Time Server
        // L'interrogazione ha inizio solamente se presente una connessione ad Internet. In caso affermativo, la funzione 'StartService' ritornerà un valore booleano 'true'.
        // In caso negativo, un valore booleano 'false'.
        return StartService();
 
    return false;
}
 
// Implementazione del metodo 'Init' della categoria 'Init'
// Init (3) --> parametrico
bool Clock::Init(WiFiUDP* t_UDPProtocol, const char* t_PoolingZone, const int& t_TimeOffset, const int& t_UpdateInterval, const TimeFormat& t_TimeFormat)
{
    // Se esiste, dealloco istanza corrente per 'm_NTPEntryPoint'
    if (m_NTPEntryPoint)
    {
        // Deallocazione
        // Arresta l'interrogazione del Time Server
        StopService();
        delete m_NTPEntryPoint;
 
        // Sanificazione manuale
        m_NTPEntryPoint = nullptr;
    }
 
    // Se esiste, dealloco istanza corrente per 'm_UDPProtocol'
    if (m_UDPProtocol)
    {
        // Deallocazione
        delete m_UDPProtocol;
 
        // Sanificazione manuale
        m_UDPProtocol = nullptr;
    }
 
    // Assegnazione parametri agli attributi della classe
    m_UDPProtocol = t_UDPProtocol;  /*si suppone oggetto già allocato. Controllo alla fine. Valore booleano in risposta.*/
    m_PoolingZone = t_PoolingZone;
    m_TimeOffset = t_TimeOffset;
    m_UpdateInterval = t_UpdateInterval;
    m_TimeFormat = t_TimeFormat;
 
    // Assegnazione constexpr '_TimePeriod' all'attributo 'm_Period' della classe (valore di default)
    m_Period = TimePeriod::NOT_USED;
 
    // Costruzione dell'oggetto di classe "NTPClient" con il rispettivo costruttore parametrico
    // Verranno utilizzati i valori degli attributi 'm_UDPProtocol', 'm_PoolingZone', 'm_TimeOffset', 'm_UpdateInterval'
    m_NTPEntryPoint = new NTPClient(*m_UDPProtocol, m_PoolingZone, m_TimeOffset, m_UpdateInterval);
 
    // Dopo l'allocazione, controllo che effettivamente è andata a buon fine. Un puntatore nullo (i.e. 'nullptr') sarebbe indice di errori durante l'allocazione.
    if (m_UDPProtocol && m_NTPEntryPoint)
        // Inizia l'interrogazione del Time Server
        // L'interrogazione ha inizio solamente se presente una connessione ad Internet. In caso affermativo, la funzione 'StartService' ritornerà un valore booleano 'true'.
        // In caso negativo, un valore booleano 'false'.
        return StartService();
 
    return false;
}
 
// Implementazione del metodo 'StartService' della categoria 'Service management'
bool Clock::StartService()
{
    // Controllo se è presente una connessione ad Internet
    // Per effettuare questa operazione, utilizzo l'oggetto già istanziato nella definizione della libreria "ESP8266WiFi"
    // Utilizzo il metodo "status" sempre della stessa classe ed effettuo il confronto con il valore intero rappresentato dal campo 'WL_CONNECTED' dell'enumerazione appartenente
    // sempre alla medesima classe.
    if (WiFi.status() == WL_CONNECTED && m_NTPEntryPoint)
    {
        // In caso affermativo, supponendo l'oggetto 'm_NTPEntryPoint' già allocato, avvio l'interrogazione del Time Server.
        m_NTPEntryPoint->begin();
        return true;
    }
 
    // In caso negativo, non eseguo nessuna azione. L'interrogazione del Time Server non avrà inizio.
    return false;
}
 
// Implementazione del metodo 'StopService' della categoria 'Service management'
bool Clock::StopService()
{
    // Supponendo l'oggetto 'm_NTPEntryPoint' già allocato, arresto l'interrogazione del Time Server.
    // Non importa se l'interrogazione è effettivamente in corso oppure no.
    if (m_NTPEntryPoint)
    {
        m_NTPEntryPoint->end();
        return true;
    }
    else
        return false;
}
 
// Implementazione del metodo 'get_UDPProtocol' della categoria 'LowLevel getters'
WiFiUDP* const Clock::get_UDPProtocol()
{
    // Ritorno l'attributo 'm_UDPProtocol' perchè rappresenta già un puntatore
    return m_UDPProtocol;
}
 
// Implementazione del metodo 'm_NTPEntryPoint' della categoria 'LowLevel getters'
NTPClient* const Clock::get_NTPEntryPoint()
{
    // Ritorno l'attributo 'm_NTPEntryPoint' perchè rappresenta già un puntatore
    return m_NTPEntryPoint;
}
 
// Implementazione del metodo 'get_PoolingZone' della categoria 'LowLevel getters'
const char* const Clock::get_PoolingZone()
{
    // Ritorno l'indirizzo di memoria dell'attributo 'm_PoolingZone'
    // Calcolo dell'indirizzo attraverso utilizzo dell'operatore '&'
    return m_PoolingZone;
}
 
// Implementazione del metodo 'get_TimeOffset' della categoria 'LowLevel getters'
int* const Clock::get_TimeOffset()
{
    // Ritorno l'indirizzo di memoria dell'attributo 'm_TimeOffset'
    // Calcolo dell'indirizzo attraverso utilizzo dell'operatore '&'
    return &m_TimeOffset;
}
 
// Implementazione del metodo 'get_UpdateInterval' della categoria 'LowLevel getters'
int* const Clock::get_UpdateInterval()
{
    // Ritorno l'indirizzo di memoria dell'attributo 'm_TimeOffset'
    // Calcolo dell'indirizzo attraverso utilizzo dell'operatore '&'
    return &m_UpdateInterval;
}
 
// Implementazione del metodo 'get_TimeFormat' della categoria 'LowLevel getters'
Clock::TimeFormat* const Clock::get_TimeFormat()
{
    // Ritorno l'indirizzo di memoria dell'attributo 'm_TimeFormat'
    // Calcolo dell'indirizzo attraverso utilizzo dell'operatore '&'
    return &m_TimeFormat;
}
 
// Implementazione del metodo 'get_TimePeriod' della categoria 'LowLevel getters'
Clock::TimePeriod* const Clock::get_TimePeriod()
{
    // Ritorno l'indirizzo di memoria dell'attributo 'm_TimePeriod'
    // Calcolo dell'indirizzo attraverso l'utilizzo dell'operatore '&'
    return &m_Period;
}
 
// Implementazione del metodo 'ReInit' della categoria 'LowLevel reallocator'
bool Clock::ReInit()
{
    // Se esiste, dealloco istanza corrente per 'm_NTPEntryPoint'
    if (m_NTPEntryPoint)
    {
        // Deallocazione
        // Arresta l'interrogazione del Time Server
        StopService();
        delete m_NTPEntryPoint;
 
        // Sanificazione manuale
        m_NTPEntryPoint = nullptr;
    }
 
    // Se esiste, dealloco istanza corrente per 'm_UDPProtocol'
    if (m_UDPProtocol)
    {
        // Deallocazione
        delete m_UDPProtocol;
 
        // Sanificazione manuale
        m_UDPProtocol = nullptr;
    }
 
    // Non effettua alcuna modifica sugli attributi
 
    // Costruzione dell'oggetto di classe "WiFiUDP" con il rispettivo costruttore di default
    m_UDPProtocol = new WiFiUDP();
 
    // Costruzione dell'oggetto di classe "NTPClient" con il rispettivo costruttore parametrico
    // Verranno utilizzati i valori degli attributi 'm_UDPProtocol', 'm_PoolingZone', 'm_TimeOffset', 'm_UpdateInterval'
    m_NTPEntryPoint = new NTPClient(*m_UDPProtocol, m_PoolingZone, m_TimeOffset, m_UpdateInterval);
 
    // Dopo l'allocazione, controllo che effettivamente è andata a buon fine. Un puntatore nullo (i.e. 'nullptr') sarebbe indice di errori durante l'allocazione.
    if (m_UDPProtocol && m_NTPEntryPoint)
        // Inizia l'interrogazione del Time Server
        // L'interrogazione ha inizio solamente se presente una connessione ad Internet. In caso affermativo, la funzione 'StartService' ritornerà un valore booleano 'true'.
        // In caso negativo, un valore booleano 'false'.
        return StartService();
 
    return false;
}
 
// Implementazione del metodo 'set_TimeFormat' della categoria 'Value Setters'
bool Clock::set_TimeFormat(const TimeFormat& t_TimeFormat)
{
    // Prima di procedere, controllo che l'inizializzazione della classe sia già stata eseguita 
    // Se così non fosse, il valore di 'm_TimeFormat' sarebbe un valore indeterminato, causando risultati indefiniti durante il confronto.
    // La presenza di riferimenti validi negli attributi 'm_UDPProtocol' e 'm_NTPEntryPoint' è segno di una inizializzazione già effettuata e correttamente completata
    if (m_UDPProtocol && m_NTPEntryPoint)
    {
        // Prima dell'assegnamento, effettuo un controllo per verificare la effettiva necessità dell'assegnamento
        if (t_TimeFormat == m_TimeFormat)
            // Operazione di assegnamento non necessaria
            return false;
 
        // Operazione di assegnamento necessaria
        m_TimeFormat = t_TimeFormat;
 
        return true;
    }
    else
        return false;
}
 
// Implementazione del metodo 'get_Day' della categoria 'Metodi'
int Clock::get_Day()
{
    // Ritorno il valore che ottengo attraverso la chiamata della funzione 'getDay' 
    // della libreria "NTPClient"
    /*Ausilio dell'operatore '->' per dereferenziamento "nascosto"*/
 
    // Prima di ritornare il valore, lo AGGIORNO attraveso la funzione "update" della libreria "NTPClient"
    // Questo perchè, una volta avviata l'interrogazione del Time Server, la richiesta dei valori avviene ogni 'm_UpdateInterval' millisecondi. 
    // Con i nostri dati di inizializzazione avviene ogni 60 secondi. Richiamando, invece, manualmente il metodo "update", forzo un aggiornamento dei valori.
 
    // Prima di richiamare il corrispettivo metodo della classe "NTPClient", controllo che l'oggetto di classe "NTPClient"
    // sia stato già allocato. Una chiamata su un oggetto non allocato (i.e. 'nullptr') causerebbe una eccezione con 
    // conseguente fail della memoria.
    // Il funzionamento dell'oggetto di classe di classe "NTPClient" dipende anche dall'oggetto di classe "WiFiUDP".
    // Per questo motivo, effettuo un controllo anche su quello.
    // Infine, effettuo anche un controllo sulla connessione. Chiamo i metodi solo se sono connesso ad Internet, questo perchè essi richiedono
    // una connessione per funzionare correttamente.
    if (m_UDPProtocol && m_NTPEntryPoint && WiFi.status() == WL_CONNECTED)
    {
        m_NTPEntryPoint->update();
        return m_NTPEntryPoint->getDay();
    }
    else
        return m_Invalidator;
}
 
// Implementazione del metodo 'get_Hours' della categoria 'Metodi'
int Clock::get_Hours()
{
    // Ritorno il valore che ottengo attraverso la chiamata della funzione 'getHours' 
    // della libreria "NTPClient"
    /*Ausilio dell'operatore '->' per dereferenziamento "nascosto"*/
 
    // Prima di ritornare il valore, lo AGGIORNO attraveso la funzione "update" della libreria "NTPClient"
    // Questo perchè, una volta avviata l'interrogazione del Time Server, la richiesta dei valori avviene ogni 'm_UpdateInterval' millisecondi. 
    // Con i nostri dati di inizializzazione avviene ogni 60 secondi. Richiamando, invece, manualmente il metodo "update", forzo un aggiornamento dei valori.
 
    // Prima di richiamare il corrispettivo metodo della classe "NTPClient", controllo che l'oggetto di classe "NTPClient"
    // sia stato già allocato. Una chiamata su un oggetto non allocato (i.e. 'nullptr') causerebbe una eccezione con 
    // conseguente fail della memoria.
    // Il funzionamento dell'oggetto di classe di classe "NTPClient" dipende anche dall'oggetto di classe "WiFiUDP".
    // Per questo motivo, effettuo un controllo anche su quello.
    // Infine, effettuo anche un controllo sulla connessione. Chiamo i metodi solo se sono connesso ad Internet, questo perchè essi richiedono
    // una connessione per funzionare correttamente.
    if (m_UDPProtocol && m_NTPEntryPoint && WiFi.status() == WL_CONNECTED)
    {
        // Prima di effettuare l'aggiornamamento e ritornare il corrispettivo valore, controllo il valore dell'attributo 'm_TimeFormat'
        // per determinare il formato dell'ora [12h/24h]
        switch (m_TimeFormat)
        {
        case Clock::TimeFormat::_12HOURS:
            // Formato 12h
        {
            m_NTPEntryPoint->update();
            auto l_Supporter = m_NTPEntryPoint->getHours();
 
            if (l_Supporter > Clock__file::_Period)
            {
                // Imposta PM
                m_Period = TimePeriod::PM;
                return (l_Supporter - Clock__file::_Period);
            }
            else /*<=*/
            {
                // Imposta AM
                m_Period = TimePeriod::AM;
                return l_Supporter;
            }
            break;
        }
        case Clock::TimeFormat::_24HOURS:
            // Formato 24h
            // Imposto NOT_USED
            m_Period = TimePeriod::NOT_USED;
 
            m_NTPEntryPoint->update();
            return m_NTPEntryPoint->getHours();
            break;
        }
    }
    else
        return m_Invalidator;
}
 
// Implementazione del metodo 'get_Minutes' della categoria 'Metodi'
int Clock::get_Minutes()
{
    // Ritorno il valore che ottengo attraverso la chiamata della funzione 'getMinutes' 
    // della libreria "NTPClient"
    /*Ausilio dell'operatore '->' per dereferenziamento "nascosto"*/
 
    // Prima di ritornare il valore, lo AGGIORNO attraveso la funzione "update" della libreria "NTPClient"
    // Questo perchè, una volta avviata l'interrogazione del Time Server, la richiesta dei valori avviene ogni 'm_UpdateInterval' millisecondi. 
    // Con i nostri dati di inizializzazione avviene ogni 60 secondi. Richiamando, invece, manualmente il metodo "update", forzo un aggiornamento dei valori.
 
    // Prima di richiamare il corrispettivo metodo della classe "NTPClient", controllo che l'oggetto di classe "NTPClient"
    // sia stato già allocato. Una chiamata su un oggetto non allocato (i.e. 'nullptr') causerebbe una eccezione con 
    // conseguente fail della memoria.
    // Il funzionamento dell'oggetto di classe di classe "NTPClient" dipende anche dall'oggetto di classe "WiFiUDP".
    // Per questo motivo, effettuo un controllo anche su quello.
    // Infine, effettuo anche un controllo sulla connessione. Chiamo i metodi solo se sono connesso ad Internet, questo perchè essi richiedono
    // una connessione per funzionare correttamente.
    if (m_UDPProtocol && m_NTPEntryPoint && WiFi.status() == WL_CONNECTED)
    {
        m_NTPEntryPoint->update();
        return m_NTPEntryPoint->getMinutes();
    }
    else
        return m_Invalidator;
}
 
// Implementazione del metodo 'get_Seconds' della categoria 'Metodi'
int Clock::get_Seconds()
{
    // Ritorno il valore che ottengo attraverso la chiamata della funzione 'getSeconds' 
    // della libreria "NTPClient"
    /*Ausilio dell'operatore '->' per dereferenziamento "nascosto"*/
 
    // Prima di ritornare il valore, lo AGGIORNO attraveso la funzione "update" della libreria "NTPClient"
    // Questo perchè, una volta avviata l'interrogazione del Time Server, la richiesta dei valori avviene ogni 'm_UpdateInterval' millisecondi. 
    // Con i nostri dati di inizializzazione avviene ogni 60 secondi. Richiamando, invece, manualmente il metodo "update", forzo un aggiornamento dei valori.
 
    // Prima di richiamare il corrispettivo metodo della classe "NTPClient", controllo che l'oggetto di classe "NTPClient"
    // sia stato già allocato. Una chiamata su un oggetto non allocato (i.e. 'nullptr') causerebbe una eccezione con 
    // conseguente fail della memoria.
    // Il funzionamento dell'oggetto di classe di classe "NTPClient" dipende anche dall'oggetto di classe "WiFiUDP".
    // Per questo motivo, effettuo un controllo anche su quello.
    // Infine, effettuo anche un controllo sulla connessione. Chiamo i metodi solo se sono connesso ad Internet, questo perchè essi richiedono
    // una connessione per funzionare correttamente.
    if (m_UDPProtocol && m_NTPEntryPoint && WiFi.status() == WL_CONNECTED)
    {
        m_NTPEntryPoint->update();
        return m_NTPEntryPoint->getSeconds();
    }
    else
        return m_Invalidator;
}
 
// Implementazione del metodo 'get_CurrentFormattedTime' della categoria 'Metodi'
String Clock::get_CurrentFormattedTime()
{
    // Ritorno il valore che ottengo attraverso la chiamata della funzione 'getFormattedTime' 
    // della libreria "NTPClient"
    /*Ausilio dell'operatore '->' per dereferenziamento "nascosto"*/
 
    // Prima di ritornare il valore, lo AGGIORNO attraveso la funzione "update" della libreria "NTPClient"
    // Questo perchè, una volta avviata l'interrogazione del Time Server, la richiesta dei valori avviene ogni 'm_UpdateInterval' millisecondi. 
    // Con i nostri dati di inizializzazione avviene ogni 60 secondi. Richiamando, invece, manualmente il metodo "update", forzo un aggiornamento dei valori.
 
    // Prima di richiamare il corrispettivo metodo della classe "NTPClient", controllo che l'oggetto di classe "NTPClient"
    // sia stato già allocato. Una chiamata su un oggetto non allocato (i.e. 'nullptr') causerebbe una eccezione con 
    // conseguente fail della memoria.
    // Il funzionamento dell'oggetto di classe di classe "NTPClient" dipende anche dall'oggetto di classe "WiFiUDP".
    // Per questo motivo, effettuo un controllo anche su quello.
    // Infine, effettuo anche un controllo sulla connessione. Chiamo i metodi solo se sono connesso ad Internet, questo perchè essi richiedono
    // una connessione per funzionare correttamente.
 
    if (m_UDPProtocol && m_NTPEntryPoint && WiFi.status() == WL_CONNECTED)
    {
        // Prima di effettuare l'aggiornamamento e ritornare il corrispettivo valore, controllo il valore dell'attributo 'm_TimeFormat'
        // per determinare il formato dell'ora [12h/24h]
        switch (m_TimeFormat)
        {
        case Clock::TimeFormat::_12HOURS:
        {
            // Formato 12h
            // Creo una variabile locale allo STACK FRAME di questo metodo <-- [reference '&'] non disponibile in ritorno
            // Questa variabile verrà utilizzata per la formattazione dell'ora corrente nel formato 'hh:mm:ss'.
            // La conversione restituirà un tipo 'String' [stringa]
            String l_Time = "";
 
            m_NTPEntryPoint->update();
 
            // Ottengo il valore 'hh'
            // Creo una variabile locale allo STACK FRAME di questo metodo non destinata ad essere utilizzata come valore di ritorno.
            // Questa variabile verrà utilizzata per contenere il valore dell'ora corrente formato 'hh' per effettuare i controlli sul periodo delle 12h.
            auto l_Supporter = m_NTPEntryPoint->getHours();
            if (l_Supporter > Clock__file::_Period)
            {
                // Imposta PM
                m_Period = TimePeriod::PM;
 
                // 'Elegant Adjustment' "Regolazione Elegante" della stringa in ritorno per l'ora formattata nel formato --> 12h
                // Aggiunge uno zero '0' inziale per compensare un eventuale mancanza di seconda cifra (per i valori minori di '_ElegantAdj' (i.e. '10'))
                if (l_Supporter - Clock__file::_Period < Clock__file::_ElegantAdj)
                    l_Time = l_Time + "0";
 
                l_Time = l_Time + String((l_Supporter - Clock__file::_Period)) + ":";
            }
            else
            {
                // Imposta AM
                m_Period = TimePeriod::AM;
 
                // 'Elegant Adjustment' "Regolazione Elegante" della stringa in ritorno per l'ora formattata nel formato --> 12h
                // Aggiunge uno zero '0' inziale per compensare un eventuale mancanza di seconda cifra (per i valori minori di '_ElegantAdj' (i.e. '10'))
                if (l_Supporter < Clock__file::_ElegantAdj)
                    l_Time = l_Time + "0";
 
                l_Time = l_Time + String(l_Supporter) + ":";
            }
 
            // Ottengo il valore 'mm'
            // 'Elegant Adjustment' "Regolazione Elegante" della stringa in ritorno per l'ora formattata nel formato --> 12h
            // Aggiunge uno zero '0' inziale per compensare un eventuale mancanza di seconda cifra (per i valori minori di '_ElegantAdj' (i.e. '10'))
            if (get_Minutes() < Clock__file::_ElegantAdj)
                l_Time = l_Time + "0";
 
            l_Time = l_Time + String(get_Minutes()) + ":";
 
            // Ottengo il valore 'ss'
            // 'Elegant Adjustment' "Regolazione Elegante" della stringa in ritorno per l'ora formattata nel formato --> 12h
            // Aggiunge uno zero '0' inziale per compensare un eventuale mancanza di seconda cifra (per i valori minori di '_ElegantAdj' (i.e. '10'))
            if (get_Seconds() < Clock__file::_ElegantAdj)
                l_Time = l_Time + "0";
 
            l_Time = l_Time + String(get_Seconds());
 
            // Aggiungo il periodo
            switch (m_Period)
            {
            case Clock::TimePeriod::NOT_USED:
                break;
            case Clock::TimePeriod::AM:
                // AM
                l_Time = l_Time + "am";
                break;
            case Clock::TimePeriod::PM:
                // PM
                l_Time = l_Time + "pm";
                break;
            }
 
            // Ritorno il risultato finale 'String' [stringa] che ho composto
            return l_Time;
            break;
        }
        case Clock::TimeFormat::_24HOURS:
            // Formato 24h
            // 'Elegant Adjustment' "Regolazione Elegante" automatica effettuata dal metodo 'getFormattedTime' della classe "NTPClient"
            m_NTPEntryPoint->update();
            return m_NTPEntryPoint->getFormattedTime();
            break;
        }
    }
    else
        return String(m_Invalidator);
}
 
// Implementazione del metodo 'get_CurrentFormattedTimeHM' della categoria 'Metodi'
String Clock::get_CurrentFormattedTimeHM()
{
        // Ritorno il valore che ottengo attraverso la chiamata della funzione 'getFormattedTime' 
        // della libreria "NTPClient"
        /*Ausilio dell'operatore '->' per dereferenziamento "nascosto"*/
 
        // Prima di ritornare il valore, lo AGGIORNO attraveso la funzione "update" della libreria "NTPClient"
        // Questo perchè, una volta avviata l'interrogazione del Time Server, la richiesta dei valori avviene ogni 'm_UpdateInterval' millisecondi. 
        // Con i nostri dati di inizializzazione avviene ogni 60 secondi. Richiamando, invece, manualmente il metodo "update", forzo un aggiornamento dei valori.
 
        // Prima di richiamare il corrispettivo metodo della classe "NTPClient", controllo che l'oggetto di classe "NTPClient"
        // sia stato già allocato. Una chiamata su un oggetto non allocato (i.e. 'nullptr') causerebbe una eccezione con 
        // conseguente fail della memoria.
        // Il funzionamento dell'oggetto di classe di classe "NTPClient" dipende anche dall'oggetto di classe "WiFiUDP".
        // Per questo motivo, effettuo un controllo anche su quello.
        // Infine, effettuo anche un controllo sulla connessione. Chiamo i metodi solo se sono connesso ad Internet, questo perchè essi richiedono
        // una connessione per funzionare correttamente.
 
    if (m_UDPProtocol && m_NTPEntryPoint && WiFi.status() == WL_CONNECTED)
    {
        // Prima di effettuare l'aggiornamamento e ritornare il corrispettivo valore, controllo il valore dell'attributo 'm_TimeFormat'
        // per determinare il formato dell'ora [12h/24h]
        switch (m_TimeFormat)
        {
        case Clock::TimeFormat::_12HOURS:
        {
            // Formato 12h
            // Creo una variabile locale allo STACK FRAME di questo metodo <-- [reference '&'] non disponibile in ritorno
            // Questa variabile verrà utilizzata per la formattazione dell'ora corrente nel formato 'hh:mm'.
            // La conversione restituirà un tipo 'String' [stringa]
            String l_Time = "";
 
            m_NTPEntryPoint->update();
 
            // Ottengo il valore 'hh'
            // Creo una variabile locale allo STACK FRAME di questo metodo non destinata ad essere utilizzata come valore di ritorno.
            // Questa variabile verrà utilizzata per contenere il valore dell'ora corrente formato 'hh' per effettuare i controlli sul periodo delle 12h.
            auto l_Supporter = m_NTPEntryPoint->getHours();
            if (l_Supporter > Clock__file::_Period)
            {
                // Imposta PM
                m_Period = TimePeriod::PM;
 
                // 'Elegant Adjustment' "Regolazione Elegante" della stringa in ritorno per l'ora formattata nel formato --> 12h
                // Aggiunge uno zero '0' inziale per compensare un eventuale mancanza di seconda cifra (per i valori minori di '_ElegantAdj' (i.e. '10'))
                if (l_Supporter - Clock__file::_Period < Clock__file::_ElegantAdj)
                    l_Time = l_Time + "0";
 
                l_Time = l_Time + String((l_Supporter - Clock__file::_Period)) + ":";
            }
            else
            {
                // Imposta AM
                m_Period = TimePeriod::AM;
 
                // 'Elegant Adjustment' "Regolazione Elegante" della stringa in ritorno per l'ora formattata nel formato --> 12h
                // Aggiunge uno zero '0' inziale per compensare un eventuale mancanza di seconda cifra (per i valori minori di '_ElegantAdj' (i.e. '10'))
                if (l_Supporter < Clock__file::_ElegantAdj)
                    l_Time = l_Time + "0";
 
                l_Time = l_Time + String(l_Supporter) + ":";
            }
 
            // Ottengo il valore 'mm'
            // 'Elegant Adjustment' "Regolazione Elegante" della stringa in ritorno per l'ora formattata nel formato --> 12h
            // Aggiunge uno zero '0' inziale per compensare un eventuale mancanza di seconda cifra (per i valori minori di '_ElegantAdj' (i.e. '10'))
            if (get_Minutes() < Clock__file::_ElegantAdj)
                l_Time = l_Time + "0";
 
            l_Time = l_Time + String(get_Minutes());
 
            // Aggiungo il periodo
            switch (m_Period)
            {
            case Clock::TimePeriod::NOT_USED:
                break;
            case Clock::TimePeriod::AM:
                // AM
                l_Time = l_Time + "am";
                break;
            case Clock::TimePeriod::PM:
                // PM
                l_Time = l_Time + "pm";
                break;
            }
 
            // Ritorno il risultato finale 'String' [stringa] che ho composto
            return l_Time;
            break;
        }
        case Clock::TimeFormat::_24HOURS:
            // Formato 24h
            // 'Elegant Adjustment' "Regolazione Elegante" automatica effettuata dal metodo 'getFormattedTime' della classe "NTPClient"
            // Non posso utilizzare il metodo 'getFormattedTime' vergine. Necessito di una composizione manuale della stringa per il valore di ritorno nel formato --> 'hh:mm'
 
            // Creo una variabile locale allo STACK FRAME di questo metodo <-- [reference '&'] non disponibile in ritorno
            // Questa variabile verrà utilizzata per la formattazione dell'ora corrente nel formato 'hh:mm'.
            // La conversione restituirà un tipo 'String' [stringa]
            String l_Time = "";
 
            m_NTPEntryPoint->update();
 
            // Ottengo 'hh'
            // Ottengo il valore 'mm'
            // 'Elegant Adjustment' "Regolazione Elegante" della stringa in ritorno per l'ora formattata nel formato --> 12h
            // Aggiunge uno zero '0' inziale per compensare un eventuale mancanza di seconda cifra (per i valori minori di '_ElegantAdj' (i.e. '10'))
            if (m_NTPEntryPoint->getHours() < Clock__file::_ElegantAdj)
                l_Time = l_Time + "0";
 
            l_Time = l_Time + String(m_NTPEntryPoint->getHours()) + ":";
 
            // Ottengo 'mm'
            // Ottengo il valore 'mm'
            // 'Elegant Adjustment' "Regolazione Elegante" della stringa in ritorno per l'ora formattata nel formato --> 12h
            // Aggiunge uno zero '0' inziale per compensare un eventuale mancanza di seconda cifra (per i valori minori di '_ElegantAdj' (i.e. '10'))
            if (get_Minutes() < Clock__file::_ElegantAdj)
                l_Time = l_Time + "0";
 
            l_Time = l_Time + String(get_Minutes());
 
            return l_Time;
            break;
        }
    }
    else
        return String(m_Invalidator);
}
 
// Implementazione del metodo 'get_EpochTime' della categoria 'Metodi'
unsigned long Clock::get_EpochTime()
{
    // Ritorno il valore che ottengo attraverso la chiamata della funzione 'getEpochTime'
    // della libreria "NTPClient"
    /*Ausilio dell'operatore '->' per dereferenziamento "nascosto"*/
 
    // Prima di ritornare il valore, lo AGGIORNO attraveso la funzione "update" della libreria "NTPClient"
    // Questo perchè, una volta avviata l'interrogazione del Time Server, la richiesta dei valori avviene ogni 'm_UpdateInterval' millisecondi. 
    // Con i nostri dati di inizializzazione avviene ogni 60 secondi. Richiamando, invece, manualmente il metodo "update", forzo un aggiornamento dei valori.
 
    // Prima di richiamare il corrispettivo metodo della classe "NTPClient", controllo che l'oggetto di classe "NTPClient"
    // sia stato già allocato. Una chiamata su un oggetto non allocato (i.e. 'nullptr') causerebbe una eccezione con 
    // conseguente fail della memoria.
    // Il funzionamento dell'oggetto di classe di classe "NTPClient" dipende anche dall'oggetto di classe "WiFiUDP".
    // Per questo motivo, effettuo un controllo anche su quello.
    // Infine, effettuo anche un controllo sulla connessione. Chiamo i metodi solo se sono connesso ad Internet, questo perchè essi richiedono
    // una connessione per funzionare correttamente.
    if (m_UDPProtocol && m_NTPEntryPoint && WiFi.status() == WL_CONNECTED)
    {
        m_NTPEntryPoint->update();
        return m_NTPEntryPoint->getEpochTime();
    }
    else
        // Precisiamo che non importa la incorrispondenza tra signed and unsigned. In questo caso, il valore che verrà ritornato NON sarà '-1', ma il corrispodente
        // valore 'unsigned'. Questo potrebbe far pensare a possibili problematiche legate al confronto tra questo valore e quello restituito dal metodo 'get_Invalidator' --> '-1'.
        // In verità, non ci sarà nessun problema. Questo, perchè durante la compilazione il compilatore, ovunque trovi un confronto tra valori 'signed' e 'unsigned', 
        // effettua una conversione automatica del valore 'signed' nel corrispondente 'unsigned'.
        // In questo modo, avremo un confronto tra due 'unsigned' il quale valore 'signed' è uguale --> '-1'. Quindi anche il corrispettivo valore 'unsigned' sarà uguale.
 
        // Ricordiamo, inoltre, che il tipo 'long' non è altro che un 'int' "ingrandito". E' sempre e comunque un 'int'.
        return m_Invalidator;
}
 
// Implementazione del metodo 'get_Period' della categoria 'Metodi'
const Clock::TimePeriod Clock::get_Period()
{
    // Prima di procedere, controllo che l'inizializzazione della classe sia già stata eseguita 
    // Se così non fosse, il valore di 'm_TimeFormat' sarebbe un valore indeterminato, causando risultati indefiniti durante il ritorno
    // La presenza di riferimenti validi negli attributi 'm_UDPProtocol' e 'm_NTPEntryPoint' è segno di una inizializzazione già effettuata e correttamente completata
    if (m_UDPProtocol && m_NTPEntryPoint && WiFi.status() == WL_CONNECTED)
        // Ritorno l'attributo originale costante (non modificabile, per evitare modifiche indesiderate)
        return m_Period;
    else
        // Causa l'impossibilità nell'uso di un ritorno come referenza 'reference'[&]
        return TimePeriod::NOT_USED;
}    
 
// Implementazione del metodo 'get_Format' della categoria 'Metodi'
const Clock::TimeFormat Clock::get_Format()
{
    // Prima di procedere, controllo che l'inizializzazione della classe sia già stata eseguita 
    // Se così non fosse, il valore di 'm_TimeFormat' sarebbe un valore indeterminato, causando risultati indefiniti durante il ritorno
    // La presenza di riferimenti validi negli attributi 'm_UDPProtocol' e 'm_NTPEntryPoint' è segno di una inizializzazione già effettuata e correttamente completata
    if (m_UDPProtocol && m_NTPEntryPoint)
        // Ritorno l'attributo originale costante (non modificabile, per evitare modifiche indesiderate)
        return m_TimeFormat;        
    else
        // Causa l'impossibilità nell'uso di un ritorno come referenza 'reference'[&]
        return TimeFormat::INVALID_REFERENCE;
}   
 
// Implementazione del metodo 'get_Invalidator' della categoria 'getter -> Invalidator'
/*La specificazione 'inline' rappresenta una grossa ottimizzazione!!*/
inline const int& Clock::get_Invalidator()
{
    // Ritorno il valore dell'attributo 'm_Invalidator'. Per evitare la copia durante la fase di ritorno, ritorno l'attributo
    // originale [referenza --> reference '&']. L'attributo è già costante, questo evita modifiche non autorizzate.
    return m_Invalidator;
}