timer_decl.h

Go to the documentation of this file.

 
#ifndef A_UTIL_UTIL_SYSTEM_TIMER_DECL_INCLUDED
#define A_UTIL_UTIL_SYSTEM_TIMER_DECL_INCLUDED
 
#include <cstdint>
 
namespace a_util {
namespace result {
namespace detail {
 
// forward declare private reference counter
template <typename T, typename U>
class ReferenceCountedObject;
 
} // namespace detail
} // namespace result
 
namespace experimental {
// forward declaration
template <typename T>
class NullaryDelegate;
 
} // namespace experimental
namespace system {
class Timer {
public:
    Timer();

    ~Timer();

    Timer(std::uint64_t period_us, void (*function)());

    template <typename M, typename T>
    Timer(std::uint64_t period_us, M method, T& instance);

    void setCallback(void (*function)());

    template <typename M, typename T>
    void setCallback(M method, T& instance);

    void setPeriod(std::uint64_t period_us);

    std::uint64_t getPeriod() const;

    bool start();

    bool stop();

    bool isRunning() const;
 
private:
    Timer(const Timer&);            // = delete;
    Timer& operator=(const Timer&); // = delete;
    void setCallback(const a_util::experimental::NullaryDelegate<void>& cb);
 
private: // temporary IntrusivePtr implementation until it can be released publically
    template <typename T>
    class IntrusivePtr {
        using reference_counted_object_pointer =
            a_util::result::detail::ReferenceCountedObject<T, T>*;
 
    public:
        using value_type = T;
        using pointer = value_type*;
        using const_pointer = const value_type*;
        using reference = value_type&;
        using const_reference = const value_type&;
 
        // construction/destruction
        explicit IntrusivePtr(reference_counted_object_pointer reference_counted_object)
            : _reference_counted_object{reference_counted_object}
        {
            // nullptr check currently missing on purpose, has to be added if generalized
            // maybe a nullptr check doesn't make sense in ctor due to move operators setting the
            // member to nullptr anyway ...
            addReference();
        }
 
        ~IntrusivePtr() noexcept
        {
            removeReference();
        }
 
        // copy constructor
        IntrusivePtr(const IntrusivePtr& other) : IntrusivePtr{other._reference_counted_object}
        {
        }
 
        // copy assignment
        IntrusivePtr& operator=(const IntrusivePtr& other)
        {
            removeReference();
            _reference_counted_object = other._reference_counted_object;
            addReference();
            return *this;
        }
 
        // move constructor
        IntrusivePtr(IntrusivePtr&& other) noexcept
            : _reference_counted_object{other._reference_counted_object}
        {
            other.release();
        }
 
        // move assignment
        IntrusivePtr& operator=(IntrusivePtr&& other) noexcept
        {
            _reference_counted_object = other._reference_counted_object;
            other.release();
            return *this;
        }
 
    public: // access/modification
        // maybe return number of references instead of void?
        void addReference() const noexcept
        {
            _reference_counted_object->addReference();
        }
 
        // maybe return number of references instead of void?
        void removeReference() const noexcept
        {
            _reference_counted_object->removeReference();
        }
 
        // maybe return pointer to member instead of void?
        void release() noexcept
        {
            _reference_counted_object = nullptr;
        }
 
        auto operator->() const noexcept -> const_pointer
        {
            return &(_reference_counted_object->getObject());
        }
 
        auto operator->() noexcept -> pointer
        {
            return &(_reference_counted_object->getObject());
        }
 
        auto operator*() noexcept -> reference
        {
            return *(this->operator->());
        }
 
        auto operator*() const noexcept -> const_reference
        {
            return *(this->operator->());
        }
 
    private:
        reference_counted_object_pointer _reference_counted_object;
    }; // IntrusivePtr
 
    template <typename T, typename... Args>
    static auto makeIntrusive(Args&&... args) -> IntrusivePtr<T>;
 
private:
    struct Implementation;
    IntrusivePtr<Implementation> _impl;
};
 
} // namespace system
} // namespace a_util

#include <a_util/system/detail/timer_impl.h>
 
#endif // A_UTIL_UTIL_SYSTEM_TIMER_DECL_INCLUDED