/* * Copyright © 2018 Google, Inc. * Copyright © 2019 Facebook, 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 * Facebook Author(s): Behdad Esfahbod */ #ifndef HB_ITER_HH #define HB_ITER_HH #include "hb.hh" #include "hb-algs.hh" #include "hb-meta.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. * * If iterator implementation implements operator!=, then it can be * used in range-based for loop. That already happens if the iterator * is random-access. Otherwise, the range-based for loop incurs * one traversal to find end(), which can be avoided if written * as a while-style for loop, or if iterator implements a faster * __end__() method. */ /* * Base classes for iterators. */ /* Base class for all iterators. */ template <typename iter_t, typename Item = typename iter_t::__item_t__> struct hb_iter_t { … }; #define HB_ITER_USING(Name) … /* Returns iterator / item type of a type. */ hb_iter_type; hb_item_type; template <typename> struct hb_array_t; template <typename> struct hb_sorted_array_t; struct { … } HB_FUNCOBJ(…); struct { … } HB_FUNCOBJ(…); /* Mixin to fill in what the subclass doesn't provide. */ template <typename iter_t, typename item_t = typename iter_t::__item_t__> struct hb_iter_fallback_mixin_t { … }; template <typename iter_t, typename item_t = typename iter_t::__item_t__> struct hb_iter_with_fallback_t : hb_iter_t<iter_t, item_t>, hb_iter_fallback_mixin_t<iter_t, item_t> { … }; /* * Meta-programming predicates. */ /* hb_is_iterator() / hb_is_iterator_of() */ template<typename Iter, typename Item> struct hb_is_iterator_of { … }; #define hb_is_iterator_of(Iter, Item) … #define hb_is_iterator(Iter) … #define hb_is_sorted_iterator_of(Iter, Item) … #define hb_is_sorted_iterator(Iter) … /* hb_is_iterable() */ template <typename T> struct hb_is_iterable { … }; #define hb_is_iterable(Iterable) … /* hb_is_source_of() / hb_is_sink_of() */ template<typename Iter, typename Item> struct hb_is_source_of { … }; #define hb_is_source_of(Iter, Item) … template<typename Iter, typename Item> struct hb_is_sink_of { … }; #define hb_is_sink_of(Iter, Item) … /* This is commonly used, so define: */ #define hb_is_sorted_source_of(Iter, Item) … /* Range-based 'for' for iterables. */ template <typename Iterable, hb_requires (hb_is_iterable (Iterable))> static inline auto begin (Iterable&& iterable) HB_AUTO_RETURN (hb_iter (iterable).begin ()) template <typename Iterable, hb_requires (hb_is_iterable (Iterable))> static inline auto end (Iterable&& iterable) HB_AUTO_RETURN (hb_iter (iterable).end ()) /* begin()/end() are NOT looked up non-ADL. So each namespace must declare them. * Do it for namespace OT. */ OT /* * Adaptors, combiners, etc. */ template <typename Lhs, typename Rhs, hb_requires (hb_is_iterator (Lhs))> static inline auto operator | (Lhs&& lhs, Rhs&& rhs) HB_AUTO_RETURN (std::forward<Rhs> (rhs) (std::forward<Lhs> (lhs))) /* hb_map(), hb_filter(), hb_reduce() */ enum class hb_function_sortedness_t { … }; template <typename Iter, typename Proj, hb_function_sortedness_t Sorted, hb_requires (hb_is_iterator (Iter))> struct hb_map_iter_t : hb_iter_t<hb_map_iter_t<Iter, Proj, Sorted>, decltype (hb_get (hb_declval (Proj), *hb_declval (Iter)))> { … }; template <typename Proj, hb_function_sortedness_t Sorted> struct hb_map_iter_factory_t { … }; struct { … } HB_FUNCOBJ(…); struct { … } HB_FUNCOBJ(…); struct { … } HB_FUNCOBJ(…); template <typename Iter, typename Pred, typename Proj, hb_requires (hb_is_iterator (Iter))> struct hb_filter_iter_t : hb_iter_with_fallback_t<hb_filter_iter_t<Iter, Pred, Proj>, typename Iter::item_t> { … }; template <typename Pred, typename Proj> struct hb_filter_iter_factory_t { … }; struct { … } HB_FUNCOBJ(…); template <typename Redu, typename InitT> struct hb_reduce_t { … }; struct { … } HB_FUNCOBJ(…); /* hb_zip() */ template <typename A, typename B> struct hb_zip_iter_t : hb_iter_t<hb_zip_iter_t<A, B>, hb_pair_t<typename A::item_t, typename B::item_t>> { … }; struct { … } HB_FUNCOBJ(…); /* hb_concat() */ template <typename A, typename B> struct hb_concat_iter_t : hb_iter_t<hb_concat_iter_t<A, B>, typename A::item_t> { … }; struct { … } HB_FUNCOBJ(…); /* hb_apply() */ template <typename Appl> struct hb_apply_t { … }; struct { … } HB_FUNCOBJ(…); /* hb_range()/hb_iota()/hb_repeat() */ template <typename T, typename S> struct hb_range_iter_t : hb_iter_t<hb_range_iter_t<T, S>, T> { … }; struct { … } HB_FUNCOBJ(…); template <typename T, typename S> struct hb_iota_iter_t : hb_iter_with_fallback_t<hb_iota_iter_t<T, S>, T> { … }; struct { … } HB_FUNCOBJ(…); template <typename T> struct hb_repeat_iter_t : hb_iter_t<hb_repeat_iter_t<T>, T> { … }; struct { … } HB_FUNCOBJ(…); /* hb_enumerate()/hb_take() */ struct { … } HB_FUNCOBJ(…); struct { … } HB_FUNCOBJ(…); struct { … } HB_FUNCOBJ(…); /* hb_sink() */ template <typename Sink> struct hb_sink_t { … }; struct { … } HB_FUNCOBJ(…); /* hb-drain: hb_sink to void / blackhole / /dev/null. */ struct { … } HB_FUNCOBJ(…); /* hb_unzip(): unzip and sink to two sinks. */ template <typename Sink1, typename Sink2> struct hb_unzip_t { … }; struct { … } HB_FUNCOBJ(…); /* hb-all, hb-any, hb-none. */ struct { … } HB_FUNCOBJ(…); struct { … } HB_FUNCOBJ(…); struct { … } HB_FUNCOBJ(…); /* * Algorithms operating on iterators. */ template <typename C, typename V, hb_requires (hb_is_iterable (C))> inline void hb_fill (C&& c, const V &v) { … } template <typename S, typename D> inline void hb_copy (S&& is, D&& id) { … } #endif /* HB_ITER_HH */
Codebase Browser
chromium