Slider.h

Go to the documentation of this file.

#pragma once
 
#pragma region INCLUSIONS
// nessuna inclusione necessaria
#pragma endregion INCLUSIONS
 
namespace Slider__file
{
    // Valore costante che viene ritornato in caso di errori
    // Il valore invalido utilizzato è un valore impossibile, cioè che non potrebbe essere mai restituito naturalmente.
    static constexpr int _invalidvalue = -1;
 
    static constexpr auto _initvalue = 0;
 
    // Valore costante per la formattazione "elegante" del formato dell'ora
    static constexpr auto _ElegantAdj /*Adjustment*/ = 10;
 
    // Espressione costante rappresentante il valore massimo che pu� essere attribuito all'attributo 'm_Hour' della classe "Slider" --> _24HOURS
    static constexpr auto _24HOURS_hourlimiter = 23;
    // Espressione costante rappresentante il valore massimo che pu� essere attribuito all'attributo 'm_Hour' della classe "Slider" --> _12HOURS
    static constexpr auto _12HOURS_hourlimiter = 12;
    // Espressione costante rappresentante il valore massimo che pu� essere attribuito all'attributo 'm_Minute' della classe "Slider" --> _12HOURS / _24HOURS
    static constexpr auto _minutelimiter = 59;
 
    // 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 rappresentante il periodo per la gestione del formato --> 12h
    static constexpr auto _Period = 12;
}
 
class Slider
{
    /*Blocco trivial*/
    /*
    Stiamo trattando una classe interamente statica. Per la definizione di staticit�, descritta successivamente, questa classe funger� solamente
    da "contenitore astratto" per organizzare pi� logicamente i dati. In verit�, tutto risieder� principalmente nel Data Segment, quindi sar�
    globale, ma statico (anche questo descritto successivamente).
    Questa staticit� implica la NON necessit� di creare istanze di questa classe, che risulterebbero totalmente inutili dato che tutti gli attributi
    e i metodi esistono nell'ambito globale.
    Per evitare, quindi, inutili istanziamenti, verranno bloccati il costruttore trivial (di default generato dal compilatore) e il distruttore, reso
    inutile dalla non-istanziabilit� della classe stessa.
    */
private:
    // Blocco attraverso privatizzazione del costruttore trivial
    Slider() = default;
    // Blocco attraverso privatizzazione del distruttore trivial
    ~Slider() = default;
 
    /*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 TimeFormat
    {
        _12HOURS,
        _24HOURS,
        INVALID_REFERENCE
    };
 
    enum class TimePeriod
    {
        NOT_USED,
        AM,
        PM
    };
 
    /*Attributi*/
private:
    static unsigned int m_Hour;
 
    static unsigned int m_Minute;
 
    static TimeFormat m_Format;
 
    static TimePeriod m_Period;
 
    static bool m_isReady;
 
    /*Init*/
public:
    static bool Init(const TimeFormat& t_Format);
 
    /*getter*/
public:
    static unsigned int get_Hour();
    static unsigned int get_Minute();
    static const TimePeriod get_Period();
    static const TimeFormat get_Format();
    static const String get_SliderValue();
 
    /*setter*/
public:
    static bool set_SliderValue(const String& t_SliderValue, const TimePeriod& t_Period = Slider::TimePeriod::NOT_USED);
 
    /*Metodi*/
public:
    static inline bool inc_Hour();
    static inline bool inc_Minute();
 
    static bool ChangeFormat(const TimeFormat& t_Format);
 
    /*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_Invalidator;
 
    /*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.
    */
    static inline const int& get_Invalidator();
};
 
// Dichiarazione delle variabili GLOBALI STATICHE 
// Risiederanno nel Data Segment
/*
Essendo statiche in classe, tutti gli attributi non sono altro che variabili GLOBALI STATICHE.
Per questo è richiesta la dichiarazione globale. Non è necessario specificare 'static' essendo già stato specificato nella dichiarazione degli
attributi nella classe stessa.
*/
unsigned int Slider::m_Hour;
unsigned int Slider::m_Minute;
Slider::TimeFormat Slider::m_Format;
Slider::TimePeriod Slider::m_Period;
bool Slider::m_isReady;
const int Slider::m_Invalidator = Slider__file::_invalidvalue;
 
//////////////////////////////////////////////////////////////////////////