feat add rxcpp (90da26f0) · Commits · tqcq air / sled · GitLab

3party/cpplinq/linq.hpp

0 → 100644

+584 −0

Original line number	Diff line number	Diff line
		// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.

		///
		/// namespace cpplinq
		/// -----------------
		///
		/// Defines a number of range-based composable operators for enumerating and modifying collections
		///
		/// The general design philosophy is to
		/// (1) emulate the composable query patterns introduced in C# Linq
		/// (2) preserve iterator category and writability where possible
		/// For instance, like C# Linq we have a select operator to project one sequence into a new one.
		/// Unlike Linq, invoking Select on a random access sequence will yield you a _random_ access sequence.
		///
		/// The general workflow begins with 'from()' which normally only takes a reference
		/// the the collection in question. However, from that point on, all operators function
		/// by value, so that the range can store any necessary state, rather than duplicating it
		/// onto iterator pairs.
		///
		/// In subsequent documentation, "powers" lists which powers that the operator attempts to preserve if
		/// available on on the input sequence. Some iterator powers may be skipped - in such a case, round down
		/// to the next supported power (e.g. if 'fwd' and 'rnd', an input of 'bidi' will round down to a 'fwd' result).
		///
		///
		///
		/// class linq_query
		/// ----------------
		///
		/// from(container&)
		/// ================
		/// - Result: Query
		///
		/// Construct a new query, from an lvalue reference to a collection. Does not copy the collection
		///
		///
		///
		/// from(iter, iter)
		/// ================
		/// - Result: Query
		///
		/// Construct a new query, from an iterator pair.
		///
		///
		///
		/// query.select(map)
		/// ==========================
		/// - Result: Query
		/// - Powers: input, forward, bidirectional, random access
		///
		/// For each element `x` in the input sequences, computes `map(x)` for the result sequence.
		///
		///
		///
		/// query.where(pred) -> query
		/// ==========================
		/// - Result: Query
		/// - Powers: input, forward, bidirectional
		///
		/// Each element `x` in the input appears in the output if `pred(x)` is true.
		///
		/// The expression `pred(x)` is evaluated only when moving iterators (op++, op--).
		/// Dereferencing (op*) does not invoke the predicate.
		///
		///
		///
		/// query.groupby(keymap [, keyequal])
		/// ====================================
		/// Result: Query of groups. Each group has a 'key' field, and is a query of elements from the input.
		/// Powers: forward
		///
		///
		///
		/// query.any([pred])
		/// =================
		/// - Result: bool
		///
		/// (No argument) Returns true if sequence is non-empty. Equivalent to `query.begin()!=query.end()`
		///
		/// (One argument) Returns true if the sequence contains any elements for which `pred(element)` is true.
		/// Equivalent to `query.where(pred).any()`.
		///
		///
		///
		/// query.all(pred)
		/// ===============
		/// - Result: bool
		///
		/// Returns true if `pred` holds for all elements in the sequence. Equivalent to `!query.any(std::not1(pred))`
		///
		///
		///
		/// query.take(n)
		/// =============
		/// - Result: query
		/// - Powers: input, forward, random access (not bidirectional)
		///
		/// Returns a sequence that contains up to `n` items from the original sequence.
		///
		///
		///
		/// query.skip(n)
		/// =============
		/// - Result: query
		/// - Powers: input, forward, random access (not bidirectional)
		///
		/// Returns a sequence that skips the first `n` items from the original sequence, or an empty sequence if
		/// fewer than `n` were available on input.
		///
		/// Note: begin() takes O(n) time when input iteration power is weaker than random access.
		///
		///
		///
		/// query.count([pred])
		/// ===================
		/// - Result: std::size_t
		///
		/// _TODO: should use inner container's iterator distance type instead._
		///
		/// (Zero-argument) Returns the number of elements in the range.
		/// Equivalent to `std::distance(query.begin(), query.end())`
		///
		/// (One-argument) Returns the number of elements for whicht `pred(element)` is true.
		/// Equivalent to `query.where(pred).count()`
		///



		#if !defined(CPPLINQ_LINQ_HPP)
		#define CPPLINQ_LINQ_HPP
		#pragma once

		#pragma push_macro("min")
		#pragma push_macro("max")
		#undef min
		#undef max

		#include <functional>
		#include <iterator>
		#include <algorithm>
		#include <numeric>
		#include <list>
		#include <map>
		#include <set>
		#include <memory>
		#include <utility>
		#include <type_traits>
		#include <vector>
		#include <cstddef>



		// some configuration macros
		#if _MSC_VER > 1600 \|\| __cplusplus > 199711L
		#define LINQ_USE_RVALUEREF 1
		#endif

		#if (defined(_MSC_VER) && _CPPRTTI) \|\| !defined(_MSC_VER)
		#define LINQ_USE_RTTI 1
		#endif

		#if defined(__clang__)
		#if __has_feature(cxx_rvalue_references)
		#define LINQ_USE_RVALUEREF 1
		#endif
		#if __has_feature(cxx_rtti)
		#define LINQ_USE_RTTI 1
		#endif
		#endif


		// individual features
		#include "util.hpp"
		#include "linq_cursor.hpp"
		#include "linq_iterators.hpp"
		#include "linq_select.hpp"
		#include "linq_take.hpp"
		#include "linq_skip.hpp"
		#include "linq_groupby.hpp"
		#include "linq_where.hpp"
		#include "linq_last.hpp"
		#include "linq_selectmany.hpp"




		namespace cpplinq
		{

		namespace detail
		{
		template<class Pred>
		struct not1_{
		Pred pred;
		not1_(Pred p) : pred(p)
		{}
		template<class T>
		bool operator()(const T& value)
		{
		return !pred(value);
		}
		};
		// note: VC2010's std::not1 doesn't support lambda expressions. provide our own.
		template<class Pred>
		not1_<Pred> not1(Pred p) { return not1_<Pred>(p); }
		}

		namespace detail {
		template <class U>
		struct cast_to {
		template <class T>
		U operator()(const T& value) const {
		return static_cast<U>(value);
		}
		};
		}

		template <class Collection>
		class linq_driver
		{
		typedef typename Collection::cursor::element_type
		element_type;
		typedef typename Collection::cursor::reference_type
		reference_type;
		public:
		typedef cursor_iterator<typename Collection::cursor>
		iterator;

		linq_driver(Collection c) : c(c) {}


		// -------------------- linq core methods --------------------

		template <class KeyFn>
		linq_driver< linq_groupby<Collection, KeyFn> > groupby(KeyFn fn)
		{
		return linq_groupby<Collection, KeyFn>(c, std::move(fn) );
		}

		// TODO: groupby(keyfn, eq)

		// TODO: join...

		template <class Selector>
		linq_driver< linq_select<Collection, Selector> > select(Selector sel) const {
		return linq_select<Collection, Selector>(c, std::move(sel) );
		}

		template <class Fn>
		linq_driver< linq_select_many<Collection, Fn, detail::default_select_many_selector> >
		select_many(Fn fn) const
		{
		return linq_select_many<Collection, Fn, detail::default_select_many_selector>(c, fn, detail::default_select_many_selector());
		}

		template <class Fn, class Fn2>
		linq_driver< linq_select_many<Collection, Fn, Fn2> > select_many(Fn fn, Fn2 fn2) const
		{
		return linq_select_many<Collection, Fn, Fn2>(c, fn, fn2);
		}

		template <class Predicate>
		linq_driver< linq_where<Collection, Predicate> > where(Predicate p) const {
		return linq_where<Collection, Predicate>(c, std::move(p) );
		}


		// -------------------- linq peripheral methods --------------------

		template <class Fn>
		element_type aggregate(Fn fn) const
		{
		auto it = begin();
		if (it == end()) {
		return element_type();
		}

		reference_type first = *it;
		return std::accumulate(++it, end(), first, fn);
		}

		template <class T, class Fn>
		T aggregate(T initialValue, Fn fn) const
		{
		return std::accumulate(begin(), end(), initialValue, fn);
		}

		bool any() const { auto cur = c.get_cursor(); return !cur.empty(); }

		template <class Predicate>
		bool any(Predicate p) const {
		auto it = std::find_if(begin(), end(), p);
		return it != end();
		}

		template <class Predicate>
		bool all(Predicate p) const {
		auto it = std::find_if(begin(), end(), detail::not1(p));
		return it == end();
		}

		// TODO: average

		#if !defined(__clang__)
		// Clang complains that linq_driver is not complete until the closing brace
		// so (linq_driver*)->select() cannot be resolved.
		template <class U>
		auto cast()
		-> decltype(static_cast<linq_driver*>(0)->select(detail::cast_to<U>()))
		{
		return this->select(detail::cast_to<U>());
		}
		#endif

		// TODO: concat

		bool contains(const typename Collection::cursor::element_type& value) const {
		return std::find(begin(), end(), value) != end();
		}

		typename std::iterator_traits<iterator>::difference_type count() const {
		return std::distance(begin(), end());
		}

		template <class Predicate>
		typename std::iterator_traits<iterator>::difference_type count(Predicate p) const {
		auto filtered = this->where(p);
		return std::distance(begin(filtered), end(filtered));
		}

		// TODO: default_if_empty

		// TODO: distinct()
		// TODO: distinct(cmp)

		reference_type element_at(std::size_t ix) const {
		auto cur = c.get_cursor();
		while(ix && !cur.empty()) {
		cur.inc();
		--ix;
		}
		if (cur.empty()) { throw std::logic_error("index out of bounds"); }
		else { return cur.get(); }
		}

		element_type element_at_or_default(std::size_t ix) const {
		auto cur = c.get_cursor();
		while(ix && !cur.empty()) {
		cur.inc();
		-- ix;
		}
		if (cur.empty()) { return element_type(); }
		else { return cur.get(); }
		}

		bool empty() const {
		return !this->any();
		}

		// TODO: except(second)
		// TODO: except(second, eq)

		reference_type first() const {
		auto cur = c.get_cursor();
		if (cur.empty()) { throw std::logic_error("index out of bounds"); }
		else { return cur.get(); }
		}

		template <class Predicate>
		reference_type first(Predicate pred) const {
		auto cur = c.get_cursor();
		while (!cur.empty() && !pred(cur.get())) {
		cur.inc();
		}
		if (cur.empty()) { throw std::logic_error("index out of bounds"); }
		else { return cur.get(); }
		}

		element_type first_or_default() const {
		auto cur = c.get_cursor();
		if (cur.empty()) { return element_type(); }
		else { return cur.get(); }
		}

		template <class Predicate>
		element_type first_or_default(Predicate pred) const {
		auto cur = c.get_cursor();
		while (!cur.empty() && !pred(cur.get())) {
		cur.inc();
		}
		if (cur.empty()) { return element_type(); }
		else { return cur.get(); }
		}

		// TODO: intersect(second)
		// TODO: intersect(second, eq)

		// note: forward cursors and beyond can provide a clone, so we can refer to the element directly
		typename std::conditional<
		std::is_convertible<
		typename Collection::cursor::cursor_category,
		forward_cursor_tag>::value,
		reference_type,
		element_type>::type
		last() const
		{
		return linq_last_(c.get_cursor(), typename Collection::cursor::cursor_category());
		}

		template <class Predicate>
		reference_type last(Predicate pred) const
		{
		auto cur = c.where(pred).get_cursor();
		return linq_last_(cur, typename decltype(cur)::cursor_category());
		}

		element_type last_or_default() const
		{
		return linq_last_or_default_(c.get_cursor(), typename Collection::cursor::cursor_category());
		}

		template <class Predicate>
		element_type last_or_default(Predicate pred) const
		{
		auto cur = c.where(pred).get_cursor();
		return linq_last_or_default_(cur, typename decltype(cur)::cursor_category());
		}

		reference_type max() const
		{
		return max(std::less<element_type>());
		}

		template <class Compare>
		reference_type max(Compare less) const
		{
		auto it = std::max_element(begin(), end(), less);
		if (it == end())
		throw std::logic_error("max performed on empty range");

		return *it;
		}

		reference_type min() const
		{
		return min(std::less<element_type>());
		}

		template <class Compare>
		reference_type min(Compare less) const
		{
		auto it = std::min_element(begin(), end(), less);
		if (it == end())
		throw std::logic_error("max performed on empty range");

		return *it;
		}

		// TODO: order_by(sel)
		// TODO: order_by(sel, less)
		// TODO: order_by_descending(sel)
		// TODO: order_by_descending(sel, less)

		// TODO: sequence_equal(second)
		// TODO: sequence_equal(second, eq)

		// TODO: single / single_or_default

		linq_driver<linq_skip<Collection>> skip(std::size_t n) const {
		return linq_skip<Collection>(c, n);
		}

		// TODO: skip_while(pred)

		template<typename ITEM = element_type>
		typename std::enable_if<std::is_default_constructible<ITEM>::value, ITEM>::type sum() const {
		ITEM seed{};
		return sum(seed);
		}

		element_type sum(element_type seed) const {
		return std::accumulate(begin(), end(), seed);
		}

		template <typename Selector, typename Result = typename std::result_of<Selector(element_type)>::type>
		typename std::enable_if<std::is_default_constructible<Result>::value, Result>::type sum(Selector sel) const {
		return from(begin(), end()).select(sel).sum();
		}

		template <typename Selector, typename Result = typename std::result_of<Selector(element_type)>::type>
		Result sum(Selector sel, Result seed) const {
		return from(begin(), end()).select(sel).sum(seed);
		}

		linq_driver<linq_take<Collection>> take(std::size_t n) const {
		return linq_take<Collection>(c, n);
		}

		// TODO: take_while

		// TODO: then_by / then_by_descending ?

		// TODO: to_...

		// TODO: union(second)
		// TODO: union(eq)

		// TODO: zip

		// -------------------- conversion methods --------------------

		std::vector<typename Collection::cursor::element_type> to_vector() const
		{
		return std::vector<typename Collection::cursor::element_type>(begin(), end());
		}

		std::list<typename Collection::cursor::element_type> to_list() const
		{
		return std::list<typename Collection::cursor::element_type>(begin(), end());
		}

		std::set<typename Collection::cursor::element_type> to_set() const
		{
		return std::set<typename Collection::cursor::element_type>(begin(), end());
		}

		// -------------------- container/range methods --------------------

		iterator begin() const { auto cur = c.get_cursor(); return !cur.empty() ? iterator(cur) : iterator(); }
		iterator end() const { return iterator(); }
		linq_driver& operator=(const linq_driver& other) { c = other.c; return *this; }
		template <class TC2>
		linq_driver& operator=(const linq_driver<TC2>& other) { c = other.c; return *this; }

		typename std::iterator_traits<iterator>::reference
		operator[](std::size_t ix) const {
		return *(begin()+=ix);
		}

		// -------------------- collection methods (leaky abstraction) --------------------

		typedef typename Collection::cursor cursor;
		cursor get_cursor() { return c.get_cursor(); }

		linq_driver< dynamic_collection<typename Collection::cursor::reference_type> >
		late_bind() const
		{
		return dynamic_collection<typename Collection::cursor::reference_type>(c);
		}

		private:
		Collection c;
		};

		// TODO: should probably use reference-wrapper instead?
		template <class TContainer>
		linq_driver<iter_cursor<typename util::container_traits<TContainer>::iterator>> from(TContainer& c)
		{
		auto cur = iter_cursor<typename util::container_traits<TContainer>::iterator>(std::begin(c), std::end(c));
		return cur;
		}
		template <class T>
		const linq_driver<T>& from(const linq_driver<T>& c)
		{
		return c;
		}
		template <class Iter>
		linq_driver<iter_cursor<Iter>> from(Iter start, Iter finish)
		{
		return iter_cursor<Iter>(start, finish);
		}

		template <class TContainer>
		linq_driver<TContainer> from_value(const TContainer& c)
		{
		return linq_driver<TContainer>(c);
		}

		}

		#pragma pop_macro("min")
		#pragma pop_macro("max")

		#endif // defined(CPPLINQ_LINQ_HPP)

3party/cpplinq/linq_cursor.hpp

0 → 100644

+342 −0

File added.

Preview size limit exceeded, changes collapsed.

3party/cpplinq/linq_groupby.hpp

0 → 100644

+195 −0

Original line number	Diff line number	Diff line
		// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.

		#if !defined(CPPLINQ_LINQ_GROUPBY_HPP)
		#define CPPLINQ_LINQ_GROUPBY_HPP
		#pragma once

		namespace cpplinq
		{

		template <class Iter, class Key>
		struct group
		{
		Key key;
		Iter start;
		Iter fin;

		typedef Iter iterator;
		typedef Iter const_iterator;

		group(){}

		group(const Key& key) : key(key)
		{
		}

		Iter begin() const { return start; }
		Iter end() const { return fin; }
		};

		struct default_equality
		{
		template <class T>
		bool operator()(const T& a, const T& b) const {
		return a == b;
		}
		};
		struct default_less
		{
		template<class T>
		bool operator()(const T& a, const T& b) const {
		return a < b;
		}
		};

		// progressively constructs grouping as user iterates over groups and elements
		// within each group. Performs this task by building a std::list of element
		// iterators with equal elements within each group.
		//
		// invariants:
		// - relative order of groups corresponds to relative order of each group's first
		// element, as they appeared in the input sequence.
		// - relative order of elements within a group correspond to relative order
		// as they appeared in the input sequence.
		//
		// requires:
		// Iter must be a forward iterator.
		template <class Collection, class KeyFn, class Compare = default_less>
		class linq_groupby
		{
		typedef typename Collection::cursor
		inner_cursor;

		typedef typename util::result_of<KeyFn(typename inner_cursor::element_type)>::type
		key_type;

		typedef std::list<typename inner_cursor::element_type>
		element_list_type;

		typedef group<typename element_list_type::iterator, key_type>
		group_type;

		typedef std::list<group_type>
		group_list_type;

		private:
		struct impl_t
		{
		// TODO: would be faster to use a chunked list, where
		// pointers are invalidated but iterators are not. Need
		// benchmarks first

		element_list_type elements;
		std::list<group_type> groups;
		std::map<key_type, group_type*, Compare> groupIndex;



		KeyFn keySelector;
		Compare comp;

		impl_t(inner_cursor cur,
		KeyFn keySelector,
		Compare comp = Compare())
		: keySelector(keySelector)
		, groupIndex(comp)
		{
		// TODO: make lazy
		insert_all(std::move(cur));
		}

		void insert_all(inner_cursor cur)
		{
		while(!cur.empty()) {
		insert(cur.get());
		cur.inc();
		}
		}
		void insert(typename inner_cursor::reference_type element)
		{
		key_type key = keySelector(element);
		auto groupPos = groupIndex.find(key);
		if(groupPos == groupIndex.end()) {
		// new group
		bool firstGroup = groups.empty();

		elements.push_back(element);
		if(!firstGroup) {
		// pop new element out of previous group
		--groups.back().fin;
		}

		// build new group
		groups.push_back(group_type(key));
		group_type& newGroup = groups.back();

		groupIndex.insert( std::make_pair(key, &newGroup) );

		newGroup.fin = elements.end();
		--(newGroup.start = newGroup.fin);
		} else {
		// add to existing group at end
		elements.insert(groupPos->second->end(), element);
		}
		}
		};

		public:
		struct cursor {
		typedef group_type
		element_type;

		typedef element_type
		reference_type;

		typedef forward_cursor_tag
		cursor_category;

		cursor(inner_cursor cur,
		KeyFn keyFn,
		Compare comp = Compare())
		{
		impl.reset(new impl_t(cur, keyFn, comp));
		inner = impl->groups.begin();
		fin = impl->groups.end();
		}

		void forget() { } // nop on forward-only cursors
		bool empty() const {
		return inner == fin;
		}
		void inc() {
		if (inner == fin) {
		throw std::logic_error("attempt to iterate past end of range");
		}
		++inner;
		}
		reference_type get() const {
		return *inner;
		}

		private:
		std::shared_ptr<impl_t> impl;
		typename std::list<group_type>::iterator inner;
		typename std::list<group_type>::iterator fin;
		};

		linq_groupby(Collection c,
		KeyFn keyFn,
		Compare comp = Compare())
		: c(c), keyFn(keyFn), comp(comp)
		{
		}

		cursor get_cursor() const { return cursor(c.get_cursor(), keyFn, comp); }

		private:
		Collection c;
		KeyFn keyFn;
		Compare comp;
		};

		}

		#endif // !defined(CPPLINQ_LINQ_GROUPBY_HPP)

3party/cpplinq/linq_iterators.hpp

0 → 100644

+196 −0

File added.

Preview size limit exceeded, changes collapsed.

3party/cpplinq/linq_last.hpp

0 → 100644

+85 −0

Original line number	Diff line number	Diff line
		// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.

		#if !defined(CPPLINQ_LINQ_LAST_HPP)
		#define CPPLINQ_LINQ_LAST_HPP
		#pragma once

		namespace cpplinq {

		template <class Cursor>
		typename Cursor::element_type
		linq_last_(Cursor c, onepass_cursor_tag)
		{
		if (c.empty()) { throw std::logic_error("last() out of bounds"); }
		typename Cursor::element_type elem = c.get();
		for(;;) {
		c.inc();
		if (c.empty()) break;
		elem = c.get();
		}
		return elem;
		}

		// TODO: bidirectional iterator in constant time

		template <class Cursor>
		typename Cursor::reference_type
		linq_last_(Cursor c, forward_cursor_tag)
		{
		if (c.empty()) { throw std::logic_error("last() out of bounds"); }
		Cursor best = c;
		for(;;) {
		c.inc();
		if (c.empty()) break;
		best = c;
		}
		return best.get();
		}

		template <class Cursor>
		typename Cursor::reference_type
		linq_last_(Cursor c, random_access_cursor_tag)
		{
		if (c.empty()) { throw std::logic_error("last() out of bounds"); }
		c.skip(c.size()-1);
		return c.get();
		}

		template <class Cursor>
		typename Cursor::element_type
		linq_last_or_default_(Cursor c, onepass_cursor_tag)
		{
		typename Cursor::element_type elem;
		while(!c.empty()) {
		elem = c.get();
		c.inc();
		}
		return elem;
		}

		template <class Cursor>
		typename Cursor::element_type
		linq_last_or_default_(Cursor c, forward_cursor_tag)
		{
		if (c.empty()) { throw std::logic_error("last() out of bounds"); }
		Cursor best = c;
		for(;;) {
		c.inc();
		if (c.empty()) break;
		best = c;
		}
		return best.get();
		}

		template <class Cursor>
		typename Cursor::element_type
		linq_last_or_default_(Cursor c, random_access_cursor_tag)
		{
		if (c.empty()) { return typename Cursor::element_type(); }
		c.skip(c.size()-1);
		return c.get();
		}

		}

		#endif // CPPLINQ_LINQ_LAST_HPP