kislager::lenses Namespace Reference

Variables
template<typename Src , typename Dst , typename SrcConstRef = std::add_lvalue_reference_t<std::add_const_t<Src>>>
auto	do_static_cast
constexpr auto	logical_not
template<typename T >
auto	scale
constexpr auto	scale_int_to_real
constexpr auto	scale_real_to_int
template<typename Base >
auto	to_base
template<typename Derived , typename Base , typename = std::enable_if_t< std::is_base_of_v<Base, Derived>>>
auto	to_base2
template<typename T >
auto	variant_to

Variable Documentation

do_static_cast

template<typename Src , typename Dst , typename SrcConstRef = std::add_lvalue_reference_t<std::add_const_t<Src>>>

auto kislager::lenses::do_static_cast

Initial value:

= lager::lenses::getset(
    [] (SrcConstRef value) { return static_cast<Dst>(value); },
    [] (Src, Dst value) { return static_cast<Src>(value); }
    )

Definition at line 69 of file KisLager.h.

logical_not

constexpr auto kislager::lenses::logical_not

constexpr

Initial value:

= [] {
    return lager::lenses::getset(
        [](bool value) -> bool {
            return !value;
        },
        [](bool, bool value) -> bool {
            return !value;
        });
}

Definition at line 114 of file KisLager.h.

                                {
    return lager::lenses::getset(
        [](bool value) -> bool {
            return !value;
        },
        [](bool, bool value) -> bool {
            return !value;
        });
};

scale

template<typename T >

auto kislager::lenses::scale

Initial value:

= [] (T multiplier) {
    return lager::lenses::getset(
        [multiplier] (T value) { return value * multiplier; },
        [multiplier] (T, T value) { return value / multiplier; }
        );
}

Definition at line 47 of file KisLager.h.

                               {
    return lager::lenses::getset(
        [multiplier] (T value) { return value * multiplier; },
        [multiplier] (T, T value) { return value / multiplier; }
        );
};

scale_int_to_real

constexpr auto kislager::lenses::scale_int_to_real

constexpr

Initial value:

= [] (qreal multiplier) {
    return lager::lenses::getset(
        [multiplier] (int value) { return value * multiplier; },
        [multiplier] (int, qreal value) { return qRound(value / multiplier); }
        );
}

Definition at line 54 of file KisLager.h.

                                                         {
    return lager::lenses::getset(
        [multiplier] (int value) { return value * multiplier; },
        [multiplier] (int, qreal value) { return qRound(value / multiplier); }
        );
};

scale_real_to_int

constexpr auto kislager::lenses::scale_real_to_int

constexpr

Initial value:

= [] (qreal multiplier) {
    return lager::lenses::getset(
        [multiplier] (qreal value) { return qRound(value * multiplier); },
        [multiplier] (qreal, int value) { return value / multiplier; }
        );
}

Definition at line 61 of file KisLager.h.

                                                         {
    return lager::lenses::getset(
        [multiplier] (qreal value) { return qRound(value * multiplier); },
        [multiplier] (qreal, int value) { return value / multiplier; }
        );
};

to_base

template<typename Base >

auto kislager::lenses::to_base

Initial value:

= lager::lenses::getset(
    [] (const auto &value) -> Base { return static_cast<const Base&>(value); },
    [] (auto src, const Base &value) { static_cast<Base&>(src) = value; return src; }
    )

A lens that accesses a base class Base of the derived type Derived

to_base variant accepts only one type Base, that is, destination type into which we should convert the value to

Definition at line 98 of file KisLager.h.

to_base2

template<typename Derived , typename Base , typename = std::enable_if_t< std::is_base_of_v<Base, Derived>>>

auto kislager::lenses::to_base2

Initial value:

= lager::lenses::getset(
    [] (const Derived &value) -> Base { return static_cast<const Base&>(value); },
    [] (Derived src, const Base &value) { static_cast<Base&>(src) = value; return src; }
    )

A lens that accesses a base class Base of the derived type Derived

to_base2 variant accepts two types, Base and Derived, which might be convenient for debugging.

Definition at line 84 of file KisLager.h.

variant_to

template<typename T >

auto kislager::lenses::variant_to

Initial value:

= lager::lenses::getset(
    [] (const QVariant &src) {
        return src.value<T>();
    },
    [] (QVariant src, const T &value) {
        src = QVariant::fromValue<T>(value);
        return src;
    }
)

Definition at line 104 of file KisLager.h.