more generalized PointerRange (but only optionally)

octa/range.h

@@ -640,13 +640,20 @@ NumberRange<T> range(T v) {
     return NumberRange<T>(v);
 }
 
-template<typename T>
-struct PointerRange: InputRange<PointerRange<T>, FiniteRandomAccessRangeTag, T> {
+template<typename T,
+    typename R = T &, typename P = T *,
+    typename S = octa::Size, typename D = octa::Ptrdiff
+>
+struct PointerRange: InputRange<
+    PointerRange<T, R, P, S, D>, FiniteRandomAccessRangeTag, T, R, S, D
+> {
+    using Pointer = P;
+
     PointerRange(): p_beg(nullptr), p_end(nullptr) {}
     PointerRange(const PointerRange &v): p_beg(v.p_beg),
         p_end(v.p_end) {}
-    PointerRange(T *beg, T *end): p_beg(beg), p_end(end) {}
-    PointerRange(T *beg, octa::Size n): p_beg(beg), p_end(beg + n) {}
+    PointerRange(Pointer beg, Pointer end): p_beg(beg), p_end(end) {}
+    PointerRange(Pointer beg, octa::Size n): p_beg(beg), p_end(beg + n) {}
 
     PointerRange &operator=(const PointerRange &v) {
         p_beg = v.p_beg;
@@ -666,8 +673,8 @@ struct PointerRange: InputRange<PointerRange<T>, FiniteRandomAccessRangeTag, T>
         --p_beg; return true;
     }
 
-    octa::Size pop_front_n(octa::Size n) {
-        octa::Size olen = p_end - p_beg;
+    S pop_front_n(S n) {
+        S olen = p_end - p_beg;
         p_beg += n;
         if (p_beg > p_end) {
             p_beg = p_end;
@@ -676,17 +683,17 @@ struct PointerRange: InputRange<PointerRange<T>, FiniteRandomAccessRangeTag, T>
         return n;
     }
 
-    octa::Size push_front_n(octa::Size n) {
+    S push_front_n(S n) {
         p_beg -= n; return true;
     }
 
-    T &front() const { return *p_beg; }
+    R front() const { return *p_beg; }
 
     bool equals_front(const PointerRange &range) const {
         return p_beg == range.p_beg;
     }
 
-    octa::Ptrdiff distance_front(const PointerRange &range) const {
+    D distance_front(const PointerRange &range) const {
         return range.p_beg - p_beg;
     }
 
@@ -700,8 +707,8 @@ struct PointerRange: InputRange<PointerRange<T>, FiniteRandomAccessRangeTag, T>
         ++p_end; return true;
     }
 
-    octa::Size pop_back_n(octa::Size n) {
-        octa::Size olen = p_end - p_beg;
+    S pop_back_n(S n) {
+        S olen = p_end - p_beg;
         p_end -= n;
         if (p_end < p_beg) {
             p_end = p_beg;
@@ -710,28 +717,28 @@ struct PointerRange: InputRange<PointerRange<T>, FiniteRandomAccessRangeTag, T>
         return n;
     }
 
-    octa::Size push_back_n(octa::Size n) {
+    S push_back_n(S n) {
         p_end += n; return true;
     }
 
-    T &back() const { return *(p_end - 1); }
+    R back() const { return *(p_end - 1); }
 
     bool equals_back(const PointerRange &range) const {
         return p_end == range.p_end;
     }
 
-    octa::Ptrdiff distance_back(const PointerRange &range) const {
+    D distance_back(const PointerRange &range) const {
         return range.p_end - p_end;
     }
 
     /* satisfy FiniteRandomAccessRange */
-    octa::Size size() const { return p_end - p_beg; }
+    S size() const { return p_end - p_beg; }
 
-    PointerRange slice(octa::Size start, octa::Size end) const {
+    PointerRange slice(S start, S end) const {
         return PointerRange(p_beg + start, p_beg + end);
     }
 
-    T &operator[](octa::Size i) const { return p_beg[i]; }
+    R operator[](S i) const { return p_beg[i]; }
 
     /* satisfy OutputRange */
     void put(const T &v) {
@@ -741,12 +748,8 @@ struct PointerRange: InputRange<PointerRange<T>, FiniteRandomAccessRangeTag, T>
         *(p_beg++) = octa::move(v);
     }
 
-    /* non-range methods */
-    T *data() { return p_beg; }
-    const T *data() const { return p_beg; }
-
 private:
-    T *p_beg, *p_end;
+    P p_beg, p_end;
 };
 
 template<typename T, octa::Size N>

octa/vector.h

@@ -125,8 +125,12 @@ public:
     using ConstReference = const T &;
     using Pointer = octa::AllocatorPointer<A>;
     using ConstPointer = octa::AllocatorConstPointer<A>;
-    using Range = octa::PointerRange<T>;
-    using ConstRange = octa::PointerRange<const T>;
+    using Range = octa::PointerRange<Value, Reference, Pointer, Size,
+        Difference
+    >;
+    using ConstRange = octa::PointerRange<const Value, ConstReference,
+        ConstPointer, Size, Difference
+    >;
     using Allocator = A;
 
     Vector(const A &a = A()): p_buf(nullptr, a), p_len(0), p_cap(0) {}