pattern.h

/*
 * Copyright (C) 2018 Microchip Technology Inc.  All rights reserved.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
#ifndef EGT_PATTERN_H
#define EGT_PATTERN_H
 
#include <cassert>
#include <egt/color.h>
#include <egt/detail/meta.h>
#include <egt/geometry.h>
#include <egt/types.h>
#include <vector>
 
namespace egt
{
inline namespace v1
{
 
namespace detail
{
class InternalPattern;
}
 
/*
 * gcc < 7.2 with c++14 support contains a bug dealing with constexpr on some
 * member functions.  clang seems to handle this correctly.
 *
 *     pattern.h:88:27: error: enclosing class of constexpr non-static member
 *         function ‘egt::v1::Pattern::operator egt::v1::Color() const’ is not a literal type
 *
 * This is further explained here:  https://gcc.gnu.org/bugzilla/show_bug.cgi?id=66297
 *
 * Conditionally use constexpr in this case.
 */
#if defined(__clang__)
#  define EGT_PATTERN_CONSTEXPR constexpr
#elif defined(__GNUC__)
#  if (__GNUC__ < 7 || (__GNUC__ == 7 && __GNUC_MINOR__ < 2))
#    define EGT_PATTERN_CONSTEXPR
#  else
#    define EGT_PATTERN_CONSTEXPR constexpr
#  endif
#else
#  define EGT_PATTERN_CONSTEXPR constexpr
#endif
 
class EGT_API Pattern
{
public:
 
    enum class Type
    {
        solid,
        linear,
        linear_vertical,
        radial
    };
 
    using StepScaler = float;
 
    using StepArray = std::vector<std::pair<float, Color>>;
 
    Pattern() noexcept = default;
 
    Pattern(const Pattern& rhs);
    Pattern(Pattern&& rhs) noexcept;
    Pattern& operator=(const Pattern& rhs);
    Pattern& operator=(Pattern&& rhs) noexcept;
 
    ~Pattern() noexcept;
 
    // cppcheck-suppress noExplicitConstructor
    // NOLINTNEXTLINE(hicpp-explicit-conversions, google-explicit-constructor)
    constexpr Pattern(const Color& color) noexcept
        : m_color(color)
    {}
 
    explicit Pattern(Type type, const StepArray& steps = {});
 
    Pattern(const StepArray& steps,
            const Point& start,
            const Point& end);
 
    Pattern(const StepArray& steps,
            const Point& start,
            float start_radius,
            const Point& end,
            float end_radius);
 
    bool operator==(const Pattern& rhs) const;
    bool operator!=(const Pattern& rhs) const
    {
        return !operator==(rhs);
    }
 
    // NOLINTNEXTLINE(hicpp-explicit-conversions, google-explicit-constructor)
    EGT_PATTERN_CONSTEXPR operator Color() const
    {
        return solid();
    }
 
    EGT_PATTERN_CONSTEXPR Color solid() const
    {
        if (m_type != Type::solid)
            throw std::runtime_error("requested solid color in pattern that is not a solid color");
        return m_color;
    }
 
    EGT_DEPRECATED EGT_NODISCARD Color color() const
    {
        return first();
    }
 
    EGT_NODISCARD Color first() const;
 
    Pattern& step(StepScaler offset, const Color& color);
 
    EGT_NODISCARD Type type() const { return m_type; }
 
    void linear(const Point& start, const Point& end);
 
    void radial(const Point& start, float start_radius,
                const Point& end, float end_radius);
 
    EGT_NODISCARD Point starting() const;
    EGT_NODISCARD float starting_radius() const;
    EGT_NODISCARD Point ending() const;
    EGT_NODISCARD float ending_radius() const;
 
    EGT_NODISCARD const StepArray& steps() const;
 
    EGT_NODISCARD const detail::InternalPattern& pattern() const
    {
        if (!m_pattern)
            create_pattern();
        assert(m_pattern.get());
        return *m_pattern;
    }
 
protected:
 
    void create_pattern() const;
 
    static bool sort_by_first(const std::pair<float, Color>& a,
                              const std::pair<float, Color>& b)
    {
        return (a.first < b.first);
    }
 
    Type m_type{Type::solid};
 
    Color m_color;
 
    struct PatternImpl;
    PatternImpl* m_impl{nullptr};
 
    mutable std::shared_ptr<detail::InternalPattern> m_pattern;
};
 
static_assert(detail::rule_of_5<Pattern>(), "must fulfill rule of 5");
 
}
}
 
#endif