6497034454

Committed 12 Oct 2023 02:27PM UTC coverage: 86.872% (-12.8%) from 99.712%

Build # 6497034454

Build Type

Pull #71

github

Committed by

web-flow

Commit Message

Merge 967744a15 into e4166ac5d

Pull Request Pull Request #71: graph namespace

Run Details

281 of 281 new or added lines in 17 files covered. (100.0%)

622 of 716 relevant lines covered (86.87%)

154.67 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

85.71

/include/Simple-Utility/CRTPBase.hpp

//          Copyright Dominic Koepke 2019 - 2023.
// Distributed under the Boost Software License, Version 1.0.
//    (See accompanying file LICENSE_1_0.txt or copy at
//          https://www.boost.org/LICENSE_1_0.txt)

#ifndef SIMPLE_UTILITY_CRTP_BASE_HPP
#define SIMPLE_UTILITY_CRTP_BASE_HPP

#pragma once

#include "Simple-Utility/concepts/stl_extensions.hpp"

namespace sl
{
        /**
         * \brief Utility type, which can be used as a base class for the crtp pattern.
         * \tparam Derived The derived type.
         * \tparam Disambiguity In cases of multiple inheritance, this param can be used to disambiguity the base class.
         */
        template <concepts::unqualified Derived, class Disambiguity = void>
        class CRTPBase
        {
        protected:
                /**
                 * \brief Up-casts the this pointer to a const lvalue reference to ``Derived``.
                 * \return A const lvalue reference.
                 */
                [[nodiscard]]
                constexpr const Derived& derived() const noexcept
                {
                        return static_cast<const Derived&>(*this);
                }

                /**
                 * \brief Up-casts the this pointer to a lvalue reference to ``Derived``.
                 * \return A lvalue reference.
                 */
                [[nodiscard]]
                constexpr Derived& derived() noexcept
                {
                        return static_cast<Derived&>(*this);
                }

                /**
                 * \brief Default constructor, performing compile-time checks.
                 */
                constexpr CRTPBase() noexcept
                {
                        static_assert(std::is_base_of_v<CRTPBase, Derived>, "Derived doesn't inherit from CRTPBase.");
                }

                /**
                 * \brief Defaulted copy-constructor.
                 */
                CRTPBase(const CRTPBase&) = default;

                /**
                 * \brief Defaulted copy-assignment operator.
                 */
                CRTPBase& operator =(const CRTPBase&) = default;

                /**
                 * \brief Defaulted move-constructor.
                 */
                CRTPBase(CRTPBase&&) = default;

                /**
                 * \brief Defaulted move-assignment operator.
                 */
                CRTPBase& operator =(CRTPBase&&) = default;

                /**
                 * \brief Defaulted destructor.
                 */
                ~CRTPBase() = default;

                /**
                 * \brief Defaulted equality operator.
                 * \return Returns true, if both operators are equal.
                 */
                [[nodiscard]]
                constexpr bool operator ==(const CRTPBase&) const noexcept = default;
        };
}

#endif

1	// Copyright Dominic Koepke 2019 - 2023.
2	// Distributed under the Boost Software License, Version 1.0.
3	// (See accompanying file LICENSE_1_0.txt or copy at
4	// https://www.boost.org/LICENSE_1_0.txt)
5
6	#ifndef SIMPLE_UTILITY_CRTP_BASE_HPP
7	#define SIMPLE_UTILITY_CRTP_BASE_HPP
8
9	#pragma once
10
11	#include "Simple-Utility/concepts/stl_extensions.hpp"
12
13	namespace sl
14	{
15	/**
16	* \brief Utility type, which can be used as a base class for the crtp pattern.
17	* \tparam Derived The derived type.
18	* \tparam Disambiguity In cases of multiple inheritance, this param can be used to disambiguity the base class.
19	*/
20	template <concepts::unqualified Derived, class Disambiguity = void>
21	class CRTPBase
22	{
23	protected:
24	/**
25	* \brief Up-casts the this pointer to a const lvalue reference to ``Derived``.
26	* \return A const lvalue reference.
27	*/
28	[[nodiscard]]
29	constexpr const Derived& derived() const noexcept	270✔
30	{
31	return static_cast<const Derived&>(*this);	270✔
32	}
33
34	/**
35	* \brief Up-casts the this pointer to a lvalue reference to ``Derived``.
36	* \return A lvalue reference.
37	*/
38	[[nodiscard]]
39	constexpr Derived& derived() noexcept	263✔
40	{
41	return static_cast<Derived&>(*this);	263✔
42	}
43
44	/**
45	* \brief Default constructor, performing compile-time checks.
46	*/
47	constexpr CRTPBase() noexcept	278✔
48	{
49	static_assert(std::is_base_of_v<CRTPBase, Derived>, "Derived doesn't inherit from CRTPBase.");
50	}	278✔
51
52	/**
53	* \brief Defaulted copy-constructor.
54	*/
55	CRTPBase(const CRTPBase&) = default;
56
57	/**
58	* \brief Defaulted copy-assignment operator.
59	*/
60	CRTPBase& operator =(const CRTPBase&) = default;
61
62	/**
63	* \brief Defaulted move-constructor.
64	*/
65	CRTPBase(CRTPBase&&) = default;
66
67	/**
68	* \brief Defaulted move-assignment operator.
69	*/
70	CRTPBase& operator =(CRTPBase&&) = default;
71
72	/**
73	* \brief Defaulted destructor.
74	*/
75	~CRTPBase() = default;
76
77	/**
78	* \brief Defaulted equality operator.
79	* \return Returns true, if both operators are equal.
80	*/
81	[[nodiscard]]
82	constexpr bool operator ==(const CRTPBase&) const noexcept = default;	×
83	};
84	}
85
86	#endif

DNKpp / Simple-Utility / 6497034454

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous