alignment.hpp

Go to the documentation of this file.

// Copyright Take Vos 2019, 2021-2022.
// 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)
 
#pragma once
 
#include "assert.hpp"
#include "cast.hpp"
 
namespace hi::inline v1 {
 
enum class vertical_alignment : uint8_t {
    top = 0,
 
    middle = 1,
 
    bottom = 2
};
 
enum class horizontal_alignment : uint8_t {
    flush = 0,
 
    left = 1,
 
    center = 2,
 
    justified = 3,
 
    right = 4,
};
 
[[nodiscard]] constexpr horizontal_alignment mirror(horizontal_alignment const &rhs) noexcept
{
    if (rhs == horizontal_alignment::left) {
        return horizontal_alignment::right;
    } else if (rhs == horizontal_alignment::right) {
        return horizontal_alignment::left;
    } else {
        return rhs;
    }
}
 
class alignment {
public:
    constexpr alignment() noexcept : _value(0) {}
    constexpr alignment(alignment const &) noexcept = default;
    constexpr alignment(alignment &&) noexcept = default;
    constexpr alignment &operator=(alignment const &) noexcept = default;
    constexpr alignment &operator=(alignment &&) noexcept = default;
 
    constexpr explicit alignment(uint8_t value) noexcept : _value(value) {}
 
    constexpr alignment(horizontal_alignment t, vertical_alignment v) noexcept :
        _value((to_underlying(v) << 4) | to_underlying(t))
    {
        hi_axiom(to_underlying(v) <= 0xf);
        hi_axiom(to_underlying(t) <= 0xf);
    }
 
    constexpr alignment(vertical_alignment v, horizontal_alignment t) noexcept :
        _value((to_underlying(v) << 4) | to_underlying(t))
    {
        hi_axiom(to_underlying(v) <= 0xf);
        hi_axiom(to_underlying(t) <= 0xf);
    }
 
    [[nodiscard]] static constexpr alignment top_flush() noexcept
    {
        return {horizontal_alignment::flush, vertical_alignment::top};
    }
 
    [[nodiscard]] static constexpr alignment top_left() noexcept
    {
        return {horizontal_alignment::left, vertical_alignment::top};
    }
 
    [[nodiscard]] static constexpr alignment top_center() noexcept
    {
        return {horizontal_alignment::center, vertical_alignment::top};
    }
 
    [[nodiscard]] static constexpr alignment top_justified() noexcept
    {
        return {horizontal_alignment::justified, vertical_alignment::top};
    }
 
    [[nodiscard]] static constexpr alignment top_right() noexcept
    {
        return {horizontal_alignment::right, vertical_alignment::top};
    }
 
    [[nodiscard]] static constexpr alignment middle_flush() noexcept
    {
        return {horizontal_alignment::flush, vertical_alignment::middle};
    }
 
    [[nodiscard]] static constexpr alignment middle_left() noexcept
    {
        return {horizontal_alignment::left, vertical_alignment::middle};
    }
 
    [[nodiscard]] static constexpr alignment middle_center() noexcept
    {
        return {horizontal_alignment::center, vertical_alignment::middle};
    }
 
    [[nodiscard]] static constexpr alignment middle_justified() noexcept
    {
        return {horizontal_alignment::justified, vertical_alignment::middle};
    }
 
    [[nodiscard]] static constexpr alignment middle_right() noexcept
    {
        return {horizontal_alignment::right, vertical_alignment::middle};
    }
 
    [[nodiscard]] static constexpr alignment bottom_left() noexcept
    {
        return {horizontal_alignment::left, vertical_alignment::bottom};
    }
 
    [[nodiscard]] static constexpr alignment bottom_center() noexcept
    {
        return {horizontal_alignment::center, vertical_alignment::bottom};
    }
 
    [[nodiscard]] static constexpr alignment bottom_right() noexcept
    {
        return {horizontal_alignment::right, vertical_alignment::bottom};
    }
 
    [[nodiscard]] constexpr horizontal_alignment text() const noexcept
    {
        return static_cast<horizontal_alignment>(_value & 0xf);
    }
 
    [[nodiscard]] constexpr vertical_alignment vertical() const noexcept
    {
        return static_cast<vertical_alignment>(_value >> 4);
    }
 
    [[nodiscard]] constexpr friend bool operator==(alignment const &lhs, alignment const &rhs) noexcept = default;
 
    [[nodiscard]] constexpr friend bool operator==(alignment const &lhs, horizontal_alignment const &rhs) noexcept
    {
        return lhs.text() == rhs;
    }
 
    [[nodiscard]] constexpr friend bool operator==(horizontal_alignment const &lhs, alignment const &rhs) noexcept
    {
        return lhs == rhs.text();
    }
 
    [[nodiscard]] constexpr friend bool operator==(alignment const &lhs, vertical_alignment const &rhs) noexcept
    {
        return lhs.vertical() == rhs;
    }
 
    [[nodiscard]] constexpr friend bool operator==(vertical_alignment const &lhs, alignment const &rhs) noexcept
    {
        return lhs == rhs.vertical();
    }
 
    [[nodiscard]] constexpr friend alignment mirror(alignment const &rhs) noexcept
    {
        return alignment{mirror(rhs.text()), rhs.vertical()};
    }
 
private:
    uint8_t _value;
};
 
constexpr alignment operator|(horizontal_alignment lhs, vertical_alignment rhs) noexcept
{
    return alignment{lhs, rhs};
}
 
constexpr alignment operator|(vertical_alignment lhs, horizontal_alignment rhs) noexcept
{
    return alignment{lhs, rhs};
}
 
} // namespace hi::inline v1