Phase.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 <string>
#include <utility>
 
namespace bactria
{
    namespace metrics
    {
        class Phase
        {
        public:
            Phase() = default;
 
            explicit Phase(std::string name) : m_name{std::move(name)}
            {
            }
 
            Phase(std::string name, std::string source, std::uint32_t lineno, std::string caller)
                : m_name{std::move(name)}
            {
                if(plugin::activated())
                    enter(std::move(source), lineno, std::move(caller));
            }
 
            Phase(const Phase&) = delete;
 
            auto operator=(const Phase&) -> Phase& = delete;
 
            Phase(Phase&& other)
                : m_name{std::move(other.m_name)}
                , m_entered{std::exchange(other.m_entered, bool{})}
                , m_handle{std::exchange(other.m_handle, nullptr)}
            {
            }
 
            auto operator=(Phase&& rhs) -> Phase&
            {
                m_name = std::move(rhs.m_name);
                m_handle = std::exchange(rhs.m_handle, nullptr);
                m_entered = std::exchange(rhs.m_entered, bool{});
 
                return *this;
            }
 
            ~Phase()
            {
                if(plugin::activated())
                {
                    if(m_entered)
                        leave(__FILE__, __LINE__, __func__);
 
                    plugin::destroy_phase(m_handle);
                }
            }
 
            auto enter(std::string source, std::uint32_t lineno, std::string caller) -> void
            {
                if(plugin::activated())
                {
                    plugin::enter_phase(m_handle, source.c_str(), lineno, caller.c_str());
                    m_entered = true;
                }
            }
 
            auto leave(std::string source, std::uint32_t lineno, std::string caller) -> void
            {
                if(plugin::activated())
                {
                    plugin::leave_phase(m_handle, source.c_str(), lineno, caller.c_str());
                    m_entered = false;
                }
            }
 
        private:
            std::string m_name{"BACTRIA_GENERIC_PHASE"};
            void* m_handle{plugin::activated() ? plugin::create_phase(m_name.c_str()) : nullptr};
            bool m_entered{false};
        };
    } // namespace metrics
} // namespace bactria
 
#define bactria_Phase(name)                                                                                           \
    ::bactria::metrics::Phase                                                                                         \
    {                                                                                                                 \
        name, __FILE__, __LINE__, __func__                                                                            \
    }