ts_resource.hpp

#ifndef OPENLIBRARY_PALGORITHM_TS_RESOURCE
#define OPENLIBRARY_PALGORITHM_TS_RESOURCE

#include <cassert>

#include <mutex>
#include <memory>
#include <ostream>

namespace ol
{


    template<typename T>
    class ThreadSafeResource
    {
        public:
            struct INotify
            {
                virtual ~INotify() {}
                virtual void unlocked() = 0;                       
            };


            struct Accessor
            {
                Accessor(std::mutex& mutex, T* object): m_lock(mutex), m_object(object), m_notify(nullptr) {}

                Accessor(Accessor&& other): m_lock(std::move(other.m_lock)),
                                            m_object(other.m_object),
                                            m_notify(other.m_notify)
                {
                    other.m_object = nullptr;
                    other.m_notify = nullptr;
                }

                Accessor(): m_lock(), m_object(nullptr), m_notify(nullptr) {}

                Accessor(std::unique_lock<std::mutex>&& lock, T* object): m_lock(std::move(lock)), m_object(object), m_notify(nullptr) {}
                Accessor(const Accessor &) = delete;

                Accessor& operator=(const Accessor &) = delete;

                Accessor& operator=(Accessor&& other)
                {
                    m_lock = std::move(other.m_lock);
                    m_object = other.m_object;
                    m_notify = other.m_notify;

                    other.m_object = nullptr;
                    other.m_notify = nullptr;

                    return *this;
                }


                virtual ~Accessor()
                {
                    if (m_lock)
                        m_lock.unlock();

                    if (m_notify != nullptr)
                        m_notify->unlocked();
                }

                T& get()
                {
                    return *m_object;
                }

                const T& get() const
                {
                    return *m_object;
                }

                T* operator->()
                {
                    return m_object;
                }

                const T* operator->() const
                {
                    return m_object;
                }

                T& operator*()
                {
                    return *m_object;
                }

                const T& operator*() const
                {
                    return *m_object;
                }


                bool is_valid() const
                {
                    return m_object != nullptr;
                }

                private:
                    friend class ThreadSafeResource;
                    std::unique_lock<std::mutex> m_lock;
                    T* m_object;
                    INotify* m_notify;

                    void set(INotify* notify)
                    {
                        m_notify = notify;
                    }
            };


            template<typename... Args>
            ThreadSafeResource(const Args&... args): m_mutex(), m_resource(args...)
            {
            }

            ~ThreadSafeResource()
            {
                // point of this lock is te be sure resource is not used (no live Accessors exist)
                std::unique_lock<std::mutex> l(m_mutex);
            }

            ThreadSafeResource(const ThreadSafeResource<T> &) = delete;
            ThreadSafeResource<T>& operator=(const ThreadSafeResource<T> &) = delete;

            Accessor lock()
            {
                Accessor accessor(m_mutex, &m_resource);

                return accessor;
            }

            Accessor lock(INotify* notify)
            {
                Accessor accessor = lock();
                accessor.set(notify);

                return accessor;
            }


            Accessor try_lock()
            {
                std::unique_lock<std::mutex> l(m_mutex, std::defer_lock);
                const bool locked = l.try_lock();
                Accessor result;

                if (locked)
                    result = Accessor(std::move(l), &m_resource);

                return result;
            }

        private:
            std::mutex m_mutex;
            T m_resource;
    };

}

#endif