generic.hpp

Go to the documentation of this file.

 
#pragma once
 
// #include <algorithm> // import std::min, std::max
#include <cassert>
// #include <cmath>  // for abs
 
namespace recti {
    template <typename T> constexpr auto my_abs(const T& value) -> T {
        return value < 0 ? -value : value;
    }
 
    template <typename U1, typename U2>  //
    constexpr auto overlap(const U1& lhs, const U2& rhs) -> bool {
        if constexpr (requires { lhs.overlaps(rhs); }) {
            return lhs.overlaps(rhs);
        } else if constexpr (requires { rhs.overlaps(lhs); }) {
            return rhs.overlaps(lhs);
        } else /* constexpr */ {
            return lhs == rhs;
        }
    }
 
    template <typename U1, typename U2>  //
    constexpr auto contain(const U1& lhs, const U2& rhs) -> bool {
        if constexpr (requires { lhs.contains(rhs); }) {
            return lhs.contains(rhs);
        } else if constexpr (requires { rhs.contains(lhs); }) {
            return false;
        } else /* constexpr */ {
            return lhs == rhs;
        }
    }
 
    template <typename U1, typename U2>  //
    constexpr auto intersection(const U1& lhs, const U2& rhs) {
        if constexpr (requires { lhs.intersect_with(rhs); }) {
            return lhs.intersect_with(rhs);
        } else if constexpr (requires { rhs.intersect_with(lhs); }) {
            return rhs.intersect_with(lhs);
        } else /* constexpr */ {
            assert(lhs == rhs);
            return lhs;
        }
    }
 
    template <typename U1, typename U2>  //
    constexpr auto min_dist(const U1& lhs, const U2& rhs) {
        if constexpr (requires { lhs.min_dist_with(rhs); }) {
            return lhs.min_dist_with(rhs);
        } else if constexpr (requires { rhs.min_dist_with(lhs); }) {
            return rhs.min_dist_with(lhs);
        } else /* constexpr */ {
            return my_abs(lhs - rhs);
        }
    }
 
    template <typename U1, typename U2>  //
    constexpr auto min_dist_change(U1& lhs, U2& rhs) {
        if constexpr (requires { lhs.min_dist_change_with(rhs); }) {
            return lhs.min_dist_change_with(rhs);
        } else if constexpr (requires { rhs.min_dist_change_with(lhs); }) {
            return rhs.min_dist_change_with(lhs);
        } else /* constexpr */ {
            return my_abs(lhs - rhs);
        }
    }
 
    template <typename U1, typename U2> constexpr auto nearest(const U1& lhs, const U2& rhs) {
        if constexpr (requires { lhs.nearest_to(rhs); }) {
            return lhs.nearest_to(rhs);
        } else {
            return lhs;
        }
    }
 
    template <typename U> constexpr auto measure_of(const U& obj) {
        if constexpr (requires { obj.measure(); }) {
            return obj.measure();
        } else {
            return 1;
        }
    }
 
    template <typename U> constexpr auto center(const U& obj) {
        if constexpr (requires { obj.get_center(); }) {
            return obj.get_center();
        } else {
            return obj;
        }
    }
 
    template <typename U> constexpr auto lower(const U& obj) {
        if constexpr (requires { obj.lower_corner(); }) {
            return obj.lower_corner();
        } else {
            return obj;
        }
    }
 
    template <typename U> constexpr auto upper(const U& obj) {
        if constexpr (requires { obj.upper_corner(); }) {
            return obj.upper_corner();
        } else {
            return obj;
        }
    }
}  // namespace recti