StopWatchData.cpp

Go to the documentation of this file.

 
// Inclusione <automatica> dell'header che si sta implementando
#include "StopWatchData.h"
 
// Implementazione del costruttore di default della categoria 'Costruttori e Distruttori'
StopWatchData::StopWatchData()
// inizializzazione ai valori di default della 'constexpr' [_initvalue]
// inizializzazione stato della sveglia 'WorkingState' al valore di default 'WorkingState::OFFLINE'.
// Inizializzazione valore booleano per controllo errori al valore di default 'false'.
// Utilizzo di una INITIALIZER LIST per ottimizzazione
    : m_Time(StopWatchData__file::_initvalue), m_BaseTime(StopWatchData__file::_initvalue), m_OldTime(StopWatchData__file::_initvalue), m_WorkingState(WorkingState::OFFLINE),
    m_isErrorOccured(false)
{
}
 
// Implementazione del distruttore della categoria 'Costruttori e di Distruttori'
StopWatchData::~StopWatchData()
{
    // Arresto il cronometro. Nel caso sia gi� arrestato, il metodo 'Stop' gestir� l'eccezzione.
    Stop();
 
    // Deallocazione dell'oggetto con la perdit� di tutte le informazioni ad esso associate.
}
 
// Implementazione del metodo 'Start' della categoria 'Service Management'
// Avvia il cronometro
bool StopWatchData::Start()
{
    // Variabile locale allo STACK FRAME del metodo.
    // Questa variabile locale viene creata per salvare localmente il valore ritornato dalla chiamata del metodo "get_EpochTime" della classe "Clock".
    // Questo viene effettuato per evitare DUPLICI CHIAMATE in previsione di un controllo sul valore per la gestione di eventuali eccezioni.
    // Il tipo è 'unsigned long', essendo questo anche quello del valore in ritorno dal metodo "get_EpochTime".
    unsigned long l_Tester;
 
    // Controllo che il cronometro non sia gi� avviato
    if (m_WorkingState == WorkingState::OFFLINE)
    {
        // In questo caso, posso procedere con l'avvio
        // Per procedere con l'avvio, eseguo un campionamento dell'ora corrente grazie ai metodi forniti dalla classe "Clock".
        // Successivamente, salvo questo valore nell'attributo 'm_BaseTime'.
 
        // Prima di procedere, effettuo un controllo sul valore ottenuto. Devo essere sicuro che la classe "Clock" era pronta nel momento della chiamata.
        // Se il valore ritornato è uguale all'invalidatore della classe "Clock", allora NON procedo con le operazioni.
        if (Clock::get_EpochTime() == Clock::get_Invalidator())
            // In questo caso, non effettuo nessuna operazione. Il valore di 'm_BaseTime' non verrà modificato e il cronometro NON verrà avviato.
            return false;
            
        // In questo caso, essendo il valore ottenuto valido, allora procedo con le operazioni.
        // Al valore ottenuto è stato sottratto "1" per gestire la ripresa del cronometro per evitare la ripetizione del primo valore in partenza.
        // Il valore viene salvato nell'attributo 'm_BaseTime'
        get_BaseTime();
 
        // Imposto lo stato di funzionamento su 'true'
        m_WorkingState = WorkingState::ONLINE;
        return true;
    }
 
    // Il cronometro non pu� essere avviato. Non eseguo alcuna operazione.
    return false;
}
 
// Implementazione del metodo 'Stop' della categoria 'Service Management'
bool StopWatchData::Stop()
{
    // Controllo che il cronometro sia gi� avviato
    if (m_WorkingState == WorkingState::ONLINE)
    {
        // Prima di fermare effettivamente il cronometro, salvo il valore corrente di esso nell'attributo 'm_OldTime'. 
        // Questa operazione è essenziale per permettere la ripresa dell'esecuzione del cronometro dallo stesso valore di arresto
        m_OldTime = m_Time;
 
        // Imposto lo stato di funzionamento su 'false'
        m_WorkingState = WorkingState::OFFLINE;
        return true;
    }
 
    // Il cronometro non pu� essere arrestato. Non eseguo alcuna operazione.
    return false;
}
 
// Implementazione del metodo 'get_BaseTime' della categoria 'Service Management'
/*
Il seguente metodo non prevede nessun tipo di implementazione del controllo. Questo è del tutto normale e viene derivato da 2 motivi:
- il metodo rappresenta una risorsa privata, che viene richiamata solo all'interno del codice della classe, implementato dal creatore stesso
- le chiamate al seguente metodo vengono effettuate di già in previo controllo. Quindi, quando il seguente metodo verrà chiamato,
si avrà già la certezza della prontezza della classe "Clock" per supportare la chiamata del suo metodo 'get_EpochTIme'.
*/
void StopWatchData::get_BaseTime()
{
    // Calcolo del 'm_BaseTime'.
    // Si sottrae '1' per evitare ripetizioni dello stesso valore alla ripresa dell'esecuzione del cronometro da un valore medio precedentemente interrotto
    m_BaseTime = Clock::get_EpochTime() - 1;
}
 
// Implementazione del metodo 'get_Time' della categoria 'Service Management'
bool StopWatchData::get_Time()
{
    // Variabile locale allo STACK FRAME del metodo.
    // Questa variabile locale viene creata per salvare localmente il valore ritornato dalla chiamata del metodo "get_EpochTime" della classe "Clock".
    // Questo viene effettuato per evitare DUPLICI CHIAMATE in previsione di un controllo sul valore per la gestione di eventuali eccezioni.
    // Il tipo è 'unsigned long', essendo questo anche quello del valore in ritorno dal metodo "get_EpochTime".
    unsigned long l_Tester;
 
    // Effettua le operazioni necessarie per determinare il valore corrente del cronometro.
    /*
    - effettua una differenza tra VALORE CORRENTE e BASE. In risultato sarà l'OFFSET che rappresenterà il valore corrente del cronometro.
    - salvo quest'ultimo valore nell'attributo 'm_Time'.
    
    Le operazioni avvengono sul tempo ESPRESSO IN SECONDI. Per ottenere questo valore, è stato utilizzato il metodo "get_EpochTime"
    */
 
    // Prima di effettuare le operazioni, controllo che il cronometro sia in funzione
    if (m_WorkingState == WorkingState::ONLINE)
    {
        // Solo quando il cronometro è in funzione, eseguo le operazioni di determinazione
        /*
        - Ottengo il valore corrente dell'ora espresso in secondi con il metodo "get_EpochTime"
        - Sottraggo il valore di base 'm_BaseTime' calcolato precedentemente
        - Aggiungo un eventuale tempo rimasto salvato in memoria nell'attributo 'm_OldTime'
        - Salvo il tutto nell'attributo 'm_Time'. Il valore sarà espresso in secondi
        */
 
        // Prima di procedere, effettuo un controllo sul valore ottenuto. Devo essere sicuro che la classe "Clock" era pronta nel momento della chiamata.
        // Se il valore ritornato è uguale all'invalidatore della classe "Clock", allora NON procedo con le operazioni.
        if (Clock::get_EpochTime() == Clock::get_Invalidator())
        {
            // In questo caso, non effettuo nessuna operazione. Il valore di 'm_BaseTime' non verrà modificato e il cronometro NON verrà avviato.
 
            // Avviso che, nel campionamento precedente dei valori, si è verificato un errore
            m_isErrorOccured = true;
            return false;
        }
 
        // In questo caso, essendo il valore ottenuto valido, allora procedo con le operazioni.
        // Controllo se precedentemente si è verificato un errore
        /*
        In caso affermativo, non avrebbe senso tentare di continuare con il precedente campionamento di 'm_BaseTime'.
        Ecco, perchè si effettua un nuovo campionamento.
        */
        if (m_isErrorOccured)
        {
            // Campiono il nuovo valore da utilizzare come base per il calcolo del valore del cronometro
            get_BaseTime();
 
            // Avviso che, durante questo campionamento, non si sono verificati errori
            m_isErrorOccured = false;
        }
 
        // Calcolo tempo effettivo che è il valore del cronometro
        m_Time = (m_OldTime + (Clock::get_EpochTime() - m_BaseTime));
 
        return true;
    }
 
    return true;
}
 
// Implementazione del metodo 'get_CurrentFormattedStopWatch' della categoria 'Metodi'
String StopWatchData::get_CurrentFormattedStopWatch()
{
    // Richiamo il metodo 'get_Time' per ottenere il valore corrente del cronometro --> "strong-updated" (appena aggiornato/"fresco")
    // Il valore verrà salvato nell'attributo 'm_Time'
    // Prima di tutto, controllo lo stato booleano ritornato dal metodo 'get_Time'.
    /*
    - 'true' --> il cronometro era in stato WorkingState::ONLINE e ha funzionato correttamente
    - 'true' --> il cronometro era in stato WorkingState::OFFLINE e ha funzionato correttamente (restituendo un valore momentaneamente costante)
    - 'false' --> il cronomtero era in stato WorkingState::ONLINE ma NON ha funzionato correttamenteù
    */
    // Nel caso 'get_Time' non funzioni correttamente, ritorniamo il valore dell'invalidatore della classe "StopWatchData"
    // Il valore corrisponde a quella della constexpr '_invalidvalue'.
    if (!(get_Time()))
        return String(m_CoreInvalidator);
 
    // Creo una variabile locale allo STACK FRAME di questo metodo <-- [reference '&'] non disponibile in ritorno
    // Questa variabile verrà utilizzata per la conversione del valore in secondi nel formato 'hh:mm:ss'.
    // La conversione restituirà un tipo 'String' [stringa]
    String l_Time = "";
 
    // Creo una seconda variabile locale allo STACK FRAME di questo metodo.
    // Quest'ultima verrà utilizzata per effettuare le operazioni di conversione del valore dell'attributo 'm_Time' senza però
    // cambiare il valore effettivo di 'm_Time'. Questo è necessario perchè un cambiamento al valore di 'm_Time' provocherebbe valori indesiderati durante 
    // il salvataggio in 'm_OldTime' e il successivo recupero.
    // Prendendo il valore di 'm_Time' di tipo 'unsigned long', anche 'l_ConversionSupporter' deve essere di tipo 'unsigned long'
    unsigned long l_ConversionSupporter = m_Time;
 
    // In questo caso, essendo il valore in 'm_Time' valido (controllato precedentemente nella prima condizione), allora procedo con le operazioni.
    // Operazioni di conversione in tipo 'String' [stringa] nel formato --> 'hh:mm:ss'
    // Le seguenti operazioni NON lavorano direttamente sul valore dell'attributo 'm_Time', ma sulla variabile locale di appoggio 'l_ConversionSupporter'
 
    // Ottengo il valore 'hh'
    // 'Elegant Adjustment' "Regolazione Elegante" della stringa in ritorno per il cronometro formattato
    // Aggiunge uno zero '0' inziale per compensare un eventuale mancanza di seconda cifra (per i valori minori di '_ElegantAdj' (i.e. '10'))
    if (l_ConversionSupporter / 3600 < StopWatchData__file::_ElegantAdj)
        l_Time = l_Time + "0";
 
    l_Time = l_Time + String(l_ConversionSupporter / 3600) + ":";
    l_ConversionSupporter = l_ConversionSupporter - ((l_ConversionSupporter / 3600) * 3600);
 
    // Ottengo il valore 'mm'
    // 'Elegant Adjustment' "Regolazione Elegante" della stringa in ritorno per il cronometro formattato
    // Aggiunge uno zero '0' inziale per compensare un eventuale mancanza di seconda cifra (per i valori minori di '_ElegantAdj' (i.e. '10'))
    if (l_ConversionSupporter / 60 < StopWatchData__file::_ElegantAdj)
        l_Time = l_Time + "0";
 
    l_Time = l_Time + String(l_ConversionSupporter / 60) + ":";
    l_ConversionSupporter = l_ConversionSupporter - ((l_ConversionSupporter / 60) * 60);
 
    // Ottengo il valore 'ss'
    // 'Elegant Adjustment' "Regolazione Elegante" della stringa in ritorno per il cronometro formattato
    // Aggiunge uno zero '0' inziale per compensare un eventuale mancanza di seconda cifra (per i valori minori di '_ElegantAdj' (i.e. '10'))
    if (l_ConversionSupporter < StopWatchData__file::_ElegantAdj)
        l_Time = l_Time + "0";
 
    l_Time = l_Time + String(l_ConversionSupporter);
 
    // Ritorno la 'String' [stringa] equivalente
    return l_Time;
}
 
// Implementazione del metodo 'get_WorkingState' della categoria 'Metodi'
const StopWatchData::WorkingState& StopWatchData::get_WorkingState()
{
    // Ritorno l'attributo originale costante (non modificabile, per evitare modifiche indesiderate)
    return m_WorkingState;
}
 
// Implementazione del metodo 'Trigger_to_Check' della categoria 'Metodi'
void StopWatchData::Trigger_to_Check()
{
    if (Clock::get_EpochTime() == Clock::get_Invalidator())
        // Avviso che, nel campionamento precedente dei valori, si è verificato un errore
        m_isErrorOccured = true;
}
 
// Implementazione del metodo 'get_Invalidator' della categoria 'getter -> Invalidator'
/*La specificazione 'inline' rappresenta una grossa ottimizzazione!!*/
inline const int& StopWatchData::get_CoreInvalidator()
{
    // 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_CoreInvalidator;
}