be_framework_api.h

Go to the documentation of this file.

/*
 * This software was developed at the National Institute of Standards and
 * Technology (NIST) by employees of the Federal Government in the course
 * of their official duties. Pursuant to Title 17 Section 105 of the
 * United States Code, this software is not subject to copyright protection
 * and is in the public domain. NIST assumes no responsibility whatsoever for
 * its use by other parties, and makes no guarantees, expressed or implied,
 * about its quality, reliability, or any other characteristic.
 */
 
#ifndef BE_FRAMEWORK_API_H_
#define BE_FRAMEWORK_API_H_
 
#include <functional>
#include <memory>
 
#include <be_error_signal_manager.h>
#include <be_framework_enumeration.h>
#include <be_framework_status.h>
#include <be_time_timer.h>
#include <be_time_watchdog.h>
 
namespace BiometricEvaluation
{
        namespace Framework
        {
                enum class APICurrentState
                {
                        NeverCalled,
                        WatchdogExpired,
                        SignalCaught,
                        ExceptionCaught,
                        Running,
                        Completed
                };
        }
}
 
BE_FRAMEWORK_ENUMERATION_DECLARATIONS(
    BiometricEvaluation::Framework::APICurrentState,
    BE_Framework_APICurrentState_EnumToStringMap);
 
namespace BiometricEvaluation
{
        namespace Framework
        {
                template<typename T>
                class API
                {
                public:
                        class Result
                        {
                        public:
                                Result();
 
                                uint64_t elapsed;
                                T status;
                                APICurrentState currentState;
 
                                inline bool
                                operator!()
                                    const
                                {
                                        return (currentState !=
                                            APICurrentState::Completed);
                                }
 
                                inline explicit operator
                                bool()
                                    const
                                {
                                        return (currentState ==
                                            APICurrentState::Completed);
                                }
 
                                std::string
                                getExceptionStr()
                                    const
                                    noexcept
                                {
                                        try {
                                                this->rethrowException();
                                        } catch (const std::exception &e) {
                                                return (e.what());
                                        } catch (...) {
                                                return {};
                                        }
                                }
 
                                [[noreturn]]
                                void
                                rethrowException()
                                    const
                                {
                                        if (this->currentState !=
                                            APICurrentState::ExceptionCaught)
                                                throw Error::StrategyError{
                                                    "No exception handled, "
                                                    "current state is " +
                                                    Enumeration::to_string(
                                                    this->currentState)};
                                        if (!this->exceptionPtr)
                                                throw Error::StrategyError{
                                                    "Exception was caught, but "
                                                    "not saved"};
 
                                        std::rethrow_exception(
                                            this->exceptionPtr);
                                }
 
                                void
                                setException(
                                    std::exception_ptr e)
                                {
                                        this->exceptionPtr = e;
                                }
 
                        private:
                                std::exception_ptr exceptionPtr{};
                        };
 
                        API();
 
                        Result
                        call(
                            const std::function<T(void)> &operation,
                            const std::function<void(const Result&)>
                            &success = {},
                            const std::function<void(const Result&)>
                            &failure = {});
 
                        bool
                        protectionsEnabled()
                            const
                        {
                                return (this->willCatchExceptions() &&
                                    !this->willRethrowExceptions() &&
                                    this->getWatchdog()->isEnabled() &&
                                    this->getSignalManager->isEnabled());
                        }
 
                        void
                        setProtectionsEnabled(
                            const bool protectionsEnabled)
                        {
                                this->setCatchExceptions(protectionsEnabled);
                                this->setRethrowExceptions(!protectionsEnabled);
                                this->getWatchdog()->setEnabled(
                                    protectionsEnabled);
                                this->getSignalManager->setEnabled(
                                    protectionsEnabled);
                        }
 
                        bool
                        willRethrowExceptions()
                            const
                        {
                                return (this->_rethrowExceptions);
                        }
 
                        void
                        setRethrowExceptions(
                            const bool shouldRethrow)
                        {
                                this->_rethrowExceptions = shouldRethrow;
                        }
 
                        void
                        setCatchExceptions(
                            const bool catchExceptions)
                        {
                                this->_catchExceptions = false;
                        }
 
                        bool
                        willCatchExceptions()
                            const
                        {
                                return (this->_catchExceptions);
                        }
 
                        inline std::shared_ptr<BiometricEvaluation::Time::Timer>
                        getTimer()
                            noexcept
                        {
                                return (_timer);
                        }
 
                        inline std::shared_ptr<
                            BiometricEvaluation::Time::Watchdog>
                        getWatchdog()
                            noexcept
                        {
                                return (_watchdog);
                        }
 
                        inline std::shared_ptr<
                            BiometricEvaluation::Error::SignalManager>
                        getSignalManager()
                            noexcept
                        {
                                return (_sigmgr);
                        }
 
                private:
                        bool _catchExceptions{true};
                        bool _rethrowExceptions{false};
                        std::shared_ptr<BiometricEvaluation::Time::Timer>
                            _timer;
                        std::shared_ptr<BiometricEvaluation::Time::Watchdog>
                            _watchdog;
                        std::shared_ptr<
                            BiometricEvaluation::Error::SignalManager> _sigmgr;
                };
        }
}
 
template<typename T>
BiometricEvaluation::Framework::API<T>::Result::Result() :
    currentState(BiometricEvaluation::Framework::APICurrentState::NeverCalled)
{
 
}
 
template<typename T>
BiometricEvaluation::Framework::API<T>::API() :
    _catchExceptions{true},
    _rethrowExceptions{false},
    _timer(new BiometricEvaluation::Time::Timer()),
    _watchdog(new BiometricEvaluation::Time::Watchdog(
        BiometricEvaluation::Time::Watchdog::REALTIME)),
    _sigmgr(new BiometricEvaluation::Error::SignalManager())
{
 
}
 
template<typename T>
typename BiometricEvaluation::Framework::API<T>::Result
BiometricEvaluation::Framework::API<T>::call(
    const std::function<T(void)> &operation,
    const std::function<void(const Framework::API<T>::Result&)> &success,
    const std::function<void(const Framework::API<T>::Result&)> &failure)
{
        Result ret;
 
        BEGIN_SIGNAL_BLOCK(this->getSignalManager(), SM_BLOCK);
        BEGIN_WATCHDOG_BLOCK(this->getWatchdog(), WD_BLOCK);
                ret.currentState = APICurrentState::Running;
                if (this->willCatchExceptions()) {
                        this->getTimer()->start();
                        try {
                                ret.status = operation();
                        } catch (...) {
                                this->getTimer()->stop();
                                ret.elapsed = this->getTimer()->elapsed();
                                ret.currentState =
                                    APICurrentState::ExceptionCaught;
                                ret.setException(std::current_exception());
 
                                if (failure)
                                        failure(ret);
 
                                if (this->_rethrowExceptions)
                                        throw;
 
                                return (ret);
                        }
                } else {
                        this->getTimer()->start();
                        ret.status = operation();
                }
                this->getTimer()->stop();
        END_WATCHDOG_BLOCK(this->getWatchdog(), WD_BLOCK);
        END_SIGNAL_BLOCK(this->getSignalManager(), SM_BLOCK);
        if (this->getSignalManager()->sigHandled()) {
                this->getTimer()->stop();
                ret.elapsed = this->getTimer()->elapsed();
                ret.currentState = APICurrentState::SignalCaught;
 
                if (failure)
                        failure(ret);
        } else if (this->getWatchdog()->expired()) {
                this->getTimer()->stop();
                ret.elapsed = this->getTimer()->elapsed();
                ret.currentState = APICurrentState::WatchdogExpired;
 
                if (failure)
                        failure(ret);
        } else {
                ret.currentState = APICurrentState::Completed;
                ret.elapsed = this->getTimer()->elapsed();
 
                if (success)
                        success(ret);
        }
 
        return (ret);
}
 
#endif /* BE_FRAMEWORK_API_H_ */