CArcTimer.h

// +------------------------------------------------------------------------------------------------------------------+
// |  FILE:  CArcTimer.h  ( GenIV )                                                                                   |
// +------------------------------------------------------------------------------------------------------------------+
// |  PURPOSE: This file defines the ARC timer class.                                                                 |
// |                                                                                                                  |
// |  AUTHOR:  Scott Streit         DATE: July 30, 2020                                                               |
// |                                                                                                                  |
// |  Copyright 2020 Astronomical Research Cameras, Inc. All rights reserved.                                         |
// +------------------------------------------------------------------------------------------------------------------+
 
#pragma once
 
#include <chrono>
#include <memory>
 
#include <CArcBaseDllMain.h>
#include <CArcBase.h>
 
 
namespace arc
{
    namespace gen4
    {
 
        class GEN4_CARCBASE_API CArcTimer : public CArcBase
        {
            public:
 
                ~CArcTimer( void );
 
                template <typename T>
                static arc::gen4::CArcTimer* create( std::function<void( void )> fnCallback, const T& tDuration )
                {
                    CArcTimer* pTimer = new CArcTimer();
 
                    if ( pTimer != nullptr )
                    {
                        pTimer->start<T>( std::ref( fnCallback ), tDuration );
                    }
 
                    return pTimer;
                }
 
                void cancel( void ) noexcept;
 
            private:
 
                CArcTimer( void );
 
                template <typename T>
                void start( std::function<void( void )> fnCallBack, const T& tDuration )
                {
                    m_fnCallBack = std::move( fnCallBack );
 
                    std::cout << "NEW TIMER (START) - ED!" << std::endl;
 
                    std::unique_ptr<std::thread> pThread( new std::thread( [ &, this ]()
                    {
                        try
                        {
                            if ( this->m_bCancel ) { std::cout << "TIMER (START) cancelled 1" << std::endl; return; }
 
                            auto start = std::chrono::high_resolution_clock::now();
 
                            while ( !this->m_bCancel )
                            {
                                auto now = std::chrono::high_resolution_clock::now();
 
                                if ( std::chrono::duration_cast< T >( now - start ) >= tDuration )
                                {
                                    break;
                                }
                            }
 
                            if ( this->m_bCancel ) { std::cout << "TIMER (START) cancelled 2" << std::endl; return; }
 
                            if ( m_fnCallBack != nullptr )
                            {
                                m_fnCallBack();
                            }
 
                            else
                            {
                                std::cout << "FUNCTION CLALBACK (START) is nullptr!" << std::endl;
                            }
                        }
                        catch ( ... ) {}
 
                        std::cout << "TIMER (START) completed!" << std::endl;
                    } ) );
 
                    pThread->detach();
                }
 
                std::function<void(void)>       m_fnCallBack;
 
                bool                            m_bCancel;
        };
 
    }       // end gen4 namespace
}           // end arc namespace