RangeSet.h

#pragma once
 
#include <xrpl/beast/core/LexicalCast.h>
 
#include <boost/algorithm/string.hpp>
#include <boost/icl/closed_interval.hpp>
#include <boost/icl/interval_set.hpp>
 
#include <functional>
#include <optional>
#include <string>
#include <vector>
 
namespace xrpl {

template <class T>
using ClosedInterval = boost::icl::closed_interval<T>;

template <class T>
ClosedInterval<T>
range(T low, T high)
{
    return ClosedInterval<T>(low, high);
}

template <class T>
using RangeSet = boost::icl::interval_set<T, std::less, ClosedInterval<T>>;

template <class T>
std::string
to_string(ClosedInterval<T> const& ci)
{
    if (ci.first() == ci.last())
        return std::to_string(ci.first());
    return std::to_string(ci.first()) + "-" + std::to_string(ci.last());
}

template <class T>
std::string
to_string(RangeSet<T> const& rs)
{
    if (rs.empty())
        return "empty";
 
    std::string s;
    for (auto const& interval : rs)
        s += xrpl::to_string(interval) + ",";
    s.pop_back();
 
    return s;
}

template <class T>
[[nodiscard]] bool
fromString(RangeSet<T>& rs, std::string const& s)
{
    std::vector<std::string> intervals;
    std::vector<std::string> tokens;
    bool result{true};
 
    rs.clear();
    boost::split(tokens, s, boost::algorithm::is_any_of(","));
    for (auto const& t : tokens)
    {
        boost::split(intervals, t, boost::algorithm::is_any_of("-"));
        switch (intervals.size())
        {
            case 1: {
                T front;
                if (!beast::lexicalCastChecked(front, intervals.front()))
                {
                    result = false;
                }
                else
                {
                    rs.insert(front);
                }
                break;
            }
            case 2: {
                T front;
                if (!beast::lexicalCastChecked(front, intervals.front()))
                {
                    result = false;
                }
                else
                {
                    T back;
                    if (!beast::lexicalCastChecked(back, intervals.back()))
                    {
                        result = false;
                    }
                    else
                    {
                        rs.insert(range(front, back));
                    }
                }
                break;
            }
            default:
                result = false;
        }
 
        if (!result)
            break;
        intervals.clear();
    }
 
    if (!result)
        rs.clear();
    return result;
}

template <class T>
std::optional<T>
prevMissing(RangeSet<T> const& rs, T t, T minVal = 0)
{
    if (rs.empty() || t == minVal)
        return std::nullopt;
    RangeSet<T> tgt{ClosedInterval<T>{minVal, t - 1}};
    tgt -= rs;
    if (tgt.empty())
        return std::nullopt;
    return boost::icl::last(tgt);
}
 
}  // namespace xrpl