Event.hpp

Go to the documentation of this file.

/* Copyright 2021 Jan Stephan
 *
 * Licensed under the EUPL, Version 1.2 or - as soon they will be approved by
 * the European Commission - subsequent versions of the EUPL (the “Licence”).
 * You may not use this work except in compliance with the Licence.
 * You may obtain a copy of the Licence at:
 *
 *     http://ec.europa.eu/idabc/eupl.html
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the Licence is distributed on an “AS IS” basis, WITHOUT
 *  WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 *  Licence permissions and limitations under the Licence.
 */
 
#pragma once
 
#include <bactria/ranges/Category.hpp>
#include <bactria/ranges/Colors.hpp>
#include <bactria/ranges/Marker.hpp>
#include <bactria/ranges/Plugin.hpp>
 
#include <functional>
#include <string>
#include <utility>
 
namespace bactria
{
    namespace ranges
    {
        class Event : public Marker
        {
        public:
            Event() : Marker("BACTRIA_GENERIC_EVENT", color::bactria_orange, Category{})
            {
            }
 
            Event(std::string name, std::uint32_t color = color::bactria_orange, Category category = Category{})
                : Marker(std::move(name), color, std::move(category))
            {
            }
 
            Event(const Event& other)
                : Marker(other)
                , m_handle{plugin::activated() ? plugin::create_event(m_color, m_category.get_c_name(), m_category.get_id()) : nullptr}
                , m_action{other.m_action}
            {
            }
 
            auto operator=(const Event& rhs) -> Event&
            {
                Marker::operator=(rhs);
 
                if(plugin::activated())
                    m_handle = plugin::create_event(m_color, m_category.get_c_name(), m_category.get_id());
                else
                    m_handle = nullptr;
 
                m_action = rhs.m_action;
 
                return *this;
            }
 
            Event(Event&& other) noexcept : Marker(std::move(other)), m_handle{std::exchange(other.m_handle, nullptr)}
            {
                std::swap(m_action, other.m_action);
            }
 
            auto operator=(Event&& rhs) noexcept -> Event&
            {
                Marker::operator=(std::move(rhs));
                m_handle = std::exchange(rhs.m_handle, nullptr);
                std::swap(m_action, rhs.m_action);
 
                return *this;
            }
 
            ~Event() override
            {
                if(plugin::activated())
                    plugin::destroy_event(m_handle);
            }
 
            auto fire(std::string source, std::uint32_t lineno, std::string caller) noexcept -> void
            {
                if(plugin::activated())
                {
                    plugin::fire_event(m_handle, m_action().c_str(), source.c_str(), lineno, caller.c_str());
                }
            }
 
            auto set_action(std::function<std::string(void)> a) noexcept -> void
            {
                m_action = std::move(a);
            }
 
        private:
            void* m_handle{
                plugin::activated() ? plugin::create_event(m_color, m_category.get_c_name(), m_category.get_id())
                                    : nullptr};
            std::function<std::string(void)> m_action = [this]() { return m_name; };
        };
    } // namespace ranges
} // namespace bactria
 
#define bactria_Event(name, color, category)                                                                          \
    {                                                                                                                 \
        auto e = bactria::ranges::Event(name, color, category);                                                       \
        e.fire(__FILE__, __LINE__, __func__);                                                                         \
    }
 
#define bactria_ActionEvent(action, color, category)                                                                  \
    {                                                                                                                 \
        auto e = bactria::ranges::Event("BACTRIA_ACTION_EVENT", color, category);                                     \
        e.set_action(action);                                                                                         \
        e.fire(__FILE__, __LINE__, __func__);                                                                         \
    }