add zip for single iterator pairs
parent
c953ef3544
commit
9860845831
|
|
@ -1,6 +1,6 @@
|
|||
cmake_minimum_required(VERSION 3.20)
|
||||
include(cmake/color.cmake)
|
||||
set(BLT_VERSION 2.1.13)
|
||||
set(BLT_VERSION 2.1.14)
|
||||
|
||||
set(BLT_TARGET BLT)
|
||||
|
||||
|
|
|
|||
|
|
@ -30,7 +30,7 @@
|
|||
|
||||
namespace blt::iterator
|
||||
{
|
||||
template<typename Derived>
|
||||
template <typename Derived>
|
||||
struct base_wrapper
|
||||
{
|
||||
base_wrapper operator++(int)
|
||||
|
|
@ -39,7 +39,7 @@ namespace blt::iterator
|
|||
++*this;
|
||||
return tmp;
|
||||
}
|
||||
|
||||
|
||||
base_wrapper operator--(int)
|
||||
{
|
||||
static_assert(meta::is_bidirectional_or_better_category_v<typename Derived::iterator_category>, "Iterator must allow random access");
|
||||
|
|
@ -47,347 +47,373 @@ namespace blt::iterator
|
|||
--*this;
|
||||
return tmp;
|
||||
}
|
||||
|
||||
|
||||
auto operator[](blt::ptrdiff_t n) const
|
||||
{
|
||||
static_assert(meta::is_random_access_iterator_category_v<typename Derived::iterator_category>, "Iterator must allow random access");
|
||||
return *(*this + n);
|
||||
}
|
||||
|
||||
|
||||
friend base_wrapper operator+(blt::ptrdiff_t n, const base_wrapper& a)
|
||||
{
|
||||
return a + n;
|
||||
}
|
||||
|
||||
|
||||
friend bool operator<(const base_wrapper& a, const base_wrapper& b)
|
||||
{
|
||||
static_assert(meta::is_random_access_iterator_category_v<typename Derived::iterator_category>, "Iterator must allow random access");
|
||||
return b - a > 0;
|
||||
}
|
||||
|
||||
|
||||
friend bool operator>(const base_wrapper& a, const base_wrapper& b)
|
||||
{
|
||||
static_assert(meta::is_random_access_iterator_category_v<typename Derived::iterator_category>, "Iterator must allow random access");
|
||||
return b < a;
|
||||
}
|
||||
|
||||
|
||||
friend bool operator>=(const base_wrapper& a, base_wrapper& b)
|
||||
{
|
||||
static_assert(meta::is_random_access_iterator_category_v<typename Derived::iterator_category>, "Iterator must allow random access");
|
||||
return !(a < b); // NOLINT
|
||||
}
|
||||
|
||||
|
||||
friend bool operator<=(const base_wrapper& a, const base_wrapper& b)
|
||||
{
|
||||
static_assert(meta::is_random_access_iterator_category_v<typename Derived::iterator_category>, "Iterator must allow random access");
|
||||
return !(a > b); // NOLINT
|
||||
}
|
||||
|
||||
|
||||
friend bool operator==(const base_wrapper& a, const base_wrapper& b)
|
||||
{
|
||||
return static_cast<const Derived&>(a).base() == static_cast<const Derived&>(b).base();
|
||||
}
|
||||
|
||||
|
||||
friend bool operator!=(const base_wrapper& a, const base_wrapper& b)
|
||||
{
|
||||
return !(static_cast<const Derived&>(a).base() == static_cast<const Derived&>(b).base()); // NOLINT
|
||||
}
|
||||
};
|
||||
|
||||
template<typename Iter, typename Derived, bool dereference = false>
|
||||
|
||||
template <typename Iter, typename Derived, bool dereference = false>
|
||||
struct passthrough_wrapper : public base_wrapper<Derived>
|
||||
{
|
||||
public:
|
||||
explicit passthrough_wrapper(Iter iter): iter(std::move(iter))
|
||||
{}
|
||||
|
||||
auto base() const
|
||||
{
|
||||
return iter;
|
||||
}
|
||||
|
||||
friend blt::ptrdiff_t operator-(const passthrough_wrapper& a, const passthrough_wrapper& b)
|
||||
{
|
||||
return a.base() - b.base();
|
||||
}
|
||||
|
||||
protected:
|
||||
mutable Iter iter;
|
||||
public:
|
||||
explicit passthrough_wrapper(Iter iter): iter(std::move(iter))
|
||||
{
|
||||
}
|
||||
|
||||
auto base() const
|
||||
{
|
||||
return iter;
|
||||
}
|
||||
|
||||
friend blt::ptrdiff_t operator-(const passthrough_wrapper& a, const passthrough_wrapper& b)
|
||||
{
|
||||
return a.base() - b.base();
|
||||
}
|
||||
|
||||
protected:
|
||||
mutable Iter iter;
|
||||
};
|
||||
|
||||
template<typename Iter, typename Derived>
|
||||
|
||||
template <typename Iter, typename Derived>
|
||||
struct passthrough_wrapper<Iter, Derived, true> : public passthrough_wrapper<Iter, Derived>
|
||||
{
|
||||
using passthrough_wrapper<Iter, Derived>::passthrough_wrapper;
|
||||
|
||||
|
||||
meta::deref_return_t<Iter> operator*() const
|
||||
{
|
||||
return *this->iter;
|
||||
}
|
||||
};
|
||||
|
||||
template<typename Iter, typename Derived>
|
||||
|
||||
template <typename Iter, typename Derived>
|
||||
class deref_only_wrapper : public passthrough_wrapper<Iter, Derived, false>
|
||||
{
|
||||
public:
|
||||
using passthrough_wrapper<Iter, Derived, false>::passthrough_wrapper;
|
||||
|
||||
deref_only_wrapper& operator++()
|
||||
{
|
||||
++this->iter;
|
||||
return *this;
|
||||
}
|
||||
|
||||
deref_only_wrapper& operator--()
|
||||
{
|
||||
--this->iter;
|
||||
return *this;
|
||||
}
|
||||
|
||||
deref_only_wrapper& operator+(blt::ptrdiff_t n)
|
||||
{
|
||||
static_assert(meta::is_random_access_iterator_v<Iter>, "Iterator must allow random access");
|
||||
this->iter = this->iter + n;
|
||||
return *this;
|
||||
}
|
||||
|
||||
deref_only_wrapper& operator-(blt::ptrdiff_t n)
|
||||
{
|
||||
static_assert(meta::is_random_access_iterator_v<Iter>, "Iterator must allow random access");
|
||||
this->iter = this->iter - n;
|
||||
return *this;
|
||||
}
|
||||
public:
|
||||
using passthrough_wrapper<Iter, Derived, false>::passthrough_wrapper;
|
||||
|
||||
deref_only_wrapper& operator++()
|
||||
{
|
||||
++this->iter;
|
||||
return *this;
|
||||
}
|
||||
|
||||
deref_only_wrapper& operator--()
|
||||
{
|
||||
--this->iter;
|
||||
return *this;
|
||||
}
|
||||
|
||||
deref_only_wrapper& operator+(blt::ptrdiff_t n)
|
||||
{
|
||||
static_assert(meta::is_random_access_iterator_v<Iter>, "Iterator must allow random access");
|
||||
this->iter = this->iter + n;
|
||||
return *this;
|
||||
}
|
||||
|
||||
deref_only_wrapper& operator-(blt::ptrdiff_t n)
|
||||
{
|
||||
static_assert(meta::is_random_access_iterator_v<Iter>, "Iterator must allow random access");
|
||||
this->iter = this->iter - n;
|
||||
return *this;
|
||||
}
|
||||
};
|
||||
|
||||
template<typename Iter, typename Func>
|
||||
|
||||
template <typename Iter, typename Func>
|
||||
class map_wrapper : public deref_only_wrapper<Iter, map_wrapper<Iter, Func>>
|
||||
{
|
||||
public:
|
||||
using iterator_category = typename std::iterator_traits<Iter>::iterator_category;
|
||||
using value_type = std::invoke_result_t<Func, meta::deref_return_t<Iter>>;
|
||||
using difference_type = blt::ptrdiff_t;
|
||||
using pointer = value_type;
|
||||
using reference = value_type;
|
||||
|
||||
map_wrapper(Iter iter, Func func):
|
||||
deref_only_wrapper<Iter, map_wrapper<Iter, Func>>(std::move(iter)), func(std::move(func))
|
||||
{}
|
||||
|
||||
reference operator*() const
|
||||
{
|
||||
return func(*this->iter);
|
||||
}
|
||||
|
||||
private:
|
||||
Func func;
|
||||
public:
|
||||
using iterator_category = typename std::iterator_traits<Iter>::iterator_category;
|
||||
using value_type = std::invoke_result_t<Func, meta::deref_return_t<Iter>>;
|
||||
using difference_type = blt::ptrdiff_t;
|
||||
using pointer = value_type;
|
||||
using reference = value_type;
|
||||
|
||||
map_wrapper(Iter iter, Func func):
|
||||
deref_only_wrapper<Iter, map_wrapper<Iter, Func>>(std::move(iter)), func(std::move(func))
|
||||
{
|
||||
}
|
||||
|
||||
reference operator*() const
|
||||
{
|
||||
return func(*this->iter);
|
||||
}
|
||||
|
||||
private:
|
||||
Func func;
|
||||
};
|
||||
|
||||
template<typename Iter, typename Pred>
|
||||
|
||||
template <typename Iter, typename Pred>
|
||||
class filter_wrapper : public deref_only_wrapper<Iter, filter_wrapper<Iter, Pred>>
|
||||
{
|
||||
public:
|
||||
using iterator_category = typename std::iterator_traits<Iter>::iterator_category;
|
||||
using value_type = std::conditional_t<
|
||||
std::is_reference_v<meta::deref_return_t<Iter>>,
|
||||
std::optional<std::reference_wrapper<std::remove_reference_t<meta::deref_return_t<Iter>>>>,
|
||||
std::optional<meta::deref_return_t<Iter>>>;
|
||||
using difference_type = blt::ptrdiff_t;
|
||||
using pointer = value_type;
|
||||
using reference = value_type;
|
||||
|
||||
filter_wrapper(Iter iter, Pred func):
|
||||
deref_only_wrapper<Iter, filter_wrapper<Iter, Pred>>(std::move(iter)), func(std::move(func))
|
||||
{}
|
||||
|
||||
reference operator*() const
|
||||
public:
|
||||
using iterator_category = typename std::iterator_traits<Iter>::iterator_category;
|
||||
using value_type = std::conditional_t<
|
||||
std::is_reference_v<meta::deref_return_t<Iter>>,
|
||||
std::optional<std::reference_wrapper<std::remove_reference_t<meta::deref_return_t<Iter>>>>,
|
||||
std::optional<meta::deref_return_t<Iter>>>;
|
||||
using difference_type = blt::ptrdiff_t;
|
||||
using pointer = value_type;
|
||||
using reference = value_type;
|
||||
|
||||
filter_wrapper(Iter iter, Pred func):
|
||||
deref_only_wrapper<Iter, filter_wrapper<Iter, Pred>>(std::move(iter)), func(std::move(func))
|
||||
{
|
||||
}
|
||||
|
||||
reference operator*() const
|
||||
{
|
||||
if (!func(*this->iter))
|
||||
{
|
||||
if (!func(*this->iter))
|
||||
{
|
||||
return {};
|
||||
}
|
||||
return *this->iter;
|
||||
return {};
|
||||
}
|
||||
|
||||
private:
|
||||
Pred func;
|
||||
return *this->iter;
|
||||
}
|
||||
|
||||
private:
|
||||
Pred func;
|
||||
};
|
||||
|
||||
|
||||
namespace impl
|
||||
{
|
||||
template<typename Derived>
|
||||
template <typename Derived>
|
||||
class skip_t
|
||||
{
|
||||
private:
|
||||
template<bool check>
|
||||
auto skip_base(blt::size_t n)
|
||||
private:
|
||||
template <bool check>
|
||||
auto skip_base(blt::size_t n)
|
||||
{
|
||||
auto* d = static_cast<Derived*>(this);
|
||||
auto begin = d->begin();
|
||||
auto end = d->end();
|
||||
|
||||
if constexpr (meta::is_random_access_iterator_category_v<typename Derived::iterator_category>)
|
||||
{
|
||||
auto* d = static_cast<Derived*>(this);
|
||||
auto begin = d->begin();
|
||||
auto end = d->end();
|
||||
|
||||
if constexpr (meta::is_random_access_iterator_category_v<typename Derived::iterator_category>)
|
||||
// random access iterators can have math directly applied to them.
|
||||
if constexpr (check)
|
||||
{
|
||||
// random access iterators can have math directly applied to them.
|
||||
if constexpr (check)
|
||||
{
|
||||
return Derived{begin + std::min(static_cast<blt::ptrdiff_t>(n), std::distance(begin, end)), end};
|
||||
} else
|
||||
{
|
||||
return Derived{begin + n, end};
|
||||
}
|
||||
} else
|
||||
return Derived{begin + std::min(static_cast<blt::ptrdiff_t>(n), std::distance(begin, end)), end};
|
||||
}
|
||||
else
|
||||
{
|
||||
for (blt::size_t i = 0; i < n; i++)
|
||||
{
|
||||
if constexpr (check)
|
||||
{
|
||||
if (begin == end)
|
||||
break;
|
||||
}
|
||||
++begin;
|
||||
}
|
||||
return Derived{std::move(begin), std::move(end)};
|
||||
return Derived{begin + n, end};
|
||||
}
|
||||
}
|
||||
|
||||
public:
|
||||
auto skip(blt::size_t n)
|
||||
{ return skip_base<false>(n); }
|
||||
|
||||
auto skip_or(blt::size_t n)
|
||||
{ return skip_base<true>(n); }
|
||||
else
|
||||
{
|
||||
for (blt::size_t i = 0; i < n; i++)
|
||||
{
|
||||
if constexpr (check)
|
||||
{
|
||||
if (begin == end)
|
||||
break;
|
||||
}
|
||||
++begin;
|
||||
}
|
||||
return Derived{std::move(begin), std::move(end)};
|
||||
}
|
||||
}
|
||||
|
||||
public:
|
||||
auto skip(blt::size_t n)
|
||||
{
|
||||
return skip_base<false>(n);
|
||||
}
|
||||
|
||||
auto skip_or(blt::size_t n)
|
||||
{
|
||||
return skip_base<true>(n);
|
||||
}
|
||||
};
|
||||
|
||||
template<typename Derived>
|
||||
|
||||
template <typename Derived>
|
||||
class take_t
|
||||
{
|
||||
private:
|
||||
template<bool check>
|
||||
auto take_base(blt::size_t n)
|
||||
private:
|
||||
template <bool check>
|
||||
auto take_base(blt::size_t n)
|
||||
{
|
||||
static_assert(!meta::is_input_iterator_category_v<typename Derived::iterator_category>,
|
||||
"Cannot .take() on an input iterator!");
|
||||
auto* d = static_cast<Derived*>(this);
|
||||
auto begin = d->begin();
|
||||
auto end = d->end();
|
||||
|
||||
// take variant for forward and bidirectional iterators
|
||||
if constexpr (meta::is_forward_iterator_category_v<typename Derived::iterator_category> ||
|
||||
meta::is_bidirectional_iterator_category_v<typename Derived::iterator_category>)
|
||||
{
|
||||
static_assert(!meta::is_input_iterator_category_v<typename Derived::iterator_category>,
|
||||
"Cannot .take() on an input iterator!");
|
||||
auto* d = static_cast<Derived*>(this);
|
||||
auto begin = d->begin();
|
||||
auto end = d->end();
|
||||
|
||||
// take variant for forward and bidirectional iterators
|
||||
if constexpr (meta::is_forward_iterator_category_v<typename Derived::iterator_category> ||
|
||||
meta::is_bidirectional_iterator_category_v<typename Derived::iterator_category>)
|
||||
// with these guys we have to loop forward to move the iterators. an unfortunate inefficiency
|
||||
auto new_end = begin;
|
||||
for (blt::size_t i = 0; i < n; i++)
|
||||
{
|
||||
// with these guys we have to loop forward to move the iterators. an unfortunate inefficiency
|
||||
auto new_end = begin;
|
||||
for (blt::size_t i = 0; i < n; i++)
|
||||
{
|
||||
if constexpr (check)
|
||||
{
|
||||
if (new_end == end)
|
||||
break;
|
||||
}
|
||||
++new_end;
|
||||
}
|
||||
return Derived{std::move(begin), std::move(new_end)};
|
||||
} else if constexpr (meta::is_random_access_iterator_category_v<typename Derived::iterator_category>)
|
||||
{
|
||||
// random access iterators can have math directly applied to them.
|
||||
if constexpr (check)
|
||||
{
|
||||
return Derived{begin, begin + std::min(static_cast<blt::ptrdiff_t>(n), std::distance(begin, end))};
|
||||
} else
|
||||
{
|
||||
return Derived{begin, begin + n};
|
||||
if (new_end == end)
|
||||
break;
|
||||
}
|
||||
++new_end;
|
||||
}
|
||||
return Derived{std::move(begin), std::move(new_end)};
|
||||
}
|
||||
else if constexpr (meta::is_random_access_iterator_category_v<typename Derived::iterator_category>)
|
||||
{
|
||||
// random access iterators can have math directly applied to them.
|
||||
if constexpr (check)
|
||||
{
|
||||
return Derived{begin, begin + std::min(static_cast<blt::ptrdiff_t>(n), std::distance(begin, end))};
|
||||
}
|
||||
else
|
||||
{
|
||||
return Derived{begin, begin + n};
|
||||
}
|
||||
}
|
||||
|
||||
public:
|
||||
auto take(blt::size_t n)
|
||||
{ return take_base<false>(n); }
|
||||
|
||||
auto take_or(blt::size_t n)
|
||||
{ return take_base<true>(n); }
|
||||
}
|
||||
|
||||
public:
|
||||
auto take(blt::size_t n)
|
||||
{
|
||||
return take_base<false>(n);
|
||||
}
|
||||
|
||||
auto take_or(blt::size_t n)
|
||||
{
|
||||
return take_base<true>(n);
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
template<typename IterBase>
|
||||
|
||||
template <typename IterBase>
|
||||
class iterator_container : public impl::take_t<iterator_container<IterBase>>,
|
||||
public impl::skip_t<iterator_container<IterBase>>
|
||||
{
|
||||
public:
|
||||
using iterator_category = typename std::iterator_traits<IterBase>::iterator_category;
|
||||
using iterator = IterBase;
|
||||
|
||||
iterator_container(IterBase begin, IterBase end): m_begin(std::move(begin)), m_end(std::move(end))
|
||||
{}
|
||||
|
||||
template<typename Iter>
|
||||
iterator_container(Iter&& begin, Iter&& end): m_begin(std::forward<Iter>(begin)), m_end(std::forward<Iter>(end))
|
||||
{}
|
||||
|
||||
auto rev() const
|
||||
{
|
||||
static_assert(meta::is_bidirectional_or_better_category_v<iterator_category>,
|
||||
".rev() must be used with bidirectional (or better) iterators!");
|
||||
return iterator_container<std::reverse_iterator<IterBase>>{std::reverse_iterator<IterBase>{end()},
|
||||
std::reverse_iterator<IterBase>{begin()}};
|
||||
}
|
||||
|
||||
template<typename... Iter>
|
||||
auto zip(iterator_pair<Iter>... iterator_pairs) const
|
||||
{
|
||||
return zip_iterator_container(iterator_pair<decltype(begin())>{begin(), end()}, iterator_pairs...);
|
||||
}
|
||||
|
||||
template<typename... Container>
|
||||
auto zip(Container& ... containers) const
|
||||
{
|
||||
return zip_iterator_container(iterator_pair<decltype(begin())>{begin(), end()},
|
||||
iterator_pair{containers.begin(), containers.end()}...);
|
||||
}
|
||||
|
||||
template<typename... Container>
|
||||
auto zip(const Container& ... containers) const
|
||||
{
|
||||
return zip_iterator_container(iterator_pair<decltype(begin())>{begin(), end()},
|
||||
iterator_pair{containers.begin(), containers.end()}...);
|
||||
}
|
||||
|
||||
auto enumerate() const
|
||||
{
|
||||
return enumerate_iterator_container{begin(), end(), static_cast<blt::size_t>(std::distance(begin(), end()))};
|
||||
}
|
||||
|
||||
template<typename Func>
|
||||
auto map(Func func) const
|
||||
{
|
||||
return iterator_container<blt::iterator::map_wrapper<IterBase, Func>>{
|
||||
blt::iterator::map_wrapper<IterBase, Func>{m_begin, func},
|
||||
blt::iterator::map_wrapper<IterBase, Func>{m_end, func}};
|
||||
}
|
||||
|
||||
template<typename Pred>
|
||||
auto filter(Pred pred) const
|
||||
{
|
||||
return iterator_container<blt::iterator::filter_wrapper<IterBase, Pred>>{
|
||||
blt::iterator::filter_wrapper<IterBase, Pred>{m_begin, pred},
|
||||
blt::iterator::filter_wrapper<IterBase, Pred>{m_end, pred}};
|
||||
}
|
||||
|
||||
auto begin() const
|
||||
{
|
||||
return m_begin;
|
||||
}
|
||||
|
||||
auto end() const
|
||||
{
|
||||
return m_end;
|
||||
}
|
||||
|
||||
protected:
|
||||
IterBase m_begin;
|
||||
IterBase m_end;
|
||||
public:
|
||||
using iterator_category = typename std::iterator_traits<IterBase>::iterator_category;
|
||||
using iterator = IterBase;
|
||||
|
||||
iterator_container(IterBase begin, IterBase end): m_begin(std::move(begin)), m_end(std::move(end))
|
||||
{
|
||||
}
|
||||
|
||||
template <typename Iter>
|
||||
iterator_container(Iter&& begin, Iter&& end): m_begin(std::forward<Iter>(begin)), m_end(std::forward<Iter>(end))
|
||||
{
|
||||
}
|
||||
|
||||
auto rev() const
|
||||
{
|
||||
static_assert(meta::is_bidirectional_or_better_category_v<iterator_category>,
|
||||
".rev() must be used with bidirectional (or better) iterators!");
|
||||
return iterator_container<std::reverse_iterator<IterBase>>{
|
||||
std::reverse_iterator<IterBase>{end()},
|
||||
std::reverse_iterator<IterBase>{begin()}
|
||||
};
|
||||
}
|
||||
|
||||
template <typename... Iter>
|
||||
auto zip(iterator_pair<Iter>... iterator_pairs) const
|
||||
{
|
||||
return zip_iterator_container(iterator_pair<decltype(begin())>{begin(), end()}, iterator_pairs...);
|
||||
}
|
||||
|
||||
template <typename... Container>
|
||||
auto zip(Container&... containers) const
|
||||
{
|
||||
return zip_iterator_container(iterator_pair<decltype(begin())>{begin(), end()},
|
||||
iterator_pair{containers.begin(), containers.end()}...);
|
||||
}
|
||||
|
||||
template <typename... Container>
|
||||
auto zip(const Container&... containers) const
|
||||
{
|
||||
return zip_iterator_container(iterator_pair<decltype(begin())>{begin(), end()},
|
||||
iterator_pair{containers.begin(), containers.end()}...);
|
||||
}
|
||||
|
||||
template <typename Iter>
|
||||
auto zip(Iter begin, Iter end)
|
||||
{
|
||||
return zip(iterator_pair<Iter>{begin, end});
|
||||
}
|
||||
|
||||
auto enumerate() const
|
||||
{
|
||||
return enumerate_iterator_container{begin(), end(), static_cast<blt::size_t>(std::distance(begin(), end()))};
|
||||
}
|
||||
|
||||
template <typename Func>
|
||||
auto map(Func func) const
|
||||
{
|
||||
return iterator_container<blt::iterator::map_wrapper<IterBase, Func>>{
|
||||
blt::iterator::map_wrapper<IterBase, Func>{m_begin, func},
|
||||
blt::iterator::map_wrapper<IterBase, Func>{m_end, func}
|
||||
};
|
||||
}
|
||||
|
||||
template <typename Pred>
|
||||
auto filter(Pred pred) const
|
||||
{
|
||||
return iterator_container<blt::iterator::filter_wrapper<IterBase, Pred>>{
|
||||
blt::iterator::filter_wrapper<IterBase, Pred>{m_begin, pred},
|
||||
blt::iterator::filter_wrapper<IterBase, Pred>{m_end, pred}
|
||||
};
|
||||
}
|
||||
|
||||
auto begin() const
|
||||
{
|
||||
return m_begin;
|
||||
}
|
||||
|
||||
auto end() const
|
||||
{
|
||||
return m_end;
|
||||
}
|
||||
|
||||
protected:
|
||||
IterBase m_begin;
|
||||
IterBase m_end;
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
#endif //BLT_ITERATOR_ITER_COMMON
|
||||
|
|
|
|||
Loading…
Reference in New Issue