AlarmData.cpp

Go to the documentation of this file.

 
// Inclusione <automatica> dell'header che si sta implementando
#include "AlarmData.h"
 
// Implementazione del costruttore dei default della categoria 'Costruttori e Distruttori'
AlarmData::AlarmData()
// inizializzazione ai valori di default della 'constexpr' [_initvalue]
// inizializzazione 'm_State' al valore 'AlarmState::OFFLINE'
// Utilizzo di una INITIALIZER LIST per ottimizzazione
    : m_Hour(AlarmData__file::_initvalue), m_Minute(AlarmData__file::_initvalue), m_Format(Clock::get_Format()), m_State(AlarmState::OFFLINE)
{
    switch (m_Format)
    {
    case Clock::TimeFormat::_12HOURS:
        m_Period = Clock::TimePeriod::AM;   // per 00:00 am di default
        break;
    case Clock::TimeFormat::_24HOURS:
        m_Period = Clock::TimePeriod::NOT_USED;
        break;
    case Clock::TimeFormat::INVALID_REFERENCE:  // indicherebbe un errore nella classe Clock
        m_Period = Clock::TimePeriod::NOT_USED;
        break;
    }
}
 
// Implementazione del distruttore della categoria 'Costruttori e Distruttori'
AlarmData::~AlarmData()
{
    // Solo per una gestione pi� sicura, verr� impostato su 'AlarmState::OFFLINE' il valore dell'attributo 'm_State'.
    // Questo principalmente per evitare la deallocazione dell'oggetto rappresentante la sveglia proprio durante il suo stato di trigger.
 
    m_State = AlarmState::OFFLINE;
 
    // Deallocazione dell'oggetto con la perdit� di tutte le informazioni ad esso associate.
}
 
// Implementazione del metodo 'set_Time' della categoria 'Value Setters'
// set_Time (1)
bool AlarmData::set_Time(const unsigned int& t_Hour, const unsigned int& t_Minute, const Clock::TimePeriod& t_Period /* = Clock::TimePeriod::NOT_USED */)
{
    // Prima dell'assegnamento, effettuo dei controlli sulla validit� dei parametri
    // Specializzazione in base al formato dell'ora --> 12h / 24h
    switch (m_Format)
    {
    case Clock::TimeFormat::_12HOURS:
        // Valori invalidi. Non effettuo alcuna operazione
        if (t_Hour > AlarmData__file::_12HOURS_hourlimiter || t_Minute > AlarmData__file::_minutelimiter)
            return false;
 
        if (t_Hour == AlarmData__file::_12HOURS_hourlimiter && t_Period == Clock::TimePeriod::PM)
            return false;
 
        if (t_Hour == AlarmData__file::_initvalue && t_Period == Clock::TimePeriod::PM)
            return false;
 
        if (t_Period == Clock::TimePeriod::NOT_USED)
            return false;
 
        // Valori validi. Effettuo assegnazione
        m_Hour = t_Hour;
        m_Minute = t_Minute;
        m_Period = t_Period;
 
        return true;
        break;
 
    case Clock::TimeFormat::_24HOURS:
        if (t_Hour > AlarmData__file::_24HOURS_hourlimiter || t_Minute > AlarmData__file::_minutelimiter)
            // Valori invalidi. Non effettuo alcuna operazione
            return false;
        else
        {
            // Valori validi. Effettuo assegnazione
            m_Hour = t_Hour;
            m_Minute = t_Minute;
            m_Period = Clock::TimePeriod::NOT_USED;
 
            return true;
        }
        break;
 
    case Clock::TimeFormat::INVALID_REFERENCE:  // indicherebbe un errore nella classe Clock
        return false;
        break;
    }
}
 
// set_Time (2)
bool AlarmData::set_Time(const String& t_Value, const Clock::TimePeriod& t_Period /* = Clock::TimePeriod::NOT_USED */)
{
    // Controlli preventivi sulla stringa
    /*hh:mm period (facoltativo)*/
    if (t_Value.length() != AlarmData__file::_length_short && t_Value.length() != AlarmData__file::_length_long)
        return false;
 
    if (t_Value[2] != AlarmData__file::_characteratpositiontwo)
        return false;
 
    unsigned int l_Hour = ((String(t_Value[0]).toInt() * 10) + String(t_Value[1]).toInt());
    unsigned int l_Minute = ((String(t_Value[3]).toInt() * 10) + String(t_Value[4]).toInt());
 
    switch (m_Format)
    {
    case Clock::TimeFormat::_12HOURS:
        if (l_Hour > AlarmData__file::_12HOURS_hourlimiter || l_Minute > AlarmData__file::_minutelimiter)
            return false;
        else
        {
            if (t_Period == Clock::TimePeriod::NOT_USED)
                return false;
 
            if (l_Hour == AlarmData__file::_12HOURS_hourlimiter && t_Period == Clock::TimePeriod::PM)
                return false;
 
            if (l_Hour == AlarmData__file::_initvalue && t_Period == Clock::TimePeriod::PM)
                return false;
 
            m_Hour = l_Hour;
            m_Minute = l_Minute;
            m_Period = t_Period;
 
            return true;
        }
        break;
    case Clock::TimeFormat::_24HOURS:
        if (l_Hour > AlarmData__file::_24HOURS_hourlimiter || l_Minute > AlarmData__file::_minutelimiter)
            return false;
        else
        {
            m_Hour = l_Hour;
            m_Minute = l_Minute;
            m_Period = Clock::TimePeriod::NOT_USED;
 
            return true;
        }
        break;
    }
}
 
// Implementazione del metodo 'set_State' della categoria 'Value Setters'
bool AlarmData::set_State(const AlarmState& t_State)
{
    // Prima dell'assegnamento, effettuo un controllo per verificare la effettiva necessit� dell'assegnamento
    if (t_State == m_State)
        // Operazione di assegnamento non necessaria
        return false;
 
    // Operazione di assegnamento necessaria
    m_State = t_State;
 
    return true;
}
 
// Implementazione del metodo 'get_SetTime' della categoria 'Metodi'
String AlarmData::get_SetTime()
{
    // Creo una variabile locale allo STACK FRAME di questo metodo <-- [reference '&'] non disponibile in ritorno
    // Questa variabile verr� utilizzata per la rappresentazione del valore nel formato 'hh:mm'.
    // Il valore restituito sar� del tipo 'String' [stringa]
    String l_SetTime = "";
 
    // Specializzazione in base al formato dell'ora --> 12h / 24h
    switch (m_Format)
    {
    case Clock::TimeFormat::_12HOURS:
        // Ottengo il valore in 'hh'
        // 'Elegant Adjustment' "Regolazione Elegante" della stringa in ritorno per il valore dell'ora impostata per il trigger della sveglia
        // Aggiunge uno zero '0' inziale per compensare un eventuale mancanza di seconda cifra (per i valori minori di '_ElegantAdj' (i.e. '10'))
        if (m_Hour < AlarmData__file::_ElegantAdj)
            l_SetTime = l_SetTime + "0";
 
        l_SetTime = l_SetTime + String(m_Hour) + ":";
 
        // Ottengo il valore in 'mm'
        // 'Elegant Adjustment' "Regolazione Elegante" della stringa in ritorno per il valore dell'ora impostata per il trigger della sveglia
        // Aggiunge uno zero '0' inziale per compensare un eventuale mancanza di seconda cifra (per i valori minori di '_ElegantAdj' (i.e. '10'))
        if (m_Minute < AlarmData__file::_ElegantAdj)
            l_SetTime = l_SetTime + "0";
 
        l_SetTime = l_SetTime + String(m_Minute);
 
        // Ottengo il periodo
        switch (m_Period)
        {
        case Clock::TimePeriod::AM:
            l_SetTime = l_SetTime + "am";
            break;
 
        case Clock::TimePeriod::PM:
            l_SetTime = l_SetTime + "pm";
            break;
        }
        break;
 
    case Clock::TimeFormat::_24HOURS:
        // Ottengo il valore in 'hh'
        // 'Elegant Adjustment' "Regolazione Elegante" della stringa in ritorno per il valore dell'ora impostata per il trigger della sveglia
        // Aggiunge uno zero '0' inziale per compensare un eventuale mancanza di seconda cifra (per i valori minori di '_ElegantAdj' (i.e. '10'))
        if (m_Hour < AlarmData__file::_ElegantAdj)
            l_SetTime = l_SetTime + "0";
 
        l_SetTime = l_SetTime + String(m_Hour) + ":";
 
        // Ottengo il valore in 'mm'
        // 'Elegant Adjustment' "Regolazione Elegante" della stringa in ritorno per il valore dell'ora impostata per il trigger della sveglia
        // Aggiunge uno zero '0' inziale per compensare un eventuale mancanza di seconda cifra (per i valori minori di '_ElegantAdj' (i.e. '10'))
        if (m_Minute < AlarmData__file::_ElegantAdj)
            l_SetTime = l_SetTime + "0";
 
        l_SetTime = l_SetTime + String(m_Minute);
 
        break;
 
    case Clock::TimeFormat::INVALID_REFERENCE:  // indicherebbe un errore nella classe Clock
        return String(m_CoreInvalidator);
        break;
    }
 
    // Ritorno la 'String' [stringa] equivalente
    return l_SetTime;
}
 
// Implementazione del metodo 'Check' della categoria 'Metodi'
bool AlarmData::Check()
{
    // Effettuo un controllo sugli attributi 'm_Hour' e 'm_Minute'
    if (m_State == AlarmState::OFFLINE)
        // La sveglia non � attiva, quindi � automaticamente non in trigger
        return false;
 
    // Confronto i valori degli attributi 'm_Hour' e 'm_Minute' con i valori in ritorno dai metodi della classe "Clock"
    // Non � necessario predisporre un controllo per gli eventuali invalidatori in ritorno dai metodi della classe "Clock".
    /*
    Questo perch� l'invalidatore, per la natura del suo tipo, rappresenta un valore impossibile, che quindi � e sar� sempre e sempre
    diverso da possibili valori validi. La classe "AlarmData", nel metodo 'set_Time' implementa di gi� controlli di validit� per gli attributi
    'm_Hour' e 'm_Minute', che quindi conterranno solo valori validi, automaticamente diversi dal valore dell'invalidatore.
    Quindi, grazie al controllo in 'set_Time' e grazie alla natura dell'invalidatore stesso, non abbiamo bisogno di conoscerne il valore: il 
    metodo 'Check' di questa classe ritorner� comunque un valore booleano 'false'.
    */
    // Specializzazione in base al formato dell'ora --> 12h / 24h
    switch (m_Format)
    {
    case Clock::TimeFormat::_12HOURS:
        if (m_Hour == Clock::get_Hours() && m_Minute == Clock::get_Minutes() && m_Period == Clock::get_Period())
            // Comunico che la sveglia � in trigger
            return true;
        else
            // Comunico che la sveglia non � in trigger
            return false;
        break;
 
    case Clock::TimeFormat::_24HOURS:
        if (m_Hour == Clock::get_Hours() && m_Minute == Clock::get_Minutes())
            // Comunico che la sveglia � in trigger
            return true;
        else
            // Comunico che la sveglia non � in trigger
            return false;
        break;
 
    case Clock::TimeFormat::INVALID_REFERENCE:  // indicherebbe un errore nella classe Clock
        return false;
        break;
    }
}
 
// Implementazione del metodo 'UpdateFormat' della categoria 'Metodi'
bool AlarmData::UpdateFormat()
{
    // Controllo se l'operazione � effettivamente necessaria
    if (m_Format == Clock::get_Format())
        // Operazione non necessaria
        return false;
 
    // Operazione necessaria
    // Assegnamento
    m_Format = Clock::get_Format();
 
    switch (m_Format)
    {
    case Clock::TimeFormat::_12HOURS:
    {
        auto l_Supporter = m_Hour;
        // Proveniamo da 24 ore
        if (l_Supporter > Clock__file::_Period)
        {
            m_Period = Clock::TimePeriod::PM;
 
            m_Hour = l_Supporter - Clock__file::_Period;
        }
        else
        {
            m_Period = Clock::TimePeriod::AM;
            m_Hour = l_Supporter;
        }
        return true;
        break;
    }
 
    case Clock::TimeFormat::_24HOURS:
        // Proveniamo da 12 ore
        switch (m_Period)
        {
        case Clock::TimePeriod::AM:
            break;
 
        case Clock::TimePeriod::PM:
            m_Hour = m_Hour + Clock__file::_Period;
            break;
        }
 
        m_Period = Clock::TimePeriod::NOT_USED;
        return true;
        break;
 
    case Clock::TimeFormat::INVALID_REFERENCE:  // indicherebbe un errore nella classe Clock
        return false;
        break;
    }
}
 
// Implementazione del metodo 'get_Invalidator' della categoria 'getter -> Invalidator'
/*La specificazione 'inline' rappresenta una grossa ottimizzazione!!*/
inline const int& AlarmData::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;
}