CLB_thread

CLB_thread è la classe base dei thread costruiti mediante il framework di Colibrì. Eredita la classe Thread_status, che utilizza come interfaccia di gestione degli eventi e stati del thread. Le classi derivate sono costruite utilizzando un insieme di macro che semplificano la gestione interna,  standardizzando i processi di interruzione dall’esterno del thread, la richiesta di sospensione o di terminazione, lo stato di waiting (attesa di eventi esterni), il passaggio on-fly di parametri ecc.

Le classi CLB_thread non appaiono come threads direttamente eseguibili, ma nascondono al loro interno, come avremo occasione di mostrare uno o più thread eseguibili, la cui gestione è fatta dalla classe stessa. La distruzione (rilascio) della classe automaticamente comporterà  la chiusura del thread/threads in esecuzione al loro interno. I thread  interni sono scritti utilizzando macro di CLB_lang: questo garantisce l’assoluta trasparenza nel controllo del loro funzionamento interno, con test automatici sullo stato degli eventi correlati alla loro esecuzione.

class AFX_EXT_CLASS CLB_thread : public Thread_status
{
public:
   CLB_thread(void);
   ~CLB_thread(void);
   
    void Set_loop_interval(int minv, int maxv);
    void Get_loop_interval(int *minv, int *maxv);

    bool Set_argument_list(__arg_value pars, ...);
    bool Push_argument(__arg_value arg);
    __arg_value Pop_argument();

    ARGPTR *GetArgumentList();

    float Perc();
    void SetPerc(float perc);
    

    virtual bool Start();
    virtual bool Suspend(); 
    virtual bool Stop();
    bool Terminated();

   __use_private_struct
};

Non tutte le funzioni di questa classe hanno utilità generale, ad esempio le due funzioni Set_loop_interval()  e Get_loop_interval() sono usate in casi particolari per estrarre i parametri di ciclo di elaborazione. Alcune funzioni come Perc() e SetPerc() sono usate per leggere ed assegnare una percentuale di esecuzione attuale del thread, che possono essere ricevute ad esempio dalle classi che ne visualizzano lo stato.

LA funzionE virtuali Start deve essere riscritta per ciascuna classe derivata da  CLB_thread

Le funzioni virtuali  Suspend e Stop possono essere riscritte per ciascuna classe derivata da  CLB_thread, per effettuare operazioni specifiche prima o dopo la richiesta di sospensione, o stop. In ogni caso devono al loro interno richiamare la CLB_thread::Stop o CLB_thread::Suspend

Start()

La funzione Start()  è virtuale, cioè deve essere riscritta per ciascuna classe thread derivata, ed è la funzione di esecuzione del thread.  Al suo interno farà riferimento, come vedremo nell’esempio alla definizione del thread/threads gestito dalla classe.

Suspend()

La funzione Suspend() sospende l’esecuzione del thread fino a chiusura o riattivazione dello stesso.

Stop()

La funzione Stop() blocca l’esecuzione del thred ed esce quando l’evento EV_END è stato effettivamente alzato. Internamente la CLB_event::Stop() richiama la funzione Thread_status::Stop_thread() che gestisce la sequenza di eventi per il blocco del thread.

Nota:  Le classi derivate da CLB_thread che avessero la necessità di riscrittura della Stop() e Suspend() , ad esempio per effettuare particolari azioni prima o dopo, comunque dovranno richiamare la CLB_thread_Stop() o CLB_thread_Suspend() prima di uscire; Di seguito è riportato un esempio di funzioni Stop e Suspendi di una classe

class my_clb_thread : public CLB_thread
{

....

bool Stop()
{
  ....  to do before stop..
  CLB_thread::Stop()
  ...   to do after stop ..
}

bool Suspend()
{
  ....  to do before suspend..
  CLB_thread::Supend()
  ...   to do after suspend..
}


}

Terminated()

La funzione rimanda true se il thread ha terminato la sua funzione ( vedi Start())

Nota: Le classi  derivate da CLB_thread non vengono automaticamente eliminate alla chiusura del thread in esecuzione; pertanto possono essere riattivate o distrutte su richiesta del programmatore