SingleTimeExecutor.hpp

Go to the documentation of this file.

#include <utility>

// @formatter:off
//
// Balau core C++ library
//
// Copyright (C) 2008 Bora Software (contact@borasoftware.com)
//
// Licensed under the Boost Software License - Version 1.0 - August 17th, 2003.
// See the LICENSE file for the full license text.
//


#ifndef COM_BORA_SOFTWARE__BALAU_CONCURRENT__SINGLE_TIME_EXECUTOR
#define COM_BORA_SOFTWARE__BALAU_CONCURRENT__SINGLE_TIME_EXECUTOR

#include <atomic>
#include <functional>
#include <mutex>

namespace Balau::Concurrent {

class SingleTimeExecutor {
    public: explicit SingleTimeExecutor(std::function<void ()> code_)
        : code(std::move(code_))
        , destructorCode() {}

    public: SingleTimeExecutor(std::function<void ()> code_, std::function<void ()> destructorCode_)
        : code(std::move(code_))
        , destructorCode(std::move(destructorCode_)) {}

    public: ~SingleTimeExecutor() {
        bool isExecuted = executed.load(std::memory_order_relaxed);
        std::atomic_thread_fence(std::memory_order_acquire);

        if (isExecuted) {
            std::lock_guard<std::mutex> lock(mutex);
            isExecuted = executed.load(std::memory_order_relaxed);

            if (isExecuted && destructorCode) {
                    destructorCode();
            }
        }
    }

    public: void operator () () {
        bool isExecuted = executed.load(std::memory_order_relaxed);
        std::atomic_thread_fence(std::memory_order_acquire);

        if (!isExecuted) {
            std::lock_guard<std::mutex> lock(mutex);
            isExecuted = executed.load(std::memory_order_relaxed);

            if (!isExecuted && code) {
                code();
                std::atomic_thread_fence(std::memory_order_release);
                executed.store(true, std::memory_order_relaxed);
            }
        }
    }

    public: bool hasExecuted() const {
        return executed;
    }

    public: std::mutex & getMutex() {
        return mutex;
    }


    private: std::function<void ()> code;
    private: std::function<void ()> destructorCode;
    private: std::atomic<bool> executed;
    private: std::mutex mutex;
};

} // namespace Balau::Concurrent

#endif // COM_BORA_SOFTWARE__BALAU_CONCURRENT__SINGLE_TIME_EXECUTOR