Sector.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/metrics/Plugin.hpp>
#include <bactria/metrics/Tags.hpp>
 
#include <functional>
#include <iostream>
#include <string>
#include <type_traits>
#include <utility>
 
namespace bactria
{
    namespace metrics
    {
        template<typename TTag = Generic>
        class Sector final
        {
        public:
            Sector() = default;
 
            Sector(std::string sector_name) : m_name{std::move(sector_name)}
            {
            }
 
            Sector(std::string sector_name, std::string source, std::uint32_t lineno, std::string caller)
                : m_name{std::move(sector_name)}
            {
                if(plugin::activated())
                {
                    plugin::enter_sector(m_handle, source.c_str(), lineno, caller.c_str());
                    m_entered = true;
                }
            }
 
            Sector(Sector const&) = delete;
 
            auto operator=(Sector const&) -> Sector& = delete;
 
            Sector(Sector&& other)
                : m_name{std::move(other.m_name)}
                , m_handle{std::exchange(other.m_handle, nullptr)}
                , m_entered{std::exchange(other.m_entered, bool{})}
                , m_summary{std::exchange(other.m_summary, bool{})}
                , m_on_enter{std::move(other.m_on_enter)}
                , m_on_leave{std::move(other.m_on_leave)}
            {
            }
 
            auto operator=(Sector&& rhs) -> Sector&
            {
                m_name = std::move(rhs.m_name);
                m_handle = std::exchange(rhs.m_handle, nullptr);
                m_entered = std::exchange(rhs.m_entered, bool{});
                m_summary = std::exchange(rhs.m_summary, bool{});
                m_on_enter = std::move(rhs.m_on_enter);
                m_on_leave = std::move(rhs.m_on_leave);
 
                return *this;
            }
 
            ~Sector()
            {
                if(plugin::activated())
                {
                    if(m_entered)
                        leave(__FILE__, __LINE__, __func__);
 
                    if(!m_summary)
                        summary();
 
                    plugin::destroy_sector(m_handle);
                }
            }
 
            auto enter(std::string source, std::uint32_t lineno, std::string caller) -> void
            {
                if(plugin::activated())
                {
                    plugin::enter_sector(m_handle, source.c_str(), lineno, caller.c_str());
                    m_on_enter();
                    m_entered = true;
                }
            }
 
            auto leave(std::string source, std::uint32_t lineno, std::string caller) -> void
            {
                if(plugin::activated())
                {
                    m_on_leave();
                    plugin::leave_sector(m_handle, source.c_str(), lineno, caller.c_str());
                    m_entered = false;
                }
            }
 
            auto summary() -> void
            {
                if(plugin::activated())
                {
                    plugin::sector_summary(m_handle);
                    m_summary = true;
                }
            }
 
            auto on_enter(std::function<void(void)> f) -> void
            {
                if(plugin::activated())
                    m_on_enter = f;
            }
 
            auto on_leave(std::function<void(void)> f) -> void
            {
                if(plugin::activated())
                    m_on_leave = f;
            }
 
        private:
            std::string m_name{"BACTRIA_GENERIC_SECTOR"};
            void* m_handle{plugin::activated() ? plugin::create_sector(m_name.c_str(), TTag::value) : nullptr};
            bool m_entered{false};
            bool m_summary{false};
            std::function<void(void)> m_on_enter = []() {};
            std::function<void(void)> m_on_leave = []() {};
        };
 
    } // namespace metrics
} // namespace bactria
 
#define bactria_Sector(name, tag)                                                                                     \
    ::bactria::metrics::Sector<tag>                                                                                   \
    {                                                                                                                 \
        name, __FILE__, __LINE__, __func__                                                                            \
    }
 
#define bactria_Enter(sec) sec.enter(__FILE__, __LINE__, __func__)
 
#define bactria_Leave(sec) sec.leave(__FILE__, __LINE__, __func__)