Range.h

Go to the documentation of this file.

#pragma once
#include <iostream>
#include <limits>
#include <misc/gen/TVector.h>
#include <misc/global.h>
 
namespace sf
{
 
_MISC_DATA extern bool RangeCompareExact;
 
// Packed structure for binary storage.
#pragma pack(push, 1)
 
struct RANGE
{
    typedef uint64_t size_type;
    typedef int64_t id_type;
    size_type _start;
    size_type _stop;
    id_type _id;
};
 
// Restore the pack option.
#pragma pack(pop)
 
class _MISC_CLASS Range : private RANGE
{
  public:
    typedef RANGE::size_type size_type;
    typedef RANGE::id_type id_type;
 
    class _MISC_CLASS Vector : public TVector<Range>
    {
      public:
        Vector& sort();
 
        [[nodiscard]] Vector sort() const;
 
        Vector& rearrange();
 
        Vector exclude(const Vector& rel) const;
 
        Vector& exclude(const Vector& rl_ex);
 
        Vector extract(const Vector& rl, Vector& rl_ex) const;
 
        Vector& merge(const Vector& rl_add);
    };
 
    typedef Vector::iter_type Iterator;
 
    inline Range();
 
    Range& operator=(Range&&) = default;
 
    inline Range(const Range& r);
 
    explicit inline Range(const RANGE& r);
 
    inline Range(size_type start, size_type stop, id_type id = 0);
 
    void normalize();
 
    Range& assign(size_type start, size_type stop, id_type id = 0);
 
    inline Range& assign(const Range& r);
 
    Range& set(const RANGE& r);
 
    inline const Range& copyTo(RANGE& dst) const;
 
    [[nodiscard]] inline size_type getStart() const;
 
    [[nodiscard]] inline size_type getStop() const;
 
    inline void clear();
 
    [[nodiscard]] inline size_type getSize() const;
 
    [[nodiscard]] inline bool isEmpty() const;
 
    [[nodiscard]] bool isOverlapped(const Range& r) const;
 
    [[nodiscard]] bool isWithinOther(const Range& r) const;
 
    [[nodiscard]] bool isWithinSelf(const Range& r) const;
 
    [[nodiscard]] bool isExtension(const Range& r) const;
 
    [[nodiscard]] bool isMergeable(const Range& r) const;
 
    inline size_type split(size_type seg_sz, Vector& rl_dst) const;
 
    static size_type split(size_type seg_sz, const Range& req, Vector& rl_dst);
 
    static size_type split(size_type seg_sz, const Vector& req, Vector& rl);
 
    [[nodiscard]] inline bool isInRange(size_type idx) const;
 
    const RANGE& getBase() const;
 
    explicit inline operator bool() const;
 
    enum ECompare : int
    {
      cmpError = std::numeric_limits<int>::max(),
      cmpSame = 0,
      cmpWithinSelf = 1,
      cmpWithinOther = -1,
      cmpOverlapsOther = 2,
      cmpOverlapsSelf = -2,
      cmpExtendsOther = 3,
      cmpExtendsSelf = -3,
      cmpBeforeSelf = 4,
      cmpAfterSelf = -4,
      cmpSelfEmpty = 5,
      cmpOtherEmpty = -5,
    };
 
    [[nodiscard]] ECompare compare(const Range& other) const;
 
    [[nodiscard]] inline id_type getId() const;
 
    inline Range& setId(id_type id);
 
    inline Range& operator=(const Range& r);
 
    inline Range& operator=(const RANGE& r);
 
    inline bool operator==(const Range& r) const;
 
    inline bool operator!=(const Range& r) const;
 
    inline bool operator<(const Range& r) const;
 
    Range operator&(const Range& r) const;
 
    inline Range& operator&=(const Range& r);
 
    Range operator+(const Range& r) const;
 
    inline Range& operator+=(const Range& r);
 
    int exclude(const Range& r, Range& rest, Range::ECompare* cmp = nullptr);
 
    inline Range& offsetBy(size_type ofs);
 
    [[nodiscard]] inline Range offset(size_type ofs) const;
 
    bool operator>(const Range& r) const = delete;
 
    bool operator>(const Range& r) = delete;
 
    bool operator<=(const Range& r) const = delete;
 
    bool operator<=(const Range& r) = delete;
 
    bool operator>=(const Range& r) const = delete;
 
    bool operator>=(const Range& r) = delete;
 
  private:
    friend std::ostream& operator<<(std::ostream& os, const Range& r);
    friend std::istream& operator>>(std::istream& is, Range& r);
};
 
_MISC_FUNC std::ostream& operator<<(std::ostream& os, const Range& r);
 
_MISC_FUNC std::istream& operator>>(std::istream& is, Range& r);
 
_MISC_FUNC std::ostream& operator<<(std::ostream& os, const Range::Vector& rl);
 
_MISC_FUNC std::istream& operator>>(std::istream& is, Range::Vector& rl);
 
}// namespace sf
 
// Include all inlined functions and template implementations.
#include <misc/gen/Range.hpp>