/*
    Copyright 2005-2013 Intel Corporation.  All Rights Reserved.

    This file is part of Threading Building Blocks.

    Threading Building Blocks is free software; you can redistribute it
    and/or modify it under the terms of the GNU General Public License
    version 2 as published by the Free Software Foundation.

    Threading Building Blocks is distributed in the hope that it will be
    useful, but WITHOUT ANY WARRANTY; without even the implied warranty
    of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with Threading Building Blocks; if not, write to the Free Software
    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

    As a special exception, you may use this file as part of a free software
    library without restriction.  Specifically, if other files instantiate
    templates or use macros or inline functions from this file, or you compile
    this file and link it with other files to produce an executable, this
    file does not by itself cause the resulting executable to be covered by
    the GNU General Public License.  This exception does not however
    invalidate any other reasons why the executable file might be covered by
    the GNU General Public License.
*/

#ifndef __TBB__flow_graph_join_impl_H
#define __TBB__flow_graph_join_impl_H

#ifndef __TBB_flow_graph_H
#error Do not #include this internal file directly; use public TBB headers instead.
#endif

#include "tbb/internal/_flow_graph_types_impl.h"

namespace internal {

    typedef size_t tag_value;
    static const tag_value NO_TAG = tag_value(-1);

    struct forwarding_base {
        forwarding_base(task *rt) : my_root_task(rt), current_tag(NO_TAG) {}
        virtual ~forwarding_base() {}
        // decrement_port_count may create a forwarding task.  If we cannot handle the task
        // ourselves, ask decrement_port_count to deal with it.
        virtual task * decrement_port_count(bool handle_task) = 0;
        virtual void increment_port_count() = 0;
        virtual task * increment_tag_count(tag_value /*t*/, bool /*handle_task*/) {return NULL;}
        // moved here so input ports can queue tasks
        task* my_root_task;
        tag_value current_tag; // so ports can refer to FE's desired items
    };

    template< int N >
    struct join_helper {

        template< typename TupleType, typename PortType >
        static inline void set_join_node_pointer(TupleType &my_input, PortType *port) {
            tbb::flow::get<N-1>( my_input ).set_join_node_pointer(port);
            join_helper<N-1>::set_join_node_pointer( my_input, port );
        }
        template< typename TupleType >
        static inline void consume_reservations( TupleType &my_input ) {
            tbb::flow::get<N-1>( my_input ).consume();
            join_helper<N-1>::consume_reservations( my_input );
        }

        template< typename TupleType >
        static inline void release_my_reservation( TupleType &my_input ) {
            tbb::flow::get<N-1>( my_input ).release();
        }

        template <typename TupleType>
        static inline void release_reservations( TupleType &my_input) {
            join_helper<N-1>::release_reservations(my_input);
            release_my_reservation(my_input);
        }

        template< typename InputTuple, typename OutputTuple >
        static inline bool reserve( InputTuple &my_input, OutputTuple &out) {
            if ( !tbb::flow::get<N-1>( my_input ).reserve( tbb::flow::get<N-1>( out ) ) ) return false;
            if ( !join_helper<N-1>::reserve( my_input, out ) ) {
                release_my_reservation( my_input );
                return false;
            }
            return true;
        }

        template<typename InputTuple, typename OutputTuple>
        static inline bool get_my_item( InputTuple &my_input, OutputTuple &out) {
            bool res = tbb::flow::get<N-1>(my_input).get_item(tbb::flow::get<N-1>(out) ); // may fail
            return join_helper<N-1>::get_my_item(my_input, out) && res;       // do get on other inputs before returning
        }

        template<typename InputTuple, typename OutputTuple>
        static inline bool get_items(InputTuple &my_input, OutputTuple &out) {
            return get_my_item(my_input, out);
        }

        template<typename InputTuple>
        static inline void reset_my_port(InputTuple &my_input) {
            join_helper<N-1>::reset_my_port(my_input);
            tbb::flow::get<N-1>(my_input).reset_port();
        }

        template<typename InputTuple>
        static inline void reset_ports(InputTuple& my_input) {
            reset_my_port(my_input);
        }

        template<typename InputTuple, typename TagFuncTuple>
        static inline void set_tag_func(InputTuple &my_input, TagFuncTuple &my_tag_funcs) {
            tbb::flow::get<N-1>(my_input).set_my_original_tag_func(tbb::flow::get<N-1>(my_tag_funcs));
            tbb::flow::get<N-1>(my_input).set_my_tag_func(tbb::flow::get<N-1>(my_input).my_original_func()->clone());
            tbb::flow::get<N-1>(my_tag_funcs) = NULL;
            join_helper<N-1>::set_tag_func(my_input, my_tag_funcs);
        }

        template< typename TagFuncTuple1, typename TagFuncTuple2>
        static inline void copy_tag_functors(TagFuncTuple1 &my_inputs, TagFuncTuple2 &other_inputs) {
            if(tbb::flow::get<N-1>(other_inputs).my_original_func()) {
                tbb::flow::get<N-1>(my_inputs).set_my_tag_func(tbb::flow::get<N-1>(other_inputs).my_original_func()->clone());
                tbb::flow::get<N-1>(my_inputs).set_my_original_tag_func(tbb::flow::get<N-1>(other_inputs).my_original_func()->clone());
            }
            join_helper<N-1>::copy_tag_functors(my_inputs, other_inputs);
        }

        template<typename InputTuple>
        static inline void reset_inputs(InputTuple &my_input) {
            join_helper<N-1>::reset_inputs(my_input);
            tbb::flow::get<N-1>(my_input).reinitialize_port();
        }
    };

    template< >
    struct join_helper<1> {

        template< typename TupleType, typename PortType >
        static inline void set_join_node_pointer(TupleType &my_input, PortType *port) {
            tbb::flow::get<0>( my_input ).set_join_node_pointer(port);
        }

        template< typename TupleType >
        static inline void consume_reservations( TupleType &my_input ) {
            tbb::flow::get<0>( my_input ).consume();
        }

        template< typename TupleType >
        static inline void release_my_reservation( TupleType &my_input ) {
            tbb::flow::get<0>( my_input ).release();
        }

        template<typename TupleType>
        static inline void release_reservations( TupleType &my_input) {
            release_my_reservation(my_input);
        }

        template< typename InputTuple, typename OutputTuple >
        static inline bool reserve( InputTuple &my_input, OutputTuple &out) {
            return tbb::flow::get<0>( my_input ).reserve( tbb::flow::get<0>( out ) );
        }

        template<typename InputTuple, typename OutputTuple>
        static inline bool get_my_item( InputTuple &my_input, OutputTuple &out) {
            return tbb::flow::get<0>(my_input).get_item(tbb::flow::get<0>(out));
        }

        template<typename InputTuple, typename OutputTuple>
        static inline bool get_items(InputTuple &my_input, OutputTuple &out) {
            return get_my_item(my_input, out);
        }

        template<typename InputTuple>
        static inline void reset_my_port(InputTuple &my_input) {
            tbb::flow::get<0>(my_input).reset_port();
        }

        template<typename InputTuple>
        static inline void reset_ports(InputTuple& my_input) {
            reset_my_port(my_input);
        }

        template<typename InputTuple, typename TagFuncTuple>
        static inline void set_tag_func(InputTuple &my_input, TagFuncTuple &my_tag_funcs) {
            tbb::flow::get<0>(my_input).set_my_original_tag_func(tbb::flow::get<0>(my_tag_funcs));
            tbb::flow::get<0>(my_input).set_my_tag_func(tbb::flow::get<0>(my_input).my_original_func()->clone());
            tbb::flow::get<0>(my_tag_funcs) = NULL;
        }

        template< typename TagFuncTuple1, typename TagFuncTuple2>
        static inline void copy_tag_functors(TagFuncTuple1 &my_inputs, TagFuncTuple2 &other_inputs) {
            if(tbb::flow::get<0>(other_inputs).my_original_func()) {
                tbb::flow::get<0>(my_inputs).set_my_tag_func(tbb::flow::get<0>(other_inputs).my_original_func()->clone());
                tbb::flow::get<0>(my_inputs).set_my_original_tag_func(tbb::flow::get<0>(other_inputs).my_original_func()->clone());
            }
        }
        template<typename InputTuple>
        static inline void reset_inputs(InputTuple &my_input) {
            tbb::flow::get<0>(my_input).reinitialize_port();
        }
    };

    //! The two-phase join port
    template< typename T >
    class reserving_port : public receiver<T> {
    public:
        typedef T input_type;
        typedef sender<T> predecessor_type;
    private:
        // ----------- Aggregator ------------
        enum op_type { reg_pred, rem_pred, res_item, rel_res, con_res };
        enum op_stat {WAIT=0, SUCCEEDED, FAILED};
        typedef reserving_port<T> my_class;

        class reserving_port_operation : public aggregated_operation<reserving_port_operation> {
        public:
            char type;
            union {
                T *my_arg;
                predecessor_type *my_pred;
            };
            reserving_port_operation(const T& e, op_type t) :
                type(char(t)), my_arg(const_cast<T*>(&e)) {}
            reserving_port_operation(const predecessor_type &s, op_type t) : type(char(t)), 
                my_pred(const_cast<predecessor_type *>(&s)) {}
            reserving_port_operation(op_type t) : type(char(t)) {}
        };

        typedef internal::aggregating_functor<my_class, reserving_port_operation> my_handler;
        friend class internal::aggregating_functor<my_class, reserving_port_operation>;
        aggregator<my_handler, reserving_port_operation> my_aggregator;

        void handle_operations(reserving_port_operation* op_list) {
            reserving_port_operation *current;
            bool no_predecessors;
            while(op_list) {
                current = op_list;
                op_list = op_list->next;
                switch(current->type) {
                case reg_pred:
                    no_predecessors = my_predecessors.empty();
                    my_predecessors.add(*(current->my_pred));
                    if ( no_predecessors ) {
                        (void) my_join->decrement_port_count(true); // may try to forward
                    }
                    __TBB_store_with_release(current->status, SUCCEEDED);
                    break;
                case rem_pred:
                    my_predecessors.remove(*(current->my_pred));
                    if(my_predecessors.empty()) my_join->increment_port_count();
                    __TBB_store_with_release(current->status, SUCCEEDED);
                    break;
                case res_item:
                    if ( reserved ) {
                        __TBB_store_with_release(current->status, FAILED);
                    }
                    else if ( my_predecessors.try_reserve( *(current->my_arg) ) ) {
                        reserved = true;
                        __TBB_store_with_release(current->status, SUCCEEDED);
                    } else {
                        if ( my_predecessors.empty() ) {
                            my_join->increment_port_count();
                        }
                        __TBB_store_with_release(current->status, FAILED);
                    }
                    break;
                case rel_res:
                    reserved = false;
                    my_predecessors.try_release( );
                    __TBB_store_with_release(current->status, SUCCEEDED);
                    break;
                case con_res:
                    reserved = false;
                    my_predecessors.try_consume( );
                    __TBB_store_with_release(current->status, SUCCEEDED);
                    break;
                }
            }
        }

    protected:
        template< typename R, typename B > friend class run_and_put_task;
        template<typename X, typename Y> friend class internal::broadcast_cache;
        template<typename X, typename Y> friend class internal::round_robin_cache;
        task *try_put_task( const T & ) {
            return NULL;
        }

    public:

        //! Constructor
        reserving_port() : reserved(false) {
            my_join = NULL;
            my_predecessors.set_owner( this );
            my_aggregator.initialize_handler(my_handler(this));
        }

        // copy constructor
        reserving_port(const reserving_port& /* other */) : receiver<T>() {
            reserved = false;
            my_join = NULL;
            my_predecessors.set_owner( this );
            my_aggregator.initialize_handler(my_handler(this));
        }

        void set_join_node_pointer(forwarding_base *join) {
            my_join = join;
        }

        //! Add a predecessor
        bool register_predecessor( sender<T> &src ) {
            reserving_port_operation op_data(src, reg_pred);
            my_aggregator.execute(&op_data);
            return op_data.status == SUCCEEDED;
        }

        //! Remove a predecessor
        bool remove_predecessor( sender<T> &src ) {
            reserving_port_operation op_data(src, rem_pred);
            my_aggregator.execute(&op_data);
            return op_data.status == SUCCEEDED;
        }

        //! Reserve an item from the port
        bool reserve( T &v ) {
            reserving_port_operation op_data(v, res_item);
            my_aggregator.execute(&op_data);
            return op_data.status == SUCCEEDED;
        }

        //! Release the port
        void release( ) {
            reserving_port_operation op_data(rel_res);
            my_aggregator.execute(&op_data);
        }

        //! Complete use of the port
        void consume( ) {
            reserving_port_operation op_data(con_res);
            my_aggregator.execute(&op_data);
        }

        void reinitialize_port() {
            my_predecessors.reset();
            reserved = false;
        }

    protected:

        /*override*/void reset_receiver() {
            my_predecessors.reset();
        }

    private:
        forwarding_base *my_join;
        reservable_predecessor_cache< T, null_mutex > my_predecessors;
        bool reserved;
    };

    //! queueing join_port
    template<typename T>
    class queueing_port : public receiver<T>, public item_buffer<T> {
    public:
        typedef T input_type;
        typedef sender<T> predecessor_type;
        typedef queueing_port<T> my_node_type;

    // ----------- Aggregator ------------
    private:
        enum op_type { get__item, res_port, try__put_task };
        enum op_stat {WAIT=0, SUCCEEDED, FAILED};
        typedef queueing_port<T> my_class;

        class queueing_port_operation : public aggregated_operation<queueing_port_operation> {
        public:
            char type;
            T my_val;
            T *my_arg;
            task * bypass_t;
            // constructor for value parameter
            queueing_port_operation(const T& e, op_type t) :
                type(char(t)), my_val(e)
                , bypass_t(NULL)
            {}
            // constructor for pointer parameter
            queueing_port_operation(const T* p, op_type t) :
                type(char(t)), my_arg(const_cast<T*>(p))
                , bypass_t(NULL)
            {}
            // constructor with no parameter
            queueing_port_operation(op_type t) : type(char(t))
                , bypass_t(NULL)
            {}
        };

        typedef internal::aggregating_functor<my_class, queueing_port_operation> my_handler;
        friend class internal::aggregating_functor<my_class, queueing_port_operation>;
        aggregator<my_handler, queueing_port_operation> my_aggregator;

        void handle_operations(queueing_port_operation* op_list) {
            queueing_port_operation *current;
            bool was_empty;
            while(op_list) {
                current = op_list;
                op_list = op_list->next;
                switch(current->type) {
                case try__put_task: {
                        task *rtask = NULL;
                        was_empty = this->buffer_empty();
                        this->push_back(current->my_val);
                        if (was_empty) rtask = my_join->decrement_port_count(false);
                        else
                            rtask = SUCCESSFULLY_ENQUEUED;
                        current->bypass_t = rtask;
                        __TBB_store_with_release(current->status, SUCCEEDED);
                    }
                    break;
                case get__item:
                    if(!this->buffer_empty()) {
                        this->fetch_front(*(current->my_arg));
                        __TBB_store_with_release(current->status, SUCCEEDED);
                    }
                    else {
                        __TBB_store_with_release(current->status, FAILED);
                    }
                    break;
                case res_port:
                    __TBB_ASSERT(this->item_valid(this->my_head), "No item to reset");
                    this->invalidate_front(); ++(this->my_head);
                    if(this->item_valid(this->my_head)) {
                        (void)my_join->decrement_port_count(true);
                    }
                    __TBB_store_with_release(current->status, SUCCEEDED);
                    break;
                }
            }
        }
    // ------------ End Aggregator ---------------

    protected:
        template< typename R, typename B > friend class run_and_put_task;
        template<typename X, typename Y> friend class internal::broadcast_cache;
        template<typename X, typename Y> friend class internal::round_robin_cache;
        /*override*/task *try_put_task(const T &v) {
            queueing_port_operation op_data(v, try__put_task);
            my_aggregator.execute(&op_data);
            __TBB_ASSERT(op_data.status == SUCCEEDED || !op_data.bypass_t, "inconsistent return from aggregator");
            if(!op_data.bypass_t) return SUCCESSFULLY_ENQUEUED;
            return op_data.bypass_t;
        }

    public:

        //! Constructor
        queueing_port() : item_buffer<T>() {
            my_join = NULL;
            my_aggregator.initialize_handler(my_handler(this));
        }

        //! copy constructor
        queueing_port(const queueing_port& /* other */) : receiver<T>(), item_buffer<T>() {
            my_join = NULL;
            my_aggregator.initialize_handler(my_handler(this));
        }

        //! record parent for tallying available items
        void set_join_node_pointer(forwarding_base *join) {
            my_join = join;
        }

        bool get_item( T &v ) {
            queueing_port_operation op_data(&v, get__item);
            my_aggregator.execute(&op_data);
            return op_data.status == SUCCEEDED;
        }

        // reset_port is called when item is accepted by successor, but
        // is initiated by join_node.
        void reset_port() {
            queueing_port_operation op_data(res_port);
            my_aggregator.execute(&op_data);
            return;
        }

        void reinitialize_port() {
            item_buffer<T>::reset();
        }

    protected:

        /*override*/void reset_receiver() {
            // nothing to do.  We queue, so no predecessor cache
        }

    private:
        forwarding_base *my_join;
    };

#include "_flow_graph_tagged_buffer_impl.h"

    template< typename T >
    class tag_matching_port : public receiver<T>, public tagged_buffer< tag_value, T, NO_TAG > {
    public:
        typedef T input_type;
        typedef sender<T> predecessor_type;
        typedef tag_matching_port<T> my_node_type;  // for forwarding, if needed
        typedef function_body<input_type, tag_value> my_tag_func_type;
        typedef tagged_buffer<tag_value,T,NO_TAG> my_buffer_type;
    private:
// ----------- Aggregator ------------
    private:
        enum op_type { try__put, get__item, res_port };
        enum op_stat {WAIT=0, SUCCEEDED, FAILED};
        typedef tag_matching_port<T> my_class;

        class tag_matching_port_operation : public aggregated_operation<tag_matching_port_operation> {
        public:
            char type;
            T my_val;
            T *my_arg;
            tag_value my_tag_value;
            // constructor for value parameter
            tag_matching_port_operation(const T& e, op_type t) :
                type(char(t)), my_val(e) {}
            // constructor for pointer parameter
            tag_matching_port_operation(const T* p, op_type t) :
                type(char(t)), my_arg(const_cast<T*>(p)) {}
            // constructor with no parameter
            tag_matching_port_operation(op_type t) : type(char(t)) {}
        };

        typedef internal::aggregating_functor<my_class, tag_matching_port_operation> my_handler;
        friend class internal::aggregating_functor<my_class, tag_matching_port_operation>;
        aggregator<my_handler, tag_matching_port_operation> my_aggregator;

        void handle_operations(tag_matching_port_operation* op_list) {
            tag_matching_port_operation *current;
            while(op_list) {
                current = op_list;
                op_list = op_list->next;
                switch(current->type) {
                case try__put: {
                        bool was_inserted = this->tagged_insert(current->my_tag_value, current->my_val);
                        // return failure if a duplicate insertion occurs
                        __TBB_store_with_release(current->status, was_inserted ? SUCCEEDED : FAILED);
                    }
                    break;
                case get__item:
                    // use current_tag from FE for item
                    if(!this->tagged_find(my_join->current_tag, *(current->my_arg))) {
                        __TBB_ASSERT(false, "Failed to find item corresponding to current_tag.");
                    }
                    __TBB_store_with_release(current->status, SUCCEEDED);
                    break;
                case res_port:
                    // use current_tag from FE for item
                    this->tagged_delete(my_join->current_tag);
                    __TBB_store_with_release(current->status, SUCCEEDED);
                    break;
                }
            }
        }
// ------------ End Aggregator ---------------
    protected:
        template< typename R, typename B > friend class run_and_put_task;
        template<typename X, typename Y> friend class internal::broadcast_cache;
        template<typename X, typename Y> friend class internal::round_robin_cache;
        /*override*/task *try_put_task(const T& v) {
            tag_matching_port_operation op_data(v, try__put);
            op_data.my_tag_value = (*my_tag_func)(v);
            task *rtask = NULL;
            my_aggregator.execute(&op_data);
            if(op_data.status == SUCCEEDED) {
                rtask = my_join->increment_tag_count(op_data.my_tag_value, false);  // may spawn
                // rtask has to reflect the return status of the try_put
                if(!rtask) rtask = SUCCESSFULLY_ENQUEUED;
            }
            return rtask;
        }

    public:

        tag_matching_port() : receiver<T>(), tagged_buffer<tag_value, T, NO_TAG>() {
            my_join = NULL;
            my_tag_func = NULL;
            my_original_tag_func = NULL;
            my_aggregator.initialize_handler(my_handler(this));
        }

        // copy constructor
        tag_matching_port(const tag_matching_port& /*other*/) : receiver<T>(), tagged_buffer<tag_value,T, NO_TAG>() {
            my_join = NULL;
            // setting the tag methods is done in the copy-constructor for the front-end.
            my_tag_func = NULL;
            my_original_tag_func = NULL;
            my_aggregator.initialize_handler(my_handler(this));
        }

        ~tag_matching_port() {
            if (my_tag_func) delete my_tag_func;
            if (my_original_tag_func) delete my_original_tag_func;
        }

        void set_join_node_pointer(forwarding_base *join) {
            my_join = join;
        }

        void set_my_original_tag_func(my_tag_func_type *f) {
            my_original_tag_func = f;
        }

        void set_my_tag_func(my_tag_func_type *f) {
            my_tag_func = f;
        }

        bool get_item( T &v ) {
            tag_matching_port_operation op_data(&v, get__item);
            my_aggregator.execute(&op_data);
            return op_data.status == SUCCEEDED;
        }

        // reset_port is called when item is accepted by successor, but
        // is initiated by join_node.
        void reset_port() {
            tag_matching_port_operation op_data(res_port);
            my_aggregator.execute(&op_data);
            return;
        }

        my_tag_func_type *my_func() { return my_tag_func; }
        my_tag_func_type *my_original_func() { return my_original_tag_func; }

        void reinitialize_port() {
            my_buffer_type::reset();
        }

    protected:

        /*override*/void reset_receiver() {
            // nothing to do.  We queue, so no predecessor cache
        }

    private:
        // need map of tags to values
        forwarding_base *my_join;
        my_tag_func_type *my_tag_func;
        my_tag_func_type *my_original_tag_func;
    };  // tag_matching_port

    using namespace graph_policy_namespace;

    template<graph_buffer_policy JP, typename InputTuple, typename OutputTuple>
    class join_node_base;

    //! join_node_FE : implements input port policy
    template<graph_buffer_policy JP, typename InputTuple, typename OutputTuple>
    class join_node_FE;

    template<typename InputTuple, typename OutputTuple>
    class join_node_FE<reserving, InputTuple, OutputTuple> : public forwarding_base {
    public:
        static const int N = tbb::flow::tuple_size<OutputTuple>::value;
        typedef OutputTuple output_type;
        typedef InputTuple input_type;
        typedef join_node_base<reserving, InputTuple, OutputTuple> my_node_type; // for forwarding

        join_node_FE(graph &g) : forwarding_base(g.root_task()), my_node(NULL) {
            ports_with_no_inputs = N;
            join_helper<N>::set_join_node_pointer(my_inputs, this);
        }

        join_node_FE(const join_node_FE& other) : forwarding_base(other.my_root_task), my_node(NULL) {
            ports_with_no_inputs = N;
            join_helper<N>::set_join_node_pointer(my_inputs, this);
        }

        void set_my_node(my_node_type *new_my_node) { my_node = new_my_node; }

       void increment_port_count() {
            ++ports_with_no_inputs;
        }

        // if all input_ports have predecessors, spawn forward to try and consume tuples
        task * decrement_port_count(bool handle_task) {
            if(ports_with_no_inputs.fetch_and_decrement() == 1) {
                task *rtask = new ( task::allocate_additional_child_of( *(this->my_root_task) ) )
                    forward_task_bypass
                    <my_node_type>(*my_node);
                if(!handle_task) return rtask;
                task::enqueue(*rtask);
            }
            return NULL;
        }

        input_type &input_ports() { return my_inputs; }

    protected:

        void reset() {
            // called outside of parallel contexts
            ports_with_no_inputs = N;
            join_helper<N>::reset_inputs(my_inputs);
        }

        // all methods on input ports should be called under mutual exclusion from join_node_base.

        bool tuple_build_may_succeed() {
            return !ports_with_no_inputs;
        }

        bool try_to_make_tuple(output_type &out) {
            if(ports_with_no_inputs) return false;
            return join_helper<N>::reserve(my_inputs, out);
        }

        void tuple_accepted() {
            join_helper<N>::consume_reservations(my_inputs);
        }
        void tuple_rejected() {
            join_helper<N>::release_reservations(my_inputs);
        }

        input_type my_inputs;
        my_node_type *my_node;
        atomic<size_t> ports_with_no_inputs;
    };

    template<typename InputTuple, typename OutputTuple>
    class join_node_FE<queueing, InputTuple, OutputTuple> : public forwarding_base {
    public:
        static const int N = tbb::flow::tuple_size<OutputTuple>::value;
        typedef OutputTuple output_type;
        typedef InputTuple input_type;
        typedef join_node_base<queueing, InputTuple, OutputTuple> my_node_type; // for forwarding

        join_node_FE(graph &g) : forwarding_base(g.root_task()), my_node(NULL) {
            ports_with_no_items = N;
            join_helper<N>::set_join_node_pointer(my_inputs, this);
        }

        join_node_FE(const join_node_FE& other) : forwarding_base(other.my_root_task), my_node(NULL) {
            ports_with_no_items = N;
            join_helper<N>::set_join_node_pointer(my_inputs, this);
        }

        // needed for forwarding
        void set_my_node(my_node_type *new_my_node) { my_node = new_my_node; }

        void reset_port_count() {
            ports_with_no_items = N;
        }

        // if all input_ports have items, spawn forward to try and consume tuples
        task * decrement_port_count(bool handle_task)
        {
            if(ports_with_no_items.fetch_and_decrement() == 1) {
                task *rtask = new ( task::allocate_additional_child_of( *(this->my_root_task) ) )
                    forward_task_bypass
                    <my_node_type>(*my_node);
                if(!handle_task) return rtask;
                task::enqueue( *rtask);
            }
            return NULL;
        }

        void increment_port_count() { __TBB_ASSERT(false, NULL); }  // should never be called

        input_type &input_ports() { return my_inputs; }

    protected:

        void reset() {
            reset_port_count();
            join_helper<N>::reset_inputs(my_inputs);
        }

        // all methods on input ports should be called under mutual exclusion from join_node_base.

        bool tuple_build_may_succeed() {
            return !ports_with_no_items;
        }

        bool try_to_make_tuple(output_type &out) {
            if(ports_with_no_items) return false;
            return join_helper<N>::get_items(my_inputs, out);
        }

        void tuple_accepted() {
            reset_port_count();
            join_helper<N>::reset_ports(my_inputs);
        }
        void tuple_rejected() {
            // nothing to do.
        }

        input_type my_inputs;
        my_node_type *my_node;
        atomic<size_t> ports_with_no_items;
    };

    // tag_matching join input port.
    template<typename InputTuple, typename OutputTuple>
    class join_node_FE<tag_matching, InputTuple, OutputTuple> : public forwarding_base,
             //     buffer of tag value counts                       buffer of output items
             public tagged_buffer<tag_value, size_t, NO_TAG>, public item_buffer<OutputTuple> {
    public:
        static const int N = tbb::flow::tuple_size<OutputTuple>::value;
        typedef OutputTuple output_type;
        typedef InputTuple input_type;
        typedef tagged_buffer<tag_value, size_t, NO_TAG> my_tag_buffer;
        typedef item_buffer<output_type> output_buffer_type;
        typedef join_node_base<tag_matching, InputTuple, OutputTuple> my_node_type; // for forwarding

// ----------- Aggregator ------------
        // the aggregator is only needed to serialize the access to the hash table.
        // and the output_buffer_type base class
    private:
        enum op_type { res_count, inc_count, may_succeed, try_make };
        enum op_stat {WAIT=0, SUCCEEDED, FAILED};
        typedef join_node_FE<tag_matching, InputTuple, OutputTuple> my_class;

        class tag_matching_FE_operation : public aggregated_operation<tag_matching_FE_operation> {
        public:
            char type;
            union {
                tag_value my_val;
                output_type* my_output;
            };
            task *bypass_t;
            bool enqueue_task;
            // constructor for value parameter
            tag_matching_FE_operation(const tag_value& e , bool q_task , op_type t) : type(char(t)), my_val(e),
                 bypass_t(NULL), enqueue_task(q_task) {}
            tag_matching_FE_operation(output_type *p, op_type t) : type(char(t)), my_output(p), bypass_t(NULL),
                 enqueue_task(true) {}
            // constructor with no parameter
            tag_matching_FE_operation(op_type t) : type(char(t)), bypass_t(NULL), enqueue_task(true) {}
        };

        typedef internal::aggregating_functor<my_class, tag_matching_FE_operation> my_handler;
        friend class internal::aggregating_functor<my_class, tag_matching_FE_operation>;
        aggregator<my_handler, tag_matching_FE_operation> my_aggregator;

        // called from aggregator, so serialized
        // construct as many output objects as possible.
        // returns a task pointer if the a task would have been enqueued but we asked that
        // it be returned.  Otherwise returns NULL.
        task * fill_output_buffer(bool should_enqueue, bool handle_task) {
            output_type l_out;
            task *rtask = NULL;
            bool do_fwd = should_enqueue && this->buffer_empty();
            while(find_value_tag(this->current_tag,N)) {  // while there are completed items
                this->tagged_delete(this->current_tag);   // remove the tag
                if(join_helper<N>::get_items(my_inputs, l_out)) {  //  <== call back
                    this->push_back(l_out);
                    if(do_fwd) {  // we enqueue if receiving an item from predecessor, not if successor asks for item
                        rtask = new ( task::allocate_additional_child_of( *(this->my_root_task) ) )
                            forward_task_bypass<my_node_type>(*my_node);
                        if(handle_task) {
                            task::enqueue(*rtask);
                            rtask = NULL;
                        }
                        do_fwd = false;
                    }
                    // retire the input values
                    join_helper<N>::reset_ports(my_inputs);  //  <== call back
                    this->current_tag = NO_TAG;    
                }
                else {
                    __TBB_ASSERT(false, "should have had something to push");
                }
            }
            return rtask;
        }

        void handle_operations(tag_matching_FE_operation* op_list) {
            tag_matching_FE_operation *current;
            while(op_list) {
                current = op_list;
                op_list = op_list->next;
                switch(current->type) {
                case res_count:  // called from BE
                    {
                        output_type l_out;
                        this->pop_front(l_out);  // don't care about returned value.
                        // buffer as many tuples as we can make
                        (void)fill_output_buffer(true, true);
                        __TBB_store_with_release(current->status, SUCCEEDED);
                    }
                    break;
                case inc_count: {  // called from input ports
                        size_t *p = 0;
                        tag_value t = current->my_val;
                        bool do_enqueue = current->enqueue_task;
                        if(!(this->tagged_find_ref(t,p))) {
                            this->tagged_insert(t, 0);
                            if(!(this->tagged_find_ref(t,p))) {
                                __TBB_ASSERT(false, "should find tag after inserting it");
                            }
                        }
                        if(++(*p) == size_t(N)) {
                            task *rtask = fill_output_buffer(true, do_enqueue);
                            __TBB_ASSERT(!rtask || !do_enqueue, "task should not be returned");
                            current->bypass_t = rtask;
                        }
                    }
                    __TBB_store_with_release(current->status, SUCCEEDED);
                    break;
                case may_succeed:  // called from BE
                    (void)fill_output_buffer(false, /*handle_task*/true);  // handle_task not used
                    __TBB_store_with_release(current->status, this->buffer_empty() ? FAILED : SUCCEEDED);
                    break;
                case try_make:  // called from BE
                    if(this->buffer_empty()) {
                        __TBB_store_with_release(current->status, FAILED);
                    }
                    else {
                        this->fetch_front(*(current->my_output));
                        __TBB_store_with_release(current->status, SUCCEEDED);
                    }
                    break;
                }
            }
        }
// ------------ End Aggregator ---------------

    public:
        template<typename FunctionTuple>
        join_node_FE(graph &g, FunctionTuple tag_funcs) : forwarding_base(g.root_task()), my_node(NULL) {
            join_helper<N>::set_join_node_pointer(my_inputs, this);
            join_helper<N>::set_tag_func(my_inputs, tag_funcs);
            my_aggregator.initialize_handler(my_handler(this));
        }

        join_node_FE(const join_node_FE& other) : forwarding_base(other.my_root_task), my_tag_buffer(),
        output_buffer_type() {
            my_node = NULL;
            join_helper<N>::set_join_node_pointer(my_inputs, this);
            join_helper<N>::copy_tag_functors(my_inputs, const_cast<input_type &>(other.my_inputs));
            my_aggregator.initialize_handler(my_handler(this));
        }

        // needed for forwarding
        void set_my_node(my_node_type *new_my_node) { my_node = new_my_node; }

        void reset_port_count() {  // called from BE
            tag_matching_FE_operation op_data(res_count);
            my_aggregator.execute(&op_data);
            return;
        }

        // if all input_ports have items, spawn forward to try and consume tuples
        // return a task if we are asked and did create one.
        task *increment_tag_count(tag_value t, bool handle_task) {  // called from input_ports
            tag_matching_FE_operation op_data(t, handle_task, inc_count);
            my_aggregator.execute(&op_data);
            return op_data.bypass_t;
        }

        /*override*/ task *decrement_port_count(bool /*handle_task*/) { __TBB_ASSERT(false, NULL); return NULL; }

        void increment_port_count() { __TBB_ASSERT(false, NULL); }  // should never be called

        input_type &input_ports() { return my_inputs; }

    protected:

        void reset() {
            // called outside of parallel contexts
            join_helper<N>::reset_inputs(my_inputs);

            my_tag_buffer::reset();  // have to reset the tag counts
            output_buffer_type::reset();  // also the queue of outputs
            my_node->current_tag = NO_TAG;
        }

        // all methods on input ports should be called under mutual exclusion from join_node_base.

        bool tuple_build_may_succeed() {  // called from back-end
            tag_matching_FE_operation op_data(may_succeed);
            my_aggregator.execute(&op_data);
            return op_data.status == SUCCEEDED;
        }

        // cannot lock while calling back to input_ports.  current_tag will only be set
        // and reset under the aggregator, so it will remain consistent.
        bool try_to_make_tuple(output_type &out) {
            tag_matching_FE_operation op_data(&out,try_make);
            my_aggregator.execute(&op_data);
            return op_data.status == SUCCEEDED;
        }

        void tuple_accepted() {
            reset_port_count();  // reset current_tag after ports reset.
        }

        void tuple_rejected() {
            // nothing to do.
        }

        input_type my_inputs;  // input ports
        my_node_type *my_node;
    }; // join_node_FE<tag_matching, InputTuple, OutputTuple>

    //! join_node_base
    template<graph_buffer_policy JP, typename InputTuple, typename OutputTuple>
    class join_node_base : public graph_node, public join_node_FE<JP, InputTuple, OutputTuple>,
                           public sender<OutputTuple> {
    protected:
        using graph_node::my_graph;
    public:
        typedef OutputTuple output_type;

        typedef receiver<output_type> successor_type;
        typedef join_node_FE<JP, InputTuple, OutputTuple> input_ports_type;
        using input_ports_type::tuple_build_may_succeed;
        using input_ports_type::try_to_make_tuple;
        using input_ports_type::tuple_accepted;
        using input_ports_type::tuple_rejected;

    private:
        // ----------- Aggregator ------------
        enum op_type { reg_succ, rem_succ, try__get, do_fwrd, do_fwrd_bypass };
        enum op_stat {WAIT=0, SUCCEEDED, FAILED};
        typedef join_node_base<JP,InputTuple,OutputTuple> my_class;

        class join_node_base_operation : public aggregated_operation<join_node_base_operation> {
        public:
            char type;
            union {
                output_type *my_arg;
                successor_type *my_succ;
            };
            task *bypass_t;
            join_node_base_operation(const output_type& e, op_type t) : type(char(t)), 
                my_arg(const_cast<output_type*>(&e)), bypass_t(NULL) {}
            join_node_base_operation(const successor_type &s, op_type t) : type(char(t)), 
                my_succ(const_cast<successor_type *>(&s)), bypass_t(NULL) {}
            join_node_base_operation(op_type t) : type(char(t)), bypass_t(NULL) {}
        };

        typedef internal::aggregating_functor<my_class, join_node_base_operation> my_handler;
        friend class internal::aggregating_functor<my_class, join_node_base_operation>;
        bool forwarder_busy;
        aggregator<my_handler, join_node_base_operation> my_aggregator;

        void handle_operations(join_node_base_operation* op_list) {
            join_node_base_operation *current;
            while(op_list) {
                current = op_list;
                op_list = op_list->next;
                switch(current->type) {
                case reg_succ:
                    my_successors.register_successor(*(current->my_succ));
                    if(tuple_build_may_succeed() && !forwarder_busy) {
                        task *rtask = new ( task::allocate_additional_child_of(*(this->my_root_task)) )
                                forward_task_bypass
                                <join_node_base<JP,InputTuple,OutputTuple> >(*this);
                        task::enqueue(*rtask);
                        forwarder_busy = true;
                    }
                    __TBB_store_with_release(current->status, SUCCEEDED);
                    break;
                case rem_succ:
                    my_successors.remove_successor(*(current->my_succ));
                    __TBB_store_with_release(current->status, SUCCEEDED);
                    break;
                case try__get:
                    if(tuple_build_may_succeed()) {
                        if(try_to_make_tuple(*(current->my_arg))) {
                            tuple_accepted();
                            __TBB_store_with_release(current->status, SUCCEEDED);
                        }
                        else __TBB_store_with_release(current->status, FAILED);
                    }
                    else __TBB_store_with_release(current->status, FAILED);
                    break;
                case do_fwrd_bypass: {
                        bool build_succeeded;
                        task *last_task = NULL;
                        output_type out;
                        if(tuple_build_may_succeed()) {
                            do {
                                build_succeeded = try_to_make_tuple(out);
                                if(build_succeeded) {
                                    task *new_task = my_successors.try_put_task(out);
                                    last_task = combine_tasks(last_task, new_task);
                                    if(new_task) {
                                        tuple_accepted();
                                    }
                                    else {
                                        tuple_rejected();
                                        build_succeeded = false;
                                    }
                                }
                            } while(build_succeeded);
                        }
                        current->bypass_t = last_task;
                        __TBB_store_with_release(current->status, SUCCEEDED);
                        forwarder_busy = false;
                    }
                    break;
                }
            }
        }
        // ---------- end aggregator -----------
    public:
        join_node_base(graph &g) : graph_node(g), input_ports_type(g), forwarder_busy(false) {
            my_successors.set_owner(this);
            input_ports_type::set_my_node(this);
            my_aggregator.initialize_handler(my_handler(this));
        }

        join_node_base(const join_node_base& other) :
            graph_node(other.my_graph), input_ports_type(other),
            sender<OutputTuple>(), forwarder_busy(false), my_successors() {
            my_successors.set_owner(this);
            input_ports_type::set_my_node(this);
            my_aggregator.initialize_handler(my_handler(this));
        }

        template<typename FunctionTuple>
        join_node_base(graph &g, FunctionTuple f) : graph_node(g), input_ports_type(g, f), forwarder_busy(false) {
            my_successors.set_owner(this);
            input_ports_type::set_my_node(this);
            my_aggregator.initialize_handler(my_handler(this));
        }

        bool register_successor(successor_type &r) {
            join_node_base_operation op_data(r, reg_succ);
            my_aggregator.execute(&op_data);
            return op_data.status == SUCCEEDED;
        }

        bool remove_successor( successor_type &r) {
            join_node_base_operation op_data(r, rem_succ);
            my_aggregator.execute(&op_data);
            return op_data.status == SUCCEEDED;
        }

        bool try_get( output_type &v) {
            join_node_base_operation op_data(v, try__get);
            my_aggregator.execute(&op_data);
            return op_data.status == SUCCEEDED;
        }

    protected:

        /*override*/void reset() {
            input_ports_type::reset();
        }

    private:
        broadcast_cache<output_type, null_rw_mutex> my_successors;

        friend class forward_task_bypass< join_node_base<JP, InputTuple, OutputTuple> >;
        task *forward_task() {
            join_node_base_operation op_data(do_fwrd_bypass);
            my_aggregator.execute(&op_data);
            return op_data.bypass_t;
        }

    };

    // join base class type generator
    template<int N, template<class> class PT, typename OutputTuple, graph_buffer_policy JP>
    struct join_base {
        typedef typename internal::join_node_base<JP, typename wrap_tuple_elements<N,PT,OutputTuple>::type, OutputTuple> type;
    };

    //! unfolded_join_node : passes input_ports_type to join_node_base.  We build the input port type
    //  using tuple_element.  The class PT is the port type (reserving_port, queueing_port, tag_matching_port)
    //  and should match the graph_buffer_policy.

    template<int N, template<class> class PT, typename OutputTuple, graph_buffer_policy JP>
    class unfolded_join_node : public join_base<N,PT,OutputTuple,JP>::type {
    public:
        typedef typename wrap_tuple_elements<N, PT, OutputTuple>::type input_ports_type;
        typedef OutputTuple output_type;
    private:
        typedef join_node_base<JP, input_ports_type, output_type > base_type;
    public:
        unfolded_join_node(graph &g) : base_type(g) {}
        unfolded_join_node(const unfolded_join_node &other) : base_type(other) {}
    };

    // tag_matching unfolded_join_node.  This must be a separate specialization because the constructors
    // differ.

    template<typename OutputTuple>
    class unfolded_join_node<2,tag_matching_port,OutputTuple,tag_matching> : public 
            join_base<2,tag_matching_port,OutputTuple,tag_matching>::type {
        typedef typename tbb::flow::tuple_element<0, OutputTuple>::type T0;
        typedef typename tbb::flow::tuple_element<1, OutputTuple>::type T1;
    public:
        typedef typename wrap_tuple_elements<2,tag_matching_port,OutputTuple>::type input_ports_type;
        typedef OutputTuple output_type;
    private:
        typedef join_node_base<tag_matching, input_ports_type, output_type > base_type;
        typedef typename internal::function_body<T0, tag_value> *f0_p;
        typedef typename internal::function_body<T1, tag_value> *f1_p;
        typedef typename tbb::flow::tuple< f0_p, f1_p > func_initializer_type;
    public:
        template<typename B0, typename B1>
        unfolded_join_node(graph &g, B0 b0, B1 b1) : base_type(g,
                func_initializer_type(
                    new internal::function_body_leaf<T0, tag_value, B0>(b0),
                    new internal::function_body_leaf<T1, tag_value, B1>(b1)
                    ) ) {}
        unfolded_join_node(const unfolded_join_node &other) : base_type(other) {}
    };

    template<typename OutputTuple>
    class unfolded_join_node<3,tag_matching_port,OutputTuple,tag_matching> : public
            join_base<3,tag_matching_port,OutputTuple,tag_matching>::type {
        typedef typename tbb::flow::tuple_element<0, OutputTuple>::type T0;
        typedef typename tbb::flow::tuple_element<1, OutputTuple>::type T1;
        typedef typename tbb::flow::tuple_element<2, OutputTuple>::type T2;
    public:
        typedef typename wrap_tuple_elements<3, tag_matching_port, OutputTuple>::type input_ports_type;
        typedef OutputTuple output_type;
    private:
        typedef join_node_base<tag_matching, input_ports_type, output_type > base_type;
        typedef typename internal::function_body<T0, tag_value> *f0_p;
        typedef typename internal::function_body<T1, tag_value> *f1_p;
        typedef typename internal::function_body<T2, tag_value> *f2_p;
        typedef typename tbb::flow::tuple< f0_p, f1_p, f2_p > func_initializer_type;
    public:
        template<typename B0, typename B1, typename B2>
        unfolded_join_node(graph &g, B0 b0, B1 b1, B2 b2) : base_type(g,
                func_initializer_type(
                    new internal::function_body_leaf<T0, tag_value, B0>(b0),
                    new internal::function_body_leaf<T1, tag_value, B1>(b1),
                    new internal::function_body_leaf<T2, tag_value, B2>(b2)
                    ) ) {}
        unfolded_join_node(const unfolded_join_node &other) : base_type(other) {}
    };

    template<typename OutputTuple>
    class unfolded_join_node<4,tag_matching_port,OutputTuple,tag_matching> : public 
            join_base<4,tag_matching_port,OutputTuple,tag_matching>::type {
        typedef typename tbb::flow::tuple_element<0, OutputTuple>::type T0;
        typedef typename tbb::flow::tuple_element<1, OutputTuple>::type T1;
        typedef typename tbb::flow::tuple_element<2, OutputTuple>::type T2;
        typedef typename tbb::flow::tuple_element<3, OutputTuple>::type T3;
    public:
        typedef typename wrap_tuple_elements<4, tag_matching_port, OutputTuple>::type input_ports_type;
        typedef OutputTuple output_type;
    private:
        typedef join_node_base<tag_matching, input_ports_type, output_type > base_type;
        typedef typename internal::function_body<T0, tag_value> *f0_p;
        typedef typename internal::function_body<T1, tag_value> *f1_p;
        typedef typename internal::function_body<T2, tag_value> *f2_p;
        typedef typename internal::function_body<T3, tag_value> *f3_p;
        typedef typename tbb::flow::tuple< f0_p, f1_p, f2_p, f3_p > func_initializer_type;
    public:
        template<typename B0, typename B1, typename B2, typename B3>
        unfolded_join_node(graph &g, B0 b0, B1 b1, B2 b2, B3 b3) : base_type(g,
                func_initializer_type(
                    new internal::function_body_leaf<T0, tag_value, B0>(b0),
                    new internal::function_body_leaf<T1, tag_value, B1>(b1),
                    new internal::function_body_leaf<T2, tag_value, B2>(b2),
                    new internal::function_body_leaf<T3, tag_value, B3>(b3)
                    ) ) {}
        unfolded_join_node(const unfolded_join_node &other) : base_type(other) {}
    };

    template<typename OutputTuple>
    class unfolded_join_node<5,tag_matching_port,OutputTuple,tag_matching> : public
            join_base<5,tag_matching_port,OutputTuple,tag_matching>::type {
        typedef typename tbb::flow::tuple_element<0, OutputTuple>::type T0;
        typedef typename tbb::flow::tuple_element<1, OutputTuple>::type T1;
        typedef typename tbb::flow::tuple_element<2, OutputTuple>::type T2;
        typedef typename tbb::flow::tuple_element<3, OutputTuple>::type T3;
        typedef typename tbb::flow::tuple_element<4, OutputTuple>::type T4;
    public:
        typedef typename wrap_tuple_elements<5, tag_matching_port, OutputTuple>::type input_ports_type;
        typedef OutputTuple output_type;
    private:
        typedef join_node_base<tag_matching, input_ports_type, output_type > base_type;
        typedef typename internal::function_body<T0, tag_value> *f0_p;
        typedef typename internal::function_body<T1, tag_value> *f1_p;
        typedef typename internal::function_body<T2, tag_value> *f2_p;
        typedef typename internal::function_body<T3, tag_value> *f3_p;
        typedef typename internal::function_body<T4, tag_value> *f4_p;
        typedef typename tbb::flow::tuple< f0_p, f1_p, f2_p, f3_p, f4_p > func_initializer_type;
    public:
        template<typename B0, typename B1, typename B2, typename B3, typename B4>
        unfolded_join_node(graph &g, B0 b0, B1 b1, B2 b2, B3 b3, B4 b4) : base_type(g,
                func_initializer_type(
                    new internal::function_body_leaf<T0, tag_value, B0>(b0),
                    new internal::function_body_leaf<T1, tag_value, B1>(b1),
                    new internal::function_body_leaf<T2, tag_value, B2>(b2),
                    new internal::function_body_leaf<T3, tag_value, B3>(b3),
                    new internal::function_body_leaf<T4, tag_value, B4>(b4)
                    ) ) {}
        unfolded_join_node(const unfolded_join_node &other) : base_type(other) {}
    };

#if __TBB_VARIADIC_MAX >= 6
    template<typename OutputTuple>
    class unfolded_join_node<6,tag_matching_port,OutputTuple,tag_matching> : public
            join_base<6,tag_matching_port,OutputTuple,tag_matching>::type {
        typedef typename tbb::flow::tuple_element<0, OutputTuple>::type T0;
        typedef typename tbb::flow::tuple_element<1, OutputTuple>::type T1;
        typedef typename tbb::flow::tuple_element<2, OutputTuple>::type T2;
        typedef typename tbb::flow::tuple_element<3, OutputTuple>::type T3;
        typedef typename tbb::flow::tuple_element<4, OutputTuple>::type T4;
        typedef typename tbb::flow::tuple_element<5, OutputTuple>::type T5;
    public:
        typedef typename wrap_tuple_elements<6, tag_matching_port, OutputTuple>::type input_ports_type;
        typedef OutputTuple output_type;
    private:
        typedef join_node_base<tag_matching, input_ports_type, output_type > base_type;
        typedef typename internal::function_body<T0, tag_value> *f0_p;
        typedef typename internal::function_body<T1, tag_value> *f1_p;
        typedef typename internal::function_body<T2, tag_value> *f2_p;
        typedef typename internal::function_body<T3, tag_value> *f3_p;
        typedef typename internal::function_body<T4, tag_value> *f4_p;
        typedef typename internal::function_body<T5, tag_value> *f5_p;
        typedef typename tbb::flow::tuple< f0_p, f1_p, f2_p, f3_p, f4_p, f5_p > func_initializer_type;
    public:
        template<typename B0, typename B1, typename B2, typename B3, typename B4, typename B5>
        unfolded_join_node(graph &g, B0 b0, B1 b1, B2 b2, B3 b3, B4 b4, B5 b5) : base_type(g,
                func_initializer_type(
                    new internal::function_body_leaf<T0, tag_value, B0>(b0),
                    new internal::function_body_leaf<T1, tag_value, B1>(b1),
                    new internal::function_body_leaf<T2, tag_value, B2>(b2),
                    new internal::function_body_leaf<T3, tag_value, B3>(b3),
                    new internal::function_body_leaf<T4, tag_value, B4>(b4),
                    new internal::function_body_leaf<T5, tag_value, B5>(b5)
                    ) ) {}
        unfolded_join_node(const unfolded_join_node &other) : base_type(other) {}
    };
#endif

#if __TBB_VARIADIC_MAX >= 7
    template<typename OutputTuple>
    class unfolded_join_node<7,tag_matching_port,OutputTuple,tag_matching> : public 
            join_base<7,tag_matching_port,OutputTuple,tag_matching>::type {
        typedef typename tbb::flow::tuple_element<0, OutputTuple>::type T0;
        typedef typename tbb::flow::tuple_element<1, OutputTuple>::type T1;
        typedef typename tbb::flow::tuple_element<2, OutputTuple>::type T2;
        typedef typename tbb::flow::tuple_element<3, OutputTuple>::type T3;
        typedef typename tbb::flow::tuple_element<4, OutputTuple>::type T4;
        typedef typename tbb::flow::tuple_element<5, OutputTuple>::type T5;
        typedef typename tbb::flow::tuple_element<6, OutputTuple>::type T6;
    public:
        typedef typename wrap_tuple_elements<7, tag_matching_port, OutputTuple>::type input_ports_type;
        typedef OutputTuple output_type;
    private:
        typedef join_node_base<tag_matching, input_ports_type, output_type > base_type;
        typedef typename internal::function_body<T0, tag_value> *f0_p;
        typedef typename internal::function_body<T1, tag_value> *f1_p;
        typedef typename internal::function_body<T2, tag_value> *f2_p;
        typedef typename internal::function_body<T3, tag_value> *f3_p;
        typedef typename internal::function_body<T4, tag_value> *f4_p;
        typedef typename internal::function_body<T5, tag_value> *f5_p;
        typedef typename internal::function_body<T6, tag_value> *f6_p;
        typedef typename tbb::flow::tuple< f0_p, f1_p, f2_p, f3_p, f4_p, f5_p, f6_p > func_initializer_type;
    public:
        template<typename B0, typename B1, typename B2, typename B3, typename B4, typename B5, typename B6>
        unfolded_join_node(graph &g, B0 b0, B1 b1, B2 b2, B3 b3, B4 b4, B5 b5, B6 b6) : base_type(g,
                func_initializer_type(
                    new internal::function_body_leaf<T0, tag_value, B0>(b0),
                    new internal::function_body_leaf<T1, tag_value, B1>(b1),
                    new internal::function_body_leaf<T2, tag_value, B2>(b2),
                    new internal::function_body_leaf<T3, tag_value, B3>(b3),
                    new internal::function_body_leaf<T4, tag_value, B4>(b4),
                    new internal::function_body_leaf<T5, tag_value, B5>(b5),
                    new internal::function_body_leaf<T6, tag_value, B6>(b6)
                    ) ) {}
        unfolded_join_node(const unfolded_join_node &other) : base_type(other) {}
    };
#endif

#if __TBB_VARIADIC_MAX >= 8
    template<typename OutputTuple>
    class unfolded_join_node<8,tag_matching_port,OutputTuple,tag_matching> : public 
            join_base<8,tag_matching_port,OutputTuple,tag_matching>::type {
        typedef typename tbb::flow::tuple_element<0, OutputTuple>::type T0;
        typedef typename tbb::flow::tuple_element<1, OutputTuple>::type T1;
        typedef typename tbb::flow::tuple_element<2, OutputTuple>::type T2;
        typedef typename tbb::flow::tuple_element<3, OutputTuple>::type T3;
        typedef typename tbb::flow::tuple_element<4, OutputTuple>::type T4;
        typedef typename tbb::flow::tuple_element<5, OutputTuple>::type T5;
        typedef typename tbb::flow::tuple_element<6, OutputTuple>::type T6;
        typedef typename tbb::flow::tuple_element<7, OutputTuple>::type T7;
    public:
        typedef typename wrap_tuple_elements<8, tag_matching_port, OutputTuple>::type input_ports_type;
        typedef OutputTuple output_type;
    private:
        typedef join_node_base<tag_matching, input_ports_type, output_type > base_type;
        typedef typename internal::function_body<T0, tag_value> *f0_p;
        typedef typename internal::function_body<T1, tag_value> *f1_p;
        typedef typename internal::function_body<T2, tag_value> *f2_p;
        typedef typename internal::function_body<T3, tag_value> *f3_p;
        typedef typename internal::function_body<T4, tag_value> *f4_p;
        typedef typename internal::function_body<T5, tag_value> *f5_p;
        typedef typename internal::function_body<T6, tag_value> *f6_p;
        typedef typename internal::function_body<T7, tag_value> *f7_p;
        typedef typename tbb::flow::tuple< f0_p, f1_p, f2_p, f3_p, f4_p, f5_p, f6_p, f7_p > func_initializer_type;
    public:
        template<typename B0, typename B1, typename B2, typename B3, typename B4, typename B5, typename B6, typename B7>
        unfolded_join_node(graph &g, B0 b0, B1 b1, B2 b2, B3 b3, B4 b4, B5 b5, B6 b6, B7 b7) : base_type(g,
                func_initializer_type(
                    new internal::function_body_leaf<T0, tag_value, B0>(b0),
                    new internal::function_body_leaf<T1, tag_value, B1>(b1),
                    new internal::function_body_leaf<T2, tag_value, B2>(b2),
                    new internal::function_body_leaf<T3, tag_value, B3>(b3),
                    new internal::function_body_leaf<T4, tag_value, B4>(b4),
                    new internal::function_body_leaf<T5, tag_value, B5>(b5),
                    new internal::function_body_leaf<T6, tag_value, B6>(b6),
                    new internal::function_body_leaf<T7, tag_value, B7>(b7)
                    ) ) {}
        unfolded_join_node(const unfolded_join_node &other) : base_type(other) {}
    };
#endif

#if __TBB_VARIADIC_MAX >= 9
    template<typename OutputTuple>
    class unfolded_join_node<9,tag_matching_port,OutputTuple,tag_matching> : public 
            join_base<9,tag_matching_port,OutputTuple,tag_matching>::type {
        typedef typename tbb::flow::tuple_element<0, OutputTuple>::type T0;
        typedef typename tbb::flow::tuple_element<1, OutputTuple>::type T1;
        typedef typename tbb::flow::tuple_element<2, OutputTuple>::type T2;
        typedef typename tbb::flow::tuple_element<3, OutputTuple>::type T3;
        typedef typename tbb::flow::tuple_element<4, OutputTuple>::type T4;
        typedef typename tbb::flow::tuple_element<5, OutputTuple>::type T5;
        typedef typename tbb::flow::tuple_element<6, OutputTuple>::type T6;
        typedef typename tbb::flow::tuple_element<7, OutputTuple>::type T7;
        typedef typename tbb::flow::tuple_element<8, OutputTuple>::type T8;
    public:
        typedef typename wrap_tuple_elements<9, tag_matching_port, OutputTuple>::type input_ports_type;
        typedef OutputTuple output_type;
    private:
        typedef join_node_base<tag_matching, input_ports_type, output_type > base_type;
        typedef typename internal::function_body<T0, tag_value> *f0_p;
        typedef typename internal::function_body<T1, tag_value> *f1_p;
        typedef typename internal::function_body<T2, tag_value> *f2_p;
        typedef typename internal::function_body<T3, tag_value> *f3_p;
        typedef typename internal::function_body<T4, tag_value> *f4_p;
        typedef typename internal::function_body<T5, tag_value> *f5_p;
        typedef typename internal::function_body<T6, tag_value> *f6_p;
        typedef typename internal::function_body<T7, tag_value> *f7_p;
        typedef typename internal::function_body<T8, tag_value> *f8_p;
        typedef typename tbb::flow::tuple< f0_p, f1_p, f2_p, f3_p, f4_p, f5_p, f6_p, f7_p, f8_p > func_initializer_type;
    public:
        template<typename B0, typename B1, typename B2, typename B3, typename B4, typename B5, typename B6, typename B7, typename B8>
        unfolded_join_node(graph &g, B0 b0, B1 b1, B2 b2, B3 b3, B4 b4, B5 b5, B6 b6, B7 b7, B8 b8) : base_type(g,
                func_initializer_type(
                    new internal::function_body_leaf<T0, tag_value, B0>(b0),
                    new internal::function_body_leaf<T1, tag_value, B1>(b1),
                    new internal::function_body_leaf<T2, tag_value, B2>(b2),
                    new internal::function_body_leaf<T3, tag_value, B3>(b3),
                    new internal::function_body_leaf<T4, tag_value, B4>(b4),
                    new internal::function_body_leaf<T5, tag_value, B5>(b5),
                    new internal::function_body_leaf<T6, tag_value, B6>(b6),
                    new internal::function_body_leaf<T7, tag_value, B7>(b7),
                    new internal::function_body_leaf<T8, tag_value, B8>(b8)
                    ) ) {}
        unfolded_join_node(const unfolded_join_node &other) : base_type(other) {}
    };
#endif

#if __TBB_VARIADIC_MAX >= 10
    template<typename OutputTuple>
    class unfolded_join_node<10,tag_matching_port,OutputTuple,tag_matching> : public 
            join_base<10,tag_matching_port,OutputTuple,tag_matching>::type {
        typedef typename tbb::flow::tuple_element<0, OutputTuple>::type T0;
        typedef typename tbb::flow::tuple_element<1, OutputTuple>::type T1;
        typedef typename tbb::flow::tuple_element<2, OutputTuple>::type T2;
        typedef typename tbb::flow::tuple_element<3, OutputTuple>::type T3;
        typedef typename tbb::flow::tuple_element<4, OutputTuple>::type T4;
        typedef typename tbb::flow::tuple_element<5, OutputTuple>::type T5;
        typedef typename tbb::flow::tuple_element<6, OutputTuple>::type T6;
        typedef typename tbb::flow::tuple_element<7, OutputTuple>::type T7;
        typedef typename tbb::flow::tuple_element<8, OutputTuple>::type T8;
        typedef typename tbb::flow::tuple_element<9, OutputTuple>::type T9;
    public:
        typedef typename wrap_tuple_elements<10, tag_matching_port, OutputTuple>::type input_ports_type;
        typedef OutputTuple output_type;
    private:
        typedef join_node_base<tag_matching, input_ports_type, output_type > base_type;
        typedef typename internal::function_body<T0, tag_value> *f0_p;
        typedef typename internal::function_body<T1, tag_value> *f1_p;
        typedef typename internal::function_body<T2, tag_value> *f2_p;
        typedef typename internal::function_body<T3, tag_value> *f3_p;
        typedef typename internal::function_body<T4, tag_value> *f4_p;
        typedef typename internal::function_body<T5, tag_value> *f5_p;
        typedef typename internal::function_body<T6, tag_value> *f6_p;
        typedef typename internal::function_body<T7, tag_value> *f7_p;
        typedef typename internal::function_body<T8, tag_value> *f8_p;
        typedef typename internal::function_body<T9, tag_value> *f9_p;
        typedef typename tbb::flow::tuple< f0_p, f1_p, f2_p, f3_p, f4_p, f5_p, f6_p, f7_p, f8_p, f9_p > func_initializer_type;
    public:
        template<typename B0, typename B1, typename B2, typename B3, typename B4, typename B5, typename B6, typename B7, typename B8, typename B9>
        unfolded_join_node(graph &g, B0 b0, B1 b1, B2 b2, B3 b3, B4 b4, B5 b5, B6 b6, B7 b7, B8 b8, B9 b9) : base_type(g,
                func_initializer_type(
                    new internal::function_body_leaf<T0, tag_value, B0>(b0),
                    new internal::function_body_leaf<T1, tag_value, B1>(b1),
                    new internal::function_body_leaf<T2, tag_value, B2>(b2),
                    new internal::function_body_leaf<T3, tag_value, B3>(b3),
                    new internal::function_body_leaf<T4, tag_value, B4>(b4),
                    new internal::function_body_leaf<T5, tag_value, B5>(b5),
                    new internal::function_body_leaf<T6, tag_value, B6>(b6),
                    new internal::function_body_leaf<T7, tag_value, B7>(b7),
                    new internal::function_body_leaf<T8, tag_value, B8>(b8),
                    new internal::function_body_leaf<T9, tag_value, B9>(b9)
                    ) ) {}
        unfolded_join_node(const unfolded_join_node &other) : base_type(other) {}
    };
#endif

    //! templated function to refer to input ports of the join node
    template<size_t N, typename JNT>
    typename tbb::flow::tuple_element<N, typename JNT::input_ports_type>::type &input_port(JNT &jn) {
        return tbb::flow::get<N>(jn.input_ports());
    }

} 
#endif // __TBB__flow_graph_join_impl_H

