dimensions.h

Go to the documentation of this file.

/*
 * Copyright © Canonical Ltd.
 *
 * This program is free software: you can redistribute it and/or modify it
 * under the terms of the GNU Lesser General Public License version 2 or 3,
 * as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */
 
#ifndef MIR_GEOMETRY_DIMENSIONS_H_
#define MIR_GEOMETRY_DIMENSIONS_H_
 
#include "forward.h"
 
#include <iosfwd>
#include <type_traits>
#include <cstdint>
 
namespace mir
{
namespace geometry
{
namespace generic
{
template<typename T, typename Tag>
/// Wraps a geometry value and prevents it from being accidentally used for invalid operations (such as setting a
/// width to a height or adding two x positions together). Of course, explicit casts are possible to get around
/// these restrictions (see the as_*() functions).
struct Value
{
    using ValueType = T;
    using TagType = Tag;
 
    template <typename Q = T>
    constexpr typename std::enable_if<std::is_integral<Q>::value, int>::type as_int() const
    {
        return this->value;
    }
 
    template <typename Q = T>
    constexpr typename std::enable_if<std::is_integral<Q>::value, uint32_t>::type as_uint32_t() const
    {
        return this->value;
    }
 
    constexpr T as_value() const noexcept
    {
        return value;
    }
 
    constexpr Value() noexcept : value{} {}
 
    Value& operator=(Value const& that) noexcept
    {
        value = that.value;
        return *this;
    }
 
    constexpr Value(Value const& that) noexcept
        : value{that.value}
    {
    }
 
    template<typename U>
    explicit constexpr Value(Value<U, Tag> const& value) noexcept
        : value{static_cast<T>(value.as_value())}
    {
    }
 
    template<typename U, typename std::enable_if<std::is_scalar<U>::value, bool>::type = true>
    explicit constexpr Value(U const& value) noexcept
        : value{static_cast<T>(value)}
    {
    }
 
    inline constexpr auto operator == (Value<T, Tag> const& rhs) const -> bool
    {
        return value == rhs.as_value();
    }
 
    inline constexpr auto operator != (Value<T, Tag> const& rhs) const -> bool
    {
        return value != rhs.as_value();
    }
 
    inline constexpr auto operator <= (Value<T, Tag> const& rhs) const -> bool
    {
        return value <= rhs.as_value();
    }
 
    inline constexpr auto operator >= (Value<T, Tag> const& rhs) const -> bool
    {
        return value >= rhs.as_value();
    }
 
    inline constexpr auto operator < (Value<T, Tag> const& rhs) const -> bool
    {
        return value < rhs.as_value();
    }
 
    inline constexpr auto operator > (Value<T, Tag> const& rhs) const -> bool
    {
        return value > rhs.as_value();
    }
 
protected:
    T value;
};
 
template<typename T, typename Tag>
std::ostream& operator<<(std::ostream& out, Value<T, Tag> const& value)
{
    out << value.as_value();
    return out;
}
 
// Adding deltas is fine
template<typename T>
inline constexpr DeltaX<T> operator+(DeltaX<T> lhs, DeltaX<T> rhs){ return DeltaX<T>(lhs.as_value() + rhs.as_value()); }
template<typename T>
inline constexpr DeltaY<T> operator+(DeltaY<T> lhs, DeltaY<T> rhs) { return DeltaY<T>(lhs.as_value() + rhs.as_value()); }
template<typename T>
inline constexpr DeltaX<T> operator-(DeltaX<T> lhs, DeltaX<T> rhs) { return DeltaX<T>(lhs.as_value() - rhs.as_value()); }
template<typename T>
inline constexpr DeltaY<T> operator-(DeltaY<T> lhs, DeltaY<T> rhs) { return DeltaY<T>(lhs.as_value() - rhs.as_value()); }
template<typename T>
inline constexpr DeltaX<T> operator-(DeltaX<T> rhs) { return DeltaX<T>(-rhs.as_value()); }
template<typename T>
inline constexpr DeltaY<T> operator-(DeltaY<T> rhs) { return DeltaY<T>(-rhs.as_value()); }
template<typename T>
inline DeltaX<T>& operator+=(DeltaX<T>& lhs, DeltaX<T> rhs) { return lhs = lhs + rhs; }
template<typename T>
inline DeltaY<T>& operator+=(DeltaY<T>& lhs, DeltaY<T> rhs) { return lhs = lhs + rhs; }
template<typename T>
inline DeltaX<T>& operator-=(DeltaX<T>& lhs, DeltaX<T> rhs) { return lhs = lhs - rhs; }
template<typename T>
inline DeltaY<T>& operator-=(DeltaY<T>& lhs, DeltaY<T> rhs) { return lhs = lhs - rhs; }
 
// Adding deltas to co-ordinates is fine
template<typename T>
inline constexpr X<T> operator+(X<T> lhs, DeltaX<T> rhs) { return X<T>(lhs.as_value() + rhs.as_value()); }
template<typename T>
inline constexpr Y<T> operator+(Y<T> lhs, DeltaY<T> rhs) { return Y<T>(lhs.as_value() + rhs.as_value()); }
template<typename T>
inline constexpr X<T> operator-(X<T> lhs, DeltaX<T> rhs) { return X<T>(lhs.as_value() - rhs.as_value()); }
template<typename T>
inline constexpr Y<T> operator-(Y<T> lhs, DeltaY<T> rhs) { return Y<T>(lhs.as_value() - rhs.as_value()); }
template