/* * Copyright © 2018 Google, Inc. * * This is part of HarfBuzz, a text shaping library. * * Permission is hereby granted, without written agreement and without * license or royalty fees, to use, copy, modify, and distribute this * software and its documentation for any purpose, provided that the * above copyright notice and the following two paragraphs appear in * all copies of this software. * * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH * DAMAGE. * * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. * * Google Author(s): Behdad Esfahbod */ #ifndef HB_ITER_HH #define HB_ITER_HH #include "hb.hh" #include "hb-dsalgs.hh" // for hb_addressof #include "hb-meta.hh" #include "hb-null.hh" /* Unified iterator object. * * The goal of this template is to make the same iterator interface * available to all types, and make it very easy and compact to use. * hb_iter_tator objects are small, light-weight, objects that can be * copied by value. If the collection / object being iterated on * is writable, then the iterator returns lvalues, otherwise it * returns rvalues. */ /* * Base classes for iterators. */ /* Base class for all iterators. */ template struct hb_iter_t { typedef Iter iter_t; typedef Item item_t; enum { item_size = hb_static_size (Item) }; enum { is_iterator = true }; enum { is_random_access_iterator = false }; enum { is_sorted_iterator = false }; private: /* https://en.wikipedia.org/wiki/Curiously_recurring_template_pattern */ const iter_t* thiz () const { return static_cast (this); } iter_t* thiz () { return static_cast< iter_t *> (this); } public: /* TODO: * Port operators below to use hb_enable_if to sniff which method implements * an operator and use it, and remove hb_iter_mixin_t completely. */ /* Operators. */ iter_t iter () const { return *thiz(); } explicit_operator bool () const { return thiz()->__more__ (); } unsigned len () const { return thiz()->__len__ (); } hb_remove_reference (item_t)* operator -> () const { return hb_addressof (**thiz()); } item_t operator * () const { return thiz()->__item__ (); } item_t operator [] (unsigned i) const { return thiz()->__item_at__ (i); } iter_t& operator += (unsigned count) { thiz()->__forward__ (count); return *thiz(); } iter_t& operator ++ () { thiz()->__next__ (); return *thiz(); } iter_t& operator -= (unsigned count) { thiz()->__rewind__ (count); return *thiz(); } iter_t& operator -- () { thiz()->__prev__ (); return *thiz(); } iter_t operator + (unsigned count) const { iter_t c (*thiz()); c += count; return c; } friend iter_t operator + (unsigned count, const iter_t &it) { return it + count; } iter_t operator ++ (int) { iter_t c (*thiz()); ++*thiz(); return c; } iter_t operator - (unsigned count) const { iter_t c (*thiz()); c -= count; return c; } iter_t operator -- (int) { iter_t c (*thiz()); --*thiz(); return c; } protected: hb_iter_t () {} hb_iter_t (const hb_iter_t &o HB_UNUSED) {} void operator = (const hb_iter_t &o HB_UNUSED) {} }; #define HB_ITER_USING(Name) \ using iter_t = typename Name::iter_t; \ using item_t = typename Name::item_t; \ using Name::item_size; \ using Name::is_iterator; \ using Name::iter; \ using Name::operator bool; \ using Name::len; \ using Name::operator ->; \ using Name::operator *; \ using Name::operator []; \ using Name::operator +=; \ using Name::operator ++; \ using Name::operator -=; \ using Name::operator --; \ using Name::operator +; \ using Name::operator -; \ static_assert (true, "") /* Mixin to fill in what the subclass doesn't provide. */ template struct hb_iter_mixin_t { private: /* https://en.wikipedia.org/wiki/Curiously_recurring_template_pattern */ const iter_t* thiz () const { return static_cast (this); } iter_t* thiz () { return static_cast< iter_t *> (this); } public: /* Access: Implement __item__(), or __item_at__() if random-access. */ item_t __item__ () const { return (*thiz())[0]; } item_t __item_at__ (unsigned i) const { return *(*thiz() + i); } /* Termination: Implement __more__(), or __len__() if random-access. */ bool __more__ () const { return thiz()->len (); } unsigned __len__ () const { iter_t c (*thiz()); unsigned l = 0; while (c) { c++; l++; }; return l; } /* Advancing: Implement __next__(), or __forward__() if random-access. */ void __next__ () { *thiz() += 1; } void __forward__ (unsigned n) { while (n--) ++*thiz(); } /* Rewinding: Implement __prev__() or __rewind__() if bidirectional. */ void __prev__ () { *thiz() -= 1; } void __rewind__ (unsigned n) { while (n--) --*thiz(); } protected: hb_iter_mixin_t () {} hb_iter_mixin_t (const hb_iter_mixin_t &o HB_UNUSED) {} void operator = (const hb_iter_mixin_t &o HB_UNUSED) {} }; /* * Meta-programming predicates. */ /* hb_is_iterable() */ template struct _hb_is_iterable { enum { value = false }; }; template struct _hb_is_iterable > { enum { value = true }; }; template struct hb_is_iterable { enum { value = _hb_is_iterable::value }; }; #define hb_is_iterable(Iterable) hb_is_iterable::value /* TODO Add hb_is_iterable_of(). * TODO Add random_access / sorted variants. */ /* hb_is_iterator() / hb_is_random_access_iterator() / hb_is_sorted_iterator() */ template struct _hb_is_iterator_of { char operator () (...) { return 0; } template int operator () (hb_iter_t *) { return 0; } template int operator () (hb_iter_t *) { return 0; } template int operator () (hb_iter_t *) { return 0; } template int operator () (hb_iter_t *) { return 0; } static_assert (sizeof (char) != sizeof (int), ""); }; template struct hb_is_iterator_of { enum { value = sizeof (int) == sizeof (hb_declval (_hb_is_iterator_of) (hb_declval (Iter*))) }; }; #define hb_is_iterator_of(Iter, Item) hb_is_iterator_of::value #define hb_is_iterator(Iter) hb_is_iterator_of (Iter, typename Iter::item_t) #define hb_is_random_access_iterator_of(Iter, Item) \ hb_is_iterator_of (Iter, Item) && Iter::is_random_access_iterator #define hb_is_random_access_iterator(Iter) \ hb_is_random_access_iterator_of (Iter, typename Iter::item_t) #define hb_is_sorted_iterator_of(Iter, Item) \ hb_is_iterator_of (Iter, Item) && Iter::is_sorted_iterator #define hb_is_sorted_iterator(Iter) \ hb_is_sorted_iterator_of (Iter, typename Iter::item_t) /* * Algorithms operating on iterators or iteratables. */ template inline hb_enable_if_t (hb_is_iterable (C), void) hb_fill (C& c, const V &v) { for (typename C::iter_t i (c); i; i++) hb_assign (*i, v); } template inline hb_enable_if_t (hb_is_iterator (S) && hb_is_iterator (D), bool) hb_copy (D id, S is) { for (; id && is; ++id, ++is) *id = *is; return !is; } template struct hb_zip_t : hb_iter_t, hb_pair_t > { hb_zip_t () {} hb_zip_t (A a, B b) : a (a), b (b) {} typedef hb_pair_t __item_t__; enum { is_random_access_iterator = A::is_random_access_iterator && B::is_random_access_iterator }; enum { is_sorted_iterator = A::is_sorted_iterator && B::is_sorted_iterator }; __item_t__ __item__ () const { return __item_t__ (*a, *b); } __item_t__ __item_at__ (unsigned i) const { return __item_t__ (a[i], b[i]); } bool __more__ () const { return a && b; } unsigned __len__ () const { return MIN (a.len (), b.len ()); } void __next__ () { ++a; ++b; } void __forward__ (unsigned n) { a += n; b += n; } void __prev__ () { --a; --b; } void __rewind__ (unsigned n) { a -= n; b -= n; } private: A a; B b; }; template inline typename hb_enable_if >::type hb_zip (A& a, B &b) { return hb_zip_t (a.iter (), b.iter ()); } #endif /* HB_ITER_HH */