Use constructed_type instead of constructed::type and used std::less<…

…void> in sorters. Fix #232 and #231

tpie/pipelining/factory_helpers.h

@@ -42,25 +42,23 @@ class factory : public factory_base {
 	template <typename... Args>
 	factory(Args && ... v) : cont(std::forward<Args>(v)...) {}
 
-	template<typename dest_t>
-	struct constructed {
-		typedef R<typename bits::remove<dest_t>::type> type;
-	};
+	template <typename dest_t>
+	using constructed_type = R<typename bits::remove<dest_t>::type>;
 
 	template <typename dest_t>
-	typename constructed<dest_t>::type construct(dest_t && dest) {
+	constructed_type<dest_t> construct(dest_t && dest) {
 		node_token tok = dest.get_token();
-		typename constructed<dest_t>::type r = container_construct<typename constructed<dest_t>::type>(cont, std::forward<dest_t>(dest));
+		constructed_type<dest_t> r = container_construct<constructed_type<dest_t>>(cont, std::forward<dest_t>(dest));
 		this->init_node(r);
 		this->add_default_edge(r, tok);
 		this->add_node_set_edges(r);
 		return r;
 	}
 
 	template <typename dest_t>
-	typename constructed<dest_t>::type construct_copy(dest_t && dest) {
+	constructed_type<dest_t> construct_copy(dest_t && dest) {
 		node_token tok = dest.get_token();
-		typename constructed<dest_t>::type r = container_construct_copy<typename constructed<dest_t>::type>(cont, std::forward<dest_t>(dest));
+		constructed_type<dest_t> r = container_construct_copy<constructed_type<dest_t>>(cont, std::forward<dest_t>(dest));
 		this->init_node(r);
 		this->add_default_edge(r, tok);
 		this->add_node_set_edges(r);
@@ -86,25 +84,23 @@ class tempfactory : public factory_base {
 	template <typename... Args>
 	tempfactory(Args && ... v) : cont(std::forward<Args>(v)...) {}
 
-	template<typename dest_t>
-	struct constructed {
-		typedef typename Holder::template type<typename bits::remove<dest_t>::type> type;
-	};
+	template <typename dest_t>
+	using constructed_type = typename Holder::template type<typename bits::remove<dest_t>::type>;
 
 	template <typename dest_t>
-	typename constructed<dest_t>::type construct(dest_t && dest) {
+	constructed_type<dest_t> construct(dest_t && dest) {
 		node_token tok = dest.get_token();
-		typename constructed<dest_t>::type r = container_construct<typename constructed<dest_t>::type>(cont, std::forward<dest_t>(dest));
+		constructed_type<dest_t> r = container_construct<constructed_type<dest_t>>(cont, std::forward<dest_t>(dest));
 		this->init_node(r);
 		this->add_default_edge(r, tok);
 		this->add_node_set_edges(r);
 		return r;
 	}
 
 	template <typename dest_t>
-	typename constructed<dest_t>::type construct_copy(dest_t && dest) {
+	constructed_type<dest_t> construct_copy(dest_t && dest) {
 		node_token tok = dest.get_token();
-		typename constructed<dest_t>::type r = container_construct_copy<typename constructed<dest_t>::type>(cont, std::forward<dest_t>(dest));
+		constructed_type<dest_t> r = container_construct_copy<constructed_type<dest_t>>(cont, std::forward<dest_t>(dest));
 		this->init_node(r);
 		this->add_default_edge(r, tok);
 		this->add_node_set_edges(r);
@@ -172,24 +168,22 @@ class tfactory<R, Args<TT...>, T...> : public factory_base {
 	tfactory(Args && ... v) : cont(std::forward<Args>(v)...) {}
 
 	template<typename dest_t>
-	struct constructed {
-		typedef R<typename bits::remove<dest_t>::type, TT...> type;
-	};
+	using constructed_type = R<typename bits::remove<dest_t>::type, TT...>;
 
 	template <typename dest_t>
-	typename constructed<dest_t>::type construct(dest_t && dest) {
+	constructed_type<dest_t> construct(dest_t && dest) {
 		node_token tok = dest.get_token();
-		typename constructed<dest_t>::type r = container_construct<typename constructed<dest_t>::type>(cont, std::forward<dest_t>(dest));
+		constructed_type<dest_t> r = container_construct<constructed_type<dest_t>>(cont, std::forward<dest_t>(dest));
 		this->init_node(r);
 		this->add_default_edge(r, tok);
 		this->add_node_set_edges(r);
 		return r;
 	}
 
 	template <typename dest_t>
-	typename constructed<dest_t>::type construct_copy(dest_t && dest) {
+	constructed_type<dest_t> construct_copy(dest_t && dest) {
 		node_token tok = dest.get_token();
-		typename constructed<dest_t>::type r = container_construct_copy<typename constructed<dest_t>::type>(cont, std::forward<dest_t>(dest));
+		constructed_type<dest_t> r = container_construct_copy<constructed_type<dest_t>>(cont, std::forward<dest_t>(dest));
 		this->init_node(r);
 		this->add_default_edge(r, tok);
 		this->add_node_set_edges(r);
@@ -212,21 +206,18 @@ template <template <typename item_type> class I, typename OB, template<typename
 class split_factory : public factory_base {
 public:
 	template <typename dest_t>
-	struct constructed {
-		typedef typename push_type<dest_t>::type item_type;
-		typedef I<item_type> type;
-	};
+	using constructed_type = I<typename push_type<dest_t>::type>;
 
 	template <typename dest_t>
-	typename constructed<dest_t>::type construct(dest_t && dest) const {
+	constructed_type<dest_t> construct(dest_t && dest) const {
 		node_token input_token;
 		typedef typename push_type<dest_t>::type item_type;
 		std::shared_ptr<OB> o = std::make_shared<O<dest_t> >(std::forward<dest_t>(dest), input_token);
 		return I<item_type>(input_token, std::move(o));
 	};
 
 	template <typename dest_t>
-	typename constructed<dest_t>::type construct_copy(dest_t && dest) const {
+	constructed_type<dest_t> construct_copy(dest_t && dest) const {
 		return construct(std::forward<dest_t>(dest));
 	};
 };

tpie/pipelining/pair_factory.h

@@ -147,10 +147,8 @@ template <typename fact1_t, typename fact2_t>
 class pair_factory : public pair_factory_base<pair_factory<fact1_t, fact2_t> > {
 public:
 	template <typename dest_t>
-	struct constructed {
-		typedef typename fact1_t::template constructed<typename fact2_t::template constructed<dest_t>::type>::type type;
-	};
-
+	using constructed_type = typename fact1_t::template constructed_type<typename fact2_t::template constructed_type<dest_t>>;
+
 	pair_factory(const pair_factory &) = delete;
 	pair_factory(pair_factory &&) = default;
 	pair_factory & operator=(const pair_factory &) = delete;
@@ -161,14 +159,12 @@ class pair_factory : public pair_factory_base<pair_factory<fact1_t, fact2_t> > {
 	}
 
 	template <typename dest_t>
-	typename constructed<dest_t>::type
-	construct(dest_t && dest) {
+	constructed_type<dest_t> construct(dest_t && dest) {
 		return this->record(0, fact1.construct(this->record(1, fact2.construct(std::forward<dest_t>(dest)))));
 	}
 
 	template <typename dest_t>
-	typename constructed<dest_t>::type
-	construct_copy(dest_t && dest) {
+	constructed_type<dest_t> construct_copy(dest_t && dest) {
 		return this->record(0, fact1.construct_copy(this->record(1, fact2.construct_copy(std::forward<dest_t>(dest)))));
 	}
 
@@ -189,9 +185,7 @@ class pair_factory : public pair_factory_base<pair_factory<fact1_t, fact2_t> > {
 template <typename fact1_t, typename termfact2_t>
 class termpair_factory : public pair_factory_base<termpair_factory<fact1_t, termfact2_t> > {
 public:
-	typedef typename fact1_t::template constructed<typename termfact2_t::constructed_type>::type constructed_type;
-
-
+	using constructed_type =  typename fact1_t::template constructed_type<typename termfact2_t::constructed_type>;
 
 	termpair_factory(const termpair_factory &) = delete;
 	termpair_factory(termpair_factory &&) = default;

tpie/pipelining/parallel/base.h

@@ -118,7 +118,7 @@ class threads_impl : public threads<Input, Output> {
 	typedef typename p_t::pi_t pi_t;
 
 	typedef after<Output> after_t;
-	typedef typename fact_t::template constructed<after_t>::type worker_t;
+	typedef typename fact_t::template constructed_type<after_t> worker_t;
 	typedef typename push_type<worker_t>::type T1;
 	typedef Output T2;
 	typedef before_impl<worker_t> before_t;
@@ -399,7 +399,7 @@ class state : public state_base {
 	std::unique_ptr<threads<T1, T2> > pipes;
 
 	template <typename fact_t>
-	state(const options opts, fact_t && fact)
+	state( options opts, fact_t && fact)
 		: state_base(opts)
 		, m_inputBuffers(opts.numJobs)
 		, m_outputBuffers(opts.numJobs)

tpie/pipelining/parallel/factory.h

@@ -41,21 +41,24 @@ class factory : public factory_base {
 		typedef typename push_type<dest_t>::type T2;
 
 		typedef after<T2> after_t;
-		typedef typename fact_t::template constructed<after_t>::type processor_t;
+		typedef typename fact_t::template constructed_type<after_t> processor_t;
 		typedef typename push_type<processor_t>::type T1;
 
 		typedef producer<T1, T2> type;
 	};
 
+
+	template <typename dest_t>
+	using constructed_type = typename constructed<dest_t>::type;
+
 	factory(fact_t && fact, options && opts)
 		: fact(std::move(fact))
 		, opts(std::move(opts))
 	{
 	}
 
 	template <typename dest_t>
-	typename constructed<dest_t>::type
-	construct(dest_t && dest) {
+	constructed_type<dest_t> construct(dest_t && dest) {
 		typedef constructed<dest_t> gen_t;
 
 		typedef typename gen_t::T1 input_type;
@@ -76,8 +79,7 @@ class factory : public factory_base {
 	}
 
 	template <typename dest_t>
-	typename constructed<dest_t>::type
-	construct_copy(dest_t && dest) {
+	constructed_type<dest_t> construct_copy(dest_t && dest) {
 		return construct(std::forward(dest));
 	}
 

tpie/pipelining/pipe_base.h

@@ -194,12 +194,16 @@ class pipe_nonterm_base : public pipe_base<child_t> {
 	pipe_nonterm_base & operator=(pipe_nonterm_base &&) = default;
 
 	template <typename dest_t>
-	struct constructed {
-		typedef typename child_t::factory_type::template constructed<dest_t>::type type;
+	class constructed {
+	public:
+		using type = typename child_t::factory_type::template constructed_type<dest_t>;
 	};
+
+	template <typename dest_t>
+	using constructed_type = typename constructed<dest_t>::type;
 
 	template <typename dest_t>
-	typename constructed<dest_t>::type construct(const dest_t & dest) {
+	constructed_type<dest_t> construct(const dest_t & dest) {
 		return this->self().factory.construct(dest);
 	}
 };

tpie/pipelining/serialization_sort.h

@@ -339,27 +339,20 @@ class sort_input_t : public node {
 	bool m_propagate_called;
 };
 
-template <typename child_t>
-class sort_factory_base : public factory_base {
-	const child_t & self() const { return *static_cast<const child_t *>(this); }
-public:
+///////////////////////////////////////////////////////////////////////////////
+/// \brief Sort factory using the given predicate as comparator.
+///////////////////////////////////////////////////////////////////////////////
+template <typename pred_t>
+class sort_factory : public factory_base {
 	template <typename dest_t>
-	struct constructed {
-	private:
-		/** Type of items sorted. */
-		typedef typename push_type<dest_t>::type item_type;
-	public:
-		typedef typename child_t::template predicate<item_type>::type pred_type;
-		typedef sorter_traits<item_type, pred_type> Traits;
-		typedef sort_input_t<Traits> type;
-	};
+	using constructed_type = sort_input_t<sorter_traits<typename push_type<dest_t>::type, pred_t>>;
 
 	template <typename dest_t>
-	typename constructed<dest_t>::type construct(dest_t dest) {
-		typedef typename push_type<dest_t>::type item_type;
-		typedef typename constructed<dest_t>::Traits Traits;
+	constructed_type<dest_t> construct(dest_t dest) {
+		using item_type = typename push_type<dest_t>::type;
+		using Traits = sorter_traits<item_type, pred_t>;
 
-		sort_output_t<Traits, dest_t> output(std::move(dest), self().template get_pred<item_type>());
+		sort_output_t<Traits, dest_t> output(std::move(dest), m_pred);
 		this->init_sub_node(output);
 		sort_calc_t<Traits> calc(std::move(output));
 		this->init_sub_node(calc);
@@ -368,68 +361,22 @@ class sort_factory_base : public factory_base {
 
 		return input;
 	}
-};
 
-///////////////////////////////////////////////////////////////////////////////
-/// \brief Sort factory using std::less<T> as comparator.
-///////////////////////////////////////////////////////////////////////////////
-class default_pred_sort_factory : public sort_factory_base<default_pred_sort_factory> {
-public:
-	template <typename item_type>
-	class predicate {
-	public:
-		typedef std::less<item_type> type;
-	};
+	sort_factory(const pred_t & p) : m_pred(p) {}
 
-	template <typename T>
-	std::less<T> get_pred() const {
-		return std::less<T>();
-	}
+	pred_t m_pred;
 };
 
-///////////////////////////////////////////////////////////////////////////////
-/// \brief Sort factory using the given predicate as comparator.
-///////////////////////////////////////////////////////////////////////////////
-template <typename pred_t>
-class sort_factory : public sort_factory_base<sort_factory<pred_t> > {
-public:
-	template <typename Dummy>
-	class predicate {
-	public:
-		typedef pred_t type;
-	};
-
-	sort_factory(const pred_t & p)
-		: pred(p)
-	{
-	}
-
-	template <typename T>
-	pred_t get_pred() const {
-		return pred;
-	}
-
-private:
-	pred_t pred;
-};
 
 } // namespace serialization_bits
 
-///////////////////////////////////////////////////////////////////////////////
-/// \brief Pipelining sorter using std::less.
-///////////////////////////////////////////////////////////////////////////////
-inline pipe_middle<serialization_bits::default_pred_sort_factory>
-serialization_sort() {
-	typedef serialization_bits::default_pred_sort_factory fact;
-	return pipe_middle<fact>(fact()).name("Sort");
-}
 
 ///////////////////////////////////////////////////////////////////////////////
 /// \brief Pipelining sorter using the given predicate.
 ///////////////////////////////////////////////////////////////////////////////
 template <typename pred_t>
 pipe_middle<serialization_bits::sort_factory<pred_t> >
-serialization_sort(const pred_t & p) {
+serialization_sort(const pred_t & p=std::less<void>()) {
 	typedef serialization_bits::sort_factory<pred_t> fact;
 	return pipe_middle<fact>(fact(p)).name("Sort");
 }