From 71f15e988b7247f19e4c0a99516e2e9ac218f1e5 Mon Sep 17 00:00:00 2001
From: Jakob Truelsen <jakob@scalgo.com>
Date: Sat, 8 Dec 2018 22:20:22 +0100
Subject: [PATCH] Use constructed_type instead of constructed::type and used
 std::less<void> in sorters. Fix #232 and #231

---
 tpie/pipelining/factory_helpers.h    |  49 +++++------
 tpie/pipelining/pair_factory.h       |  16 ++--
 tpie/pipelining/parallel/base.h      |   4 +-
 tpie/pipelining/parallel/factory.h   |  12 +--
 tpie/pipelining/pipe_base.h          |  10 ++-
 tpie/pipelining/serialization_sort.h |  79 +++---------------
 tpie/pipelining/sort.h               | 116 +++++----------------------
 tpie/pipelining/virtual.h            |  18 ++---
 8 files changed, 79 insertions(+), 225 deletions(-)

diff --git a/tpie/pipelining/factory_helpers.h b/tpie/pipelining/factory_helpers.h
index cfe1974e1..8022dc307 100644
--- a/tpie/pipelining/factory_helpers.h
+++ b/tpie/pipelining/factory_helpers.h
@@ -42,15 +42,13 @@ 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);
@@ -58,9 +56,9 @@ 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) {
 		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,15 +84,13 @@ 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);
@@ -102,9 +98,9 @@ class tempfactory : 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) {
 		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,14 +168,12 @@ 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);
@@ -187,9 +181,9 @@ class tfactory<R, Args<TT...>, T...> : 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) {
 		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,13 +206,10 @@ 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);
@@ -226,7 +217,7 @@ class split_factory : public factory_base {
 	};
 
 	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));
 	};
 };
diff --git a/tpie/pipelining/pair_factory.h b/tpie/pipelining/pair_factory.h
index bc615f31c..163d0b04f 100644
--- a/tpie/pipelining/pair_factory.h
+++ b/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;
diff --git a/tpie/pipelining/parallel/base.h b/tpie/pipelining/parallel/base.h
index b87c2cd9c..9c660d5e3 100644
--- a/tpie/pipelining/parallel/base.h
+++ b/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)
diff --git a/tpie/pipelining/parallel/factory.h b/tpie/pipelining/parallel/factory.h
index 3a29197e1..43015ce6d 100644
--- a/tpie/pipelining/parallel/factory.h
+++ b/tpie/pipelining/parallel/factory.h
@@ -41,12 +41,16 @@ 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))
@@ -54,8 +58,7 @@ class factory : public factory_base {
 	}
 
 	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));
 	}
 
diff --git a/tpie/pipelining/pipe_base.h b/tpie/pipelining/pipe_base.h
index 351c90f74..b73c11cc7 100644
--- a/tpie/pipelining/pipe_base.h
+++ b/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);
 	}
 };
diff --git a/tpie/pipelining/serialization_sort.h b/tpie/pipelining/serialization_sort.h
index 92dc16343..48b9dbf60 100644
--- a/tpie/pipelining/serialization_sort.h
+++ b/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");
 }
diff --git a/tpie/pipelining/sort.h b/tpie/pipelining/sort.h
index e8ffb7e94..141647110 100644
--- a/tpie/pipelining/sort.h
+++ b/tpie/pipelining/sort.h
@@ -393,126 +393,46 @@ class sort_input_t : public node {
 	sort_calc_t<T, pred_t, store_t> dest;
 };
 
-template <typename child_t, typename store_t>
-class sort_factory_base : public factory_base {
-	const child_t & self() const { return *static_cast<const child_t *>(this); }
+template <typename pred_t, typename store_t>
+class sort_factory : public factory_base {
 public:
 	template <typename dest_t>
-	struct constructed {
-	private:
-		/** Type of items sorted. */
-		typedef typename push_type<dest_t>::type item_type;
-		typedef typename store_t::template element_type<item_type>::type element_type;
-	public:
-		typedef typename child_t::template predicate<element_type>::type pred_type;
-		typedef sort_input_t<item_type, pred_type, store_t> type;
-	};
+	using constructed_type = sort_input_t<typename push_type<dest_t>::type, pred_t, store_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 store_t::template element_type<item_type>::type element_type;
-		typedef typename constructed<dest_t>::pred_type pred_type;
-
-		sort_output_t<pred_type, dest_t, store_t> output(
+	constructed_type<dest_t> construct(dest_t dest) {
+		using item_type = typename push_type<dest_t>::type;
+		sort_output_t<pred_t, dest_t, store_t> output(
 			std::move(dest),
-			std::make_shared<merge_sorter<item_type, true, pred_type, store_t> > (
-				self().template get_pred<element_type>(), 
+			std::make_shared<merge_sorter<item_type, true, pred_t, store_t> > (
+				m_pred,
 				m_store));
 		this->init_sub_node(output);
-		sort_calc_t<item_type, pred_type, store_t> calc(std::move(output));
+		sort_calc_t<item_type, pred_t, store_t> calc(std::move(output));
 		this->init_sub_node(calc);
-		sort_input_t<item_type, pred_type, store_t> input(std::move(calc));
+		sort_input_t<item_type, pred_t, store_t> input(std::move(calc));
 		this->init_sub_node(input);
-
 		return std::move(input);
 	}
 
-	sort_factory_base(store_t store): m_store(store) {}
+	sort_factory(const pred_t & pred, store_t store): m_pred(pred), m_store(store) {}
 private:
+	pred_t m_pred;
 	store_t m_store;
 
 };
 
-///////////////////////////////////////////////////////////////////////////////
-/// \brief Sort factory using std::less<T> as comparator.
-///////////////////////////////////////////////////////////////////////////////
-template <typename store_t>
-class default_pred_sort_factory : public sort_factory_base<default_pred_sort_factory<store_t>, store_t> {
-public:
-	template <typename item_type>
-	class predicate {
-	public:
-		typedef std::less<item_type> type;
-	};
-	
-	template <typename T>
-	std::less<T> get_pred() const {
-		return std::less<T>();
-	}
-
-	default_pred_sort_factory(const store_t & store)
-		: sort_factory_base<default_pred_sort_factory<store_t>, store_t>(store) 
-	{
-	}
-};
-
-///////////////////////////////////////////////////////////////////////////////
-/// \brief Sort factory using the given predicate as comparator.
-///////////////////////////////////////////////////////////////////////////////
-template <typename pred_t, typename store_t>
-class sort_factory : public sort_factory_base<sort_factory<pred_t, store_t>, store_t> {
-public:
-	template <typename Dummy>
-	class predicate {
-	public:
-		typedef pred_t type;
-	};
-
-	sort_factory(const pred_t & p, const store_t & store)
-		: sort_factory_base<sort_factory<pred_t, store_t>, store_t>(store)
-		, pred(p)
-	{
-	}
-
-	template <typename T>
-	pred_t get_pred() const {
-		return pred;
-	}
-private:
-	pred_t pred;
-};
-
 } // namespace bits
 
-///////////////////////////////////////////////////////////////////////////////
-/// \brief Pipelining sorter using std::less.
-///////////////////////////////////////////////////////////////////////////////
-inline pipe_middle<bits::default_pred_sort_factory<default_store> >
-sort() {
-	typedef bits::default_pred_sort_factory<default_store> fact;
-	return pipe_middle<fact>(fact(default_store())).name("Sort");
-}
-
 ///////////////////////////////////////////////////////////////////////////////
 /// \brief A pipelining node that sorts large elements indirectly by using 
 /// a store and std::less.
 ///////////////////////////////////////////////////////////////////////////////
 template <typename store_t>
-inline pipe_middle<bits::default_pred_sort_factory<store_t> >
+inline pipe_middle<bits::sort_factory<std::less<void>, store_t> >
 store_sort(store_t store=store_t()) {
-	typedef bits::default_pred_sort_factory<store_t> fact;
-	return pipe_middle<fact>(fact(store)).name("Sort");
-}
-
-///////////////////////////////////////////////////////////////////////////////
-/// \brief Pipelining sorter using the given predicate.
-///////////////////////////////////////////////////////////////////////////////
-template <typename pred_t>
-inline pipe_middle<bits::sort_factory<pred_t, default_store> >
-sort(const pred_t & p) {
-	typedef bits::sort_factory<pred_t, default_store> fact;
-	return pipe_middle<fact>(fact(p, default_store())).name("Sort");
+	typedef bits::sort_factory<std::less<void>, store_t> fact;
+	return pipe_middle<fact>(fact(std::less<void>(), store)).name("Sort");
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -528,11 +448,11 @@ store_sort(const pred_t & p, store_t store=store_t()) {
 
 ///////////////////////////////////////////////////////////////////////////////
 /// \brief A pipelining node that sorts large elements indirectly by using 
-/// a storeand a given predicate.
+/// a store and a given predicate.
 ///////////////////////////////////////////////////////////////////////////////
-template <typename pred_t, typename store_t>
+template <typename pred_t=std::less<void>, typename store_t=default_store>
 inline pipe_middle<bits::sort_factory<pred_t, store_t> >
-sort(const pred_t & p, store_t store) {
+sort(const pred_t & p=std::less<void>(), store_t store=default_store()) {
 	typedef bits::sort_factory<pred_t, store_t> fact;
 	return pipe_middle<fact>(fact(p, store)).name("Sort");
 }
diff --git a/tpie/pipelining/virtual.h b/tpie/pipelining/virtual.h
index 742e924fc..98f22e40b 100644
--- a/tpie/pipelining/virtual.h
+++ b/tpie/pipelining/virtual.h
@@ -580,7 +580,7 @@ class virtual_chunk : public bits::virtual_chunk_base {
 			log_error() << "Virtual chunk assigned twice" << std::endl;
 			throw tpie::exception("Virtual chunk assigned twice");
 		}
-		typedef typename fact_t::template constructed<output_type>::type constructed_type;
+		typedef typename fact_t::template constructed_type<output_type> constructed_type;
 		output_type temp(m_output);
 		this->m_nodeMap = temp.get_node_map();
 		fact_t f = std::move(pipe.factory);
@@ -690,7 +690,7 @@ class virtual_chunk_begin : public bits::virtual_chunk_base {
 			log_error() << "Virtual chunk assigned twice" << std::endl;
 			throw tpie::exception("Virtual chunk assigned twice");
 		}
-		typedef typename fact_t::template constructed<output_type>::type constructed_type;
+		typedef typename fact_t::template constructed_type<output_type> constructed_type;
 		output_type temp(m_output);
 		this->m_nodeMap = m_output->get_node_map();
 		fact_t f = std::move(pipe.factory);
@@ -780,7 +780,7 @@ class virtual_chunk_pull_end : public bits::virtual_chunk_base {
 			log_error() << "Virtual chunk assigned twice" << std::endl;
 			throw tpie::exception("Virtual chunk assigned twice");
 		}
-		typedef typename fact_t::template constructed<input_type>::type constructed_type;
+		typedef typename fact_t::template constructed_type<input_type> constructed_type;
 		input_type temp(m_input);
 		this->m_nodeMap = m_input->get_node_map();
 		fact_t f = std::move(pipe.factory);
@@ -866,7 +866,7 @@ class virtual_chunk_pull : public bits::virtual_chunk_base {
 			log_error() << "Virtual chunk assigned twice" << std::endl;
 			throw tpie::exception("Virtual chunk assigned twice");
 		}
-		typedef typename fact_t::template constructed<input_type>::type constructed_type;
+		typedef typename fact_t::template constructed_type<input_type> constructed_type;
 		input_type temp(m_input);
 		this->m_nodeMap = temp.get_node_map();
 		fact_t f = std::move(pipe.factory);
@@ -1179,9 +1179,7 @@ template <typename Input, typename Output>
 class devirtualization_factory: public factory_base {
 public:
 	template <typename dest_t>
-	struct constructed {
-		using type = bits::devirtualize_end_node<Input>;
-	};
+	using constructed_type = bits::devirtualize_end_node<Input>;
 
 	devirtualization_factory(const devirtualization_factory &) = delete;
 	devirtualization_factory(devirtualization_factory &&) = default;
@@ -1279,10 +1277,8 @@ template <typename Input, typename Output>
 class devirtualization_pull_factory: public factory_base {
 public:
 	template <typename src_t>
-	struct constructed {
-		using type = bits::devirtualize_pull_begin_node<Output>;
-	};
-
+	using constructed_type = bits::devirtualize_pull_begin_node<Output>;
+	
 	devirtualization_pull_factory(const devirtualization_pull_factory &) = delete;
 	devirtualization_pull_factory(devirtualization_pull_factory &&) = default;
 	devirtualization_pull_factory & operator=(const devirtualization_pull_factory &) = delete;