src/hb-iter.hh

   1 /*
   2  * Copyright © 2018  Google, Inc.
   3  *
   4  *  This is part of HarfBuzz, a text shaping library.
   5  *
   6  * Permission is hereby granted, without written agreement and without
   7  * license or royalty fees, to use, copy, modify, and distribute this
   8  * software and its documentation for any purpose, provided that the
   9  * above copyright notice and the following two paragraphs appear in
  10  * all copies of this software.
  11  *
  12  * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR
  13  * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
  14  * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN
  15  * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
  16  * DAMAGE.
  17  *
  18  * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,
  19  * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
  20  * FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS
  21  * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO
  22  * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
  23  *
  24  * Google Author(s): Behdad Esfahbod
  25  */
  26
  27 #ifndef HB_ITER_HH
  28 #define HB_ITER_HH
  29
  30 #include "hb.hh"
  31 #include "hb-null.hh"
  32
  33
  34 /* Unified iterator object.
  35  *
  36  * The goal of this template is to make the same iterator interface
  37  * available to all types, and make it very easy and compact to use.
  38  * hb_iter_tator objects are small, light-weight, objects that can be
  39  * copied by value.  If the collection / object being iterated on
  40  * is writable, then the iterator returns lvalues, otherwise it
  41  * returns rvalues.
  42  */
  43
  44 /* Base class for all iterators. */
  45 template <typename Iter, typename Item = typename Iter::__item_type__>
  46 struct hb_iter_t
  47 {
  48   typedef Iter iter_t;
  49   typedef iter_t const_iter_t;
  50   typedef Item item_t;
  51   static constexpr unsigned item_size = hb_static_size (Item);
  52
  53   private:
  54   /* https://en.wikipedia.org/wiki/Curiously_recurring_template_pattern */
  55   const iter_t* thiz () const { return static_cast<const iter_t *> (this); }
  56         iter_t* thiz ()       { return static_cast<      iter_t *> (this); }
  57   public:
  58
  59   /* Operators. */
  60   operator iter_t () { return iter(); }
  61   explicit_operator bool () const { return more (); }
  62   item_t& operator * () const { return item (); }
  63   item_t& operator [] (signed i) const { return item_at ((unsigned) i); }
  64   iter_t& operator += (unsigned count) { forward (count); return *thiz(); }
  65   iter_t& operator ++ () { next (); return *thiz(); }
  66   iter_t& operator -= (unsigned count) { rewind (count); return *thiz(); }
  67   iter_t& operator -- () { prev (); return *thiz(); }
  68   iter_t operator + (unsigned count) { iter_t c (*thiz()); c += count; return c; }
  69   iter_t operator ++ (int) { iter_t c (*thiz()); ++*thiz(); return c; }
  70   iter_t operator - (unsigned count) { iter_t c (*thiz()); c -= count; return c; }
  71   iter_t operator -- (int) { iter_t c (*thiz()); --*thiz(); return c; }
  72
  73   /* Methods. */
  74   iter_t iter () const { return *thiz(); }
  75   const_iter_t const_iter () const { return iter (); }
  76   item_t& item () const { return thiz()->__item__ (); }
  77   item_t& item_at (unsigned i) const { return thiz()->__item_at__ (i); }
  78   bool more () const { return thiz()->__more__ (); }
  79   unsigned len () const { return thiz()->__len__ (); }
  80   void next () { thiz()->__next__ (); }
  81   void forward (unsigned n) { thiz()->__forward__ (n); }
  82   void prev () { thiz()->__prev__ (); }
  83   void rewind (unsigned n) { thiz()->__rewind__ (n); }
  84   bool random_access () const { return thiz()->__random_access__ (); }
  85
  86   protected:
  87   hb_iter_t () {}
  88   hb_iter_t (const hb_iter_t &o HB_UNUSED) {}
  89   void operator = (const hb_iter_t &o HB_UNUSED) {}
  90 };
  91
  92 /* Base class for sorted iterators.  Does not enforce anything.
  93  * Just for class taxonomy and requirements. */
  94 template <typename Iter, typename Item = typename Iter::__item_type__>
  95 struct hb_sorted_iter_t : hb_iter_t<Iter, Item>
  96 {
  97   protected:
  98   hb_sorted_iter_t () {}
  99   hb_sorted_iter_t (const hb_sorted_iter_t &o) : hb_iter_t<Iter, Item> (o) {}
 100   void operator = (const hb_sorted_iter_t &o HB_UNUSED) {}
 101 };
 102
 103 /* Mixin to fill in what the subclass doesn't provide. */
 104 template <typename iter_t, typename item_t = typename iter_t::__item_type__>
 105 struct hb_iter_mixin_t
 106 {
 107   private:
 108   /* https://en.wikipedia.org/wiki/Curiously_recurring_template_pattern */
 109   const iter_t* thiz () const { return static_cast<const iter_t *> (this); }
 110         iter_t* thiz ()       { return static_cast<      iter_t *> (this); }
 111   public:
 112
 113   /* Access: Implement __item__(), or __item_at__() if random-access. */
 114   item_t& __item__ () const { return thiz()->item_at (0); }
 115   item_t& __item_at__ (unsigned i) const { return *(thiz() + i); }
 116
 117   /* Termination: Implement __more__(), or __len__() if random-access. */
 118   bool __more__ () const { return thiz()->__len__ (); }
 119   unsigned __len__ () const
 120   { iter_t c (*thiz()); unsigned l = 0; while (c) { c++; l++; }; return l; }
 121
 122   /* Advancing: Implement __next__(), or __forward__() if random-access. */
 123   void __next__ () { thiz()->forward (1); }
 124   void __forward__ (unsigned n) { while (n--) thiz()->next (); }
 125
 126   /* Rewinding: Implement __prev__() or __rewind__() if bidirectional. */
 127   void __prev__ () { thiz()->rewind (1); }
 128   void __rewind__ (unsigned n) { while (n--) thiz()->prev (); }
 129
 130   /* Random access: Return true if item_at(), len(), forward() are fast. */
 131   bool __random_access__ () const { return false; }
 132 };
 133
 134
 135 /* Functions operating on iterators or iteratables. */
 136
 137 template <typename C, typename V> inline void
 138 hb_fill (const C& c, const V &v)
 139 {
 140   for (typename C::iter_t i (c); i; i++)
 141     hb_assign (*i, v);
 142 }
 143
 144 template <typename S, typename D> inline bool
 145 hb_copy (hb_iter_t<D> &id, hb_iter_t<S> &is)
 146 {
 147   for (; id && is; ++id, ++is)
 148     *id = *is;
 149   return !is;
 150 }
 151
 152
 153 #endif /* HB_ITER_HH */