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();
 
        [[nodiscard]] 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();
 
    inline 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);
 
inline Range::Range()
  : RANGE()
{
  clear();
}
 
inline Range::Range(const Range& r)
  : RANGE(r)
{
  assign(r);
}
 
inline Range::Range(const RANGE& r)
  : RANGE()
{
  set(r);
}
 
inline Range::Range(size_type start, size_type stop, id_type id)
  : RANGE()
{
  assign(start, stop, id);
}
 
inline Range::size_type Range::getStart() const
{
  return _start;
}
 
inline Range::size_type Range::getStop() const
{
  return _stop;
}
 
inline Range::id_type Range::getId() const
{
  return _id;
}
 
inline Range& Range::setId(id_type id)
{
  _id = id;
  return *this;
}
 
inline void Range::clear()
{
  _start = 0;
  _stop = 0;
  _id = 0;
}
 
inline Range& Range::assign(const Range& r)
{
  *(RANGE*) this = *(RANGE*) &r;
  return *this;
}
 
inline Range::size_type Range::getSize() const
{
  return _stop - _start;
}
 
inline Range::size_type Range::split(size_type seg_sz, Vector& rl_dst) const
{
  return split(seg_sz, *this, rl_dst);
}
 
inline bool Range::isEmpty() const
{
  return (_stop == _start);
}
 
inline Range& Range::operator=(const Range& r)
{
  assign(r);
  return *this;
}
 
inline Range& Range::operator=(const RANGE& r)
{
  set(r);
  return *this;
}
 
inline const RANGE& Range::getBase() const
{
  return *this;
}
 
inline Range::operator bool() const
{
  return isEmpty();
}
 
inline bool Range::operator==(const Range& r) const
{
  return compare(r) == cmpSame && (!RangeCompareExact || _id == r._id);
}
 
inline bool Range::operator!=(const Range& r) const
{
  return !(compare(r) == cmpSame && (!RangeCompareExact || _id == r._id));
}
 
inline bool Range::operator<(const Range& r) const
{
  return !isEmpty() && (r.isEmpty() || ((_start == r._start) ? _stop < r._stop : _start < r._start));
}
 
inline Range& Range::operator+=(const Range& r)
{
  return assign(*this + r);
}
 
inline Range& Range::operator&=(const Range& r)
{
  return assign(*this & r);
}
 
inline Range& Range::offsetBy(size_type ofs)
{
  _start += ofs;
  _stop += ofs;
  return *this;
}
 
inline Range Range::offset(size_type ofs) const
{
  return Range(*this).offsetBy(ofs);
}
 
inline bool Range::isInRange(size_type idx) const
{
  return idx >= _start && idx < _stop;
}
 
inline const Range& Range::copyTo(RANGE& dst) const
{
  dst = *this;
  return *this;
}
 
}// namespace sf