Range.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/Colors.hpp>
#include <bactria/ranges/Marker.hpp>
#include <bactria/ranges/Plugin.hpp>
 
#include <cstdint>
#include <string>
#include <utility>
 
namespace bactria
{
    namespace ranges
    {
        class Range : public Marker
        {
        public:
            Range() : Marker("BACTRIA_GENERIC_RANGE", color::bactria_cyan, Category{})
            {
            }
 
            Range(
                std::string name,
                std::uint32_t color = color::bactria_cyan,
                Category category = Category{},
                bool autostart = true)
                : Marker(std::move(name), color, std::move(category))
            {
                if(autostart && plugin::activated())
                    start();
            }
 
            Range(Range const& other)
            : Marker(other), m_handle{plugin::activated() ? plugin::create_range(m_name.c_str(), m_color, m_category.get_c_name(), m_category.get_id()) : nullptr}
            , m_started{other.m_started}
            {
                if(m_started && plugin::activated())
                    plugin::start_range(m_handle);
            }
 
            auto operator=(Range const& rhs) -> Range&
            {
                Marker::operator=(rhs);
                if(plugin::activated())
                {
                    m_handle
                        = plugin::create_range(m_name.c_str(), m_color, m_category.get_c_name(), m_category.get_id());
                    m_started = rhs.m_started;
 
                    if(m_started)
                        plugin::start_range(m_handle);
                }
 
                return *this;
            }
 
            Range(Range&& other) noexcept
                : Marker(std::move(other))
                , m_handle{std::exchange(other.m_handle, nullptr)}
                , m_started{std::exchange(other.m_started, bool{})}
            {
            }
 
            auto operator=(Range&& rhs) noexcept -> Range&
            {
                Marker::operator=(std::move(rhs));
                m_handle = std::exchange(rhs.m_handle, nullptr);
                m_started = std::exchange(rhs.m_started, bool{});
 
                return *this;
            }
 
            ~Range() override
            {
                if(plugin::activated())
                {
                    stop();
                    plugin::destroy_range(m_handle);
                }
            }
 
            auto start() noexcept -> void
            {
                if(!m_started && plugin::activated())
                {
                    plugin::start_range(m_handle);
                    m_started = true;
                }
            }
 
            auto stop() noexcept -> void
            {
                if(m_started && plugin::activated())
                {
                    plugin::stop_range(m_handle);
                    m_started = false;
                }
            }
 
            auto is_running() const noexcept -> bool
            {
                return m_started;
            }
 
        private:
            void* m_handle{
                plugin::activated()
                    ? plugin::create_range(m_name.c_str(), m_color, m_category.get_c_name(), m_category.get_id())
                    : nullptr};
            bool m_started{false};
        };
    } // namespace ranges
} // namespace bactria