utils.h

#ifndef PROBFD_ALGORITHMS_UTILS_H
#define PROBFD_ALGORITHMS_UTILS_H
 
#include "probfd/value_type.h"
 
#include <cassert>
#include <cstddef>
#include <tuple>
#include <utility>
 
// Forward Declarations
namespace probfd {
struct Interval;
}
 
namespace probfd::algorithms {
 
template <typename... T>
class ClearGuard {
    std::tuple<T&...> containers_;
 
public:
    explicit ClearGuard(T&... containers)
        : containers_(containers...)
    {
        assert((containers.empty() && ...));
    }
 
    ~ClearGuard()
    {
        std::apply([](auto&... c) { (c.clear(), ...); }, containers_);
    }
};
 
template <size_t n>
struct get_t {
    template <typename T>
    decltype(auto) operator()(T&& t) const
    {
        using std::get;
        return get<n>(std::forward<T>(t));
    }
};
 
template <size_t n>
inline constexpr get_t<n> project;
 
value_t as_lower_bound(Interval interval);
 
value_t as_lower_bound(value_t single);
 
Interval as_interval(value_t lower_bound);
 
Interval as_interval(Interval value);
 
bool set_min(Interval& lhs, Interval rhs);
 
bool set_min(value_t& lhs, value_t rhs);
 
bool update(Interval& lhs, Interval rhs, value_t epsilon = g_epsilon);
 
// Value update
bool update(value_t& lhs, value_t rhs, value_t epsilon = g_epsilon);
 
} // namespace probfd::algorithms
 
#endif