internal::join_node_FE< key_matching< K, KHash >, InputTuple, OutputTuple > Class Template Reference

#include <_flow_graph_join_impl.h>

Inheritance diagram for internal::join_node_FE< key_matching< K, KHash >, InputTuple, OutputTuple >:

Collaboration diagram for internal::join_node_FE< key_matching< K, KHash >, InputTuple, OutputTuple >:

Classes
class	key_matching_FE_operation

Public Types
typedef OutputTuple	output_type
typedef InputTuple	input_type
typedef K	key_type
typedef tbb::internal::strip< key_type >::type	unref_key_type
typedef KHash	key_hash_compare
typedef count_element< unref_key_type >	count_element_type
typedef key_to_count_functor< unref_key_type >	key_to_count_func
typedef internal::type_to_key_function_body< count_element_type, unref_key_type & >	TtoK_function_body_type
typedef internal::type_to_key_function_body_leaf< count_element_type, unref_key_type &, key_to_count_func >	TtoK_function_body_leaf_type
typedef hash_buffer< unref_key_type &, count_element_type, TtoK_function_body_type, key_hash_compare >	key_to_count_buffer_type
typedef item_buffer< output_type >	output_buffer_type
typedef join_node_base< key_matching< key_type, key_hash_compare >, InputTuple, OutputTuple >	base_node_type
typedef matching_forwarding_base< key_type >	forwarding_base_type
Public Types inherited from internal::matching_forwarding_base< K >
typedef tbb::internal::strip< K >::type	current_key_type
Public Types inherited from hash_buffer< tbb::internal::strip< K >::type &, count_element< tbb::internal::strip< K >::type >, internal::type_to_key_function_body< count_element< tbb::internal::strip< K >::type >, tbb::internal::strip< K >::type & >, KHash >
typedef count_element< tbb::internal::strip< K >::type >	value_type
typedef buffer_element_type< value_type >::type	element_type
typedef value_type *	pointer_type
typedef element_type *	list_array_type
typedef list_array_type *	pointer_array_type
typedef tbb::cache_aligned_allocator< typename aligned_pair< count_element< tbb::internal::strip< K >::type >, void * >::type > ::template rebind< list_array_type >::other	pointer_array_allocator_type
typedef tbb::cache_aligned_allocator< typename aligned_pair< count_element< tbb::internal::strip< K >::type >, void * >::type > ::template rebind< element_type >::other	elements_array_allocator
typedef tbb::internal::strip< tbb::internal::strip< K >::type & >::type	Knoref
Public Types inherited from internal::item_buffer< OutputTuple >
enum	buffer_item_state
typedef OutputTuple	item_type

Public Member Functions
template<typename FunctionTuple >
	join_node_FE (graph &g, FunctionTuple &TtoK_funcs)
	join_node_FE (const join_node_FE &other)
void	set_my_node (base_node_type *new_my_node)
void	reset_port_count ()
task *	increment_key_count (unref_key_type const &t, bool handle_task) __TBB_override
task *	decrement_port_count (bool) __TBB_override
void	increment_port_count () __TBB_override
input_type &	input_ports ()
Public Member Functions inherited from internal::matching_forwarding_base< K >
	matching_forwarding_base (graph &g)
Public Member Functions inherited from internal::forwarding_base
	forwarding_base (graph &g)
virtual	~forwarding_base ()
Public Member Functions inherited from tbb::internal::no_assign
void	operator= (const no_assign &)=delete
	no_assign (const no_assign &)=default
	no_assign ()=default
Public Member Functions inherited from hash_buffer< tbb::internal::strip< K >::type &, count_element< tbb::internal::strip< K >::type >, internal::type_to_key_function_body< count_element< tbb::internal::strip< K >::type >, tbb::internal::strip< K >::type & >, KHash >
	hash_buffer ()
	~hash_buffer ()
void	reset ()
void	set_key_func (internal::type_to_key_function_body< count_element< tbb::internal::strip< K >::type >, tbb::internal::strip< K >::type & > *vtk)
internal::type_to_key_function_body< count_element< tbb::internal::strip< K >::type >, tbb::internal::strip< K >::type & > *	get_key_func ()
bool	insert_with_key (const value_type &v)
bool	find_ref_with_key (const Knoref &k, pointer_type &v)
bool	find_with_key (const Knoref &k, value_type &v)
void	delete_with_key (const Knoref &k)
Public Member Functions inherited from internal::item_buffer< OutputTuple >
	item_buffer ()
	Constructor. More...
	~item_buffer ()
void	reset ()

Static Public Attributes
static const int	N = tbb::flow::tuple_size<OutputTuple>::value
Static Public Attributes inherited from hash_buffer< tbb::internal::strip< K >::type &, count_element< tbb::internal::strip< K >::type >, internal::type_to_key_function_body< count_element< tbb::internal::strip< K >::type >, tbb::internal::strip< K >::type & >, KHash >
static const size_t	INITIAL_SIZE

Protected Member Functions
void	reset (reset_flags f)
bool	tuple_build_may_succeed ()
bool	try_to_make_tuple (output_type &out)
void	tuple_accepted ()
void	tuple_rejected ()
Protected Member Functions inherited from internal::item_buffer< OutputTuple >
bool	buffer_empty () const
buffer_item_type &	item (size_type i)
const buffer_item_type &	item (size_type i) const
bool	my_item_valid (size_type i) const
bool	my_item_reserved (size_type i) const
const item_type &	get_my_item (size_t i) const
void	set_my_item (size_t i, const item_type &o)
void	fetch_item (size_t i, item_type &o)
void	move_item (size_t to, size_t from)
bool	place_item (size_t here, const item_type &me)
void	swap_items (size_t i, size_t j)
void	destroy_item (size_type i)
const item_type &	front () const
const item_type &	back () const
void	reserve_item (size_type i)
void	release_item (size_type i)
void	destroy_front ()
void	destroy_back ()
size_type	size (size_t new_tail=0)
size_type	capacity ()
bool	buffer_full ()
void	grow_my_array (size_t minimum_size)
	Grows the internal array. More...
bool	push_back (item_type &v)
bool	pop_back (item_type &v)
bool	pop_front (item_type &v)
void	clean_up_buffer (bool reset_pointers)

Protected Attributes
input_type	my_inputs
base_node_type *	my_node
Protected Attributes inherited from internal::item_buffer< OutputTuple >
buffer_item_type *	my_array
size_type	my_array_size
size_type	my_head
size_type	my_tail

Private Types
enum	op_type { res_count, inc_count, may_succeed, try_make }
typedef join_node_FE< key_matching< key_type, key_hash_compare >, InputTuple, OutputTuple >	class_type
typedef internal::aggregating_functor< class_type, key_matching_FE_operation >	handler_type

Private Member Functions
task *	fill_output_buffer (unref_key_type &t, bool should_enqueue, bool handle_task)
void	handle_operations (key_matching_FE_operation *op_list)

Private Attributes
aggregator< handler_type, key_matching_FE_operation >	my_aggregator

Friends
class	internal::aggregating_functor< class_type, key_matching_FE_operation >

Additional Inherited Members
Public Attributes inherited from internal::matching_forwarding_base< K >
current_key_type	current_key
Public Attributes inherited from internal::forwarding_base
graph &	graph_ref
Protected Types inherited from internal::item_buffer< OutputTuple >
typedef size_t	size_type
typedef aligned_pair< item_type, buffer_item_state >::type	buffer_item_type
typedef tbb::internal::allocator_rebind< cache_aligned_allocator< OutputTuple >, buffer_item_type >::type	allocator_type
Static Protected Attributes inherited from internal::item_buffer< OutputTuple >
static const size_type	initial_buffer_size

Detailed Description

template<typename InputTuple, typename OutputTuple, typename K, typename KHash>
class internal::join_node_FE< key_matching< K, KHash >, InputTuple, OutputTuple >

Definition at line 1034 of file _flow_graph_join_impl.h.

Member Typedef Documentation

base_node_type

template<typename InputTuple , typename OutputTuple , typename K , typename KHash >

typedef join_node_base<key_matching<key_type,key_hash_compare>, InputTuple, OutputTuple> internal::join_node_FE< key_matching< K, KHash >, InputTuple, OutputTuple >::base_node_type

Definition at line 1063 of file _flow_graph_join_impl.h.

class_type

template<typename InputTuple , typename OutputTuple , typename K , typename KHash >

typedef join_node_FE<key_matching<key_type,key_hash_compare>, InputTuple, OutputTuple> internal::join_node_FE< key_matching< K, KHash >, InputTuple, OutputTuple >::class_type

private

Definition at line 1071 of file _flow_graph_join_impl.h.

count_element_type

template<typename InputTuple , typename OutputTuple , typename K , typename KHash >

typedef count_element<unref_key_type> internal::join_node_FE< key_matching< K, KHash >, InputTuple, OutputTuple >::count_element_type

Definition at line 1053 of file _flow_graph_join_impl.h.

forwarding_base_type

template<typename InputTuple , typename OutputTuple , typename K , typename KHash >

typedef matching_forwarding_base<key_type> internal::join_node_FE< key_matching< K, KHash >, InputTuple, OutputTuple >::forwarding_base_type

Definition at line 1064 of file _flow_graph_join_impl.h.

handler_type

template<typename InputTuple , typename OutputTuple , typename K , typename KHash >

typedef internal::aggregating_functor<class_type, key_matching_FE_operation> internal::join_node_FE< key_matching< K, KHash >, InputTuple, OutputTuple >::handler_type

private

Definition at line 1089 of file _flow_graph_join_impl.h.

input_type

template<typename InputTuple , typename OutputTuple , typename K , typename KHash >

typedef InputTuple internal::join_node_FE< key_matching< K, KHash >, InputTuple, OutputTuple >::input_type

Definition at line 1048 of file _flow_graph_join_impl.h.

key_hash_compare

template<typename InputTuple , typename OutputTuple , typename K , typename KHash >

typedef KHash internal::join_node_FE< key_matching< K, KHash >, InputTuple, OutputTuple >::key_hash_compare

Definition at line 1051 of file _flow_graph_join_impl.h.

key_to_count_buffer_type

template<typename InputTuple , typename OutputTuple , typename K , typename KHash >

typedef hash_buffer< unref_key_type&, count_element_type, TtoK_function_body_type, key_hash_compare > internal::join_node_FE< key_matching< K, KHash >, InputTuple, OutputTuple >::key_to_count_buffer_type

Definition at line 1061 of file _flow_graph_join_impl.h.

key_to_count_func

template<typename InputTuple , typename OutputTuple , typename K , typename KHash >

typedef key_to_count_functor<unref_key_type> internal::join_node_FE< key_matching< K, KHash >, InputTuple, OutputTuple >::key_to_count_func

Definition at line 1055 of file _flow_graph_join_impl.h.

key_type

template<typename InputTuple , typename OutputTuple , typename K , typename KHash >

typedef K internal::join_node_FE< key_matching< K, KHash >, InputTuple, OutputTuple >::key_type

Definition at line 1049 of file _flow_graph_join_impl.h.

output_buffer_type

template<typename InputTuple , typename OutputTuple , typename K , typename KHash >

typedef item_buffer<output_type> internal::join_node_FE< key_matching< K, KHash >, InputTuple, OutputTuple >::output_buffer_type

Definition at line 1062 of file _flow_graph_join_impl.h.

output_type

template<typename InputTuple , typename OutputTuple , typename K , typename KHash >

typedef OutputTuple internal::join_node_FE< key_matching< K, KHash >, InputTuple, OutputTuple >::output_type

Definition at line 1047 of file _flow_graph_join_impl.h.

TtoK_function_body_leaf_type

template<typename InputTuple , typename OutputTuple , typename K , typename KHash >

typedef internal::type_to_key_function_body_leaf<count_element_type, unref_key_type&, key_to_count_func> internal::join_node_FE< key_matching< K, KHash >, InputTuple, OutputTuple >::TtoK_function_body_leaf_type

Definition at line 1057 of file _flow_graph_join_impl.h.

TtoK_function_body_type

template<typename InputTuple , typename OutputTuple , typename K , typename KHash >

typedef internal::type_to_key_function_body< count_element_type, unref_key_type&> internal::join_node_FE< key_matching< K, KHash >, InputTuple, OutputTuple >::TtoK_function_body_type

Definition at line 1056 of file _flow_graph_join_impl.h.

unref_key_type

template<typename InputTuple , typename OutputTuple , typename K , typename KHash >

typedef tbb::internal::strip<key_type>::type internal::join_node_FE< key_matching< K, KHash >, InputTuple, OutputTuple >::unref_key_type

Definition at line 1050 of file _flow_graph_join_impl.h.

Member Enumeration Documentation

op_type

template<typename InputTuple , typename OutputTuple , typename K , typename KHash >

enum internal::join_node_FE< key_matching< K, KHash >, InputTuple, OutputTuple >::op_type

private

Enumerator
res_count
inc_count
may_succeed
try_make

Definition at line 1070 of file _flow_graph_join_impl.h.

{ res_count, inc_count, may_succeed, try_make };

Constructor & Destructor Documentation

join_node_FE() [1/2]

template<typename InputTuple , typename OutputTuple , typename K , typename KHash >

template<typename FunctionTuple >

internal::join_node_FE< key_matching< K, KHash >, InputTuple, OutputTuple >::join_node_FE ( graph &  g, FunctionTuple &  TtoK_funcs  )

inline

Definition at line 1174 of file _flow_graph_join_impl.h.

                                                          : forwarding_base_type(g), my_node(NULL) {
            join_helper<N>::set_join_node_pointer(my_inputs, this);
            join_helper<N>::set_key_functors(my_inputs, TtoK_funcs);
            my_aggregator.initialize_handler(handler_type(this));
                    TtoK_function_body_type *cfb = new TtoK_function_body_leaf_type(key_to_count_func());
            this->set_key_func(cfb);
        }

References tbb::interface6::internal::aggregator< handler_type, operation_type >::initialize_handler(), internal::join_helper< N >::set_join_node_pointer(), and internal::join_helper< N >::set_key_functors().

Here is the call graph for this function:

join_node_FE() [2/2]

template<typename InputTuple , typename OutputTuple , typename K , typename KHash >

internal::join_node_FE< key_matching< K, KHash >, InputTuple, OutputTuple >::join_node_FE ( const join_node_FE< key_matching< K, KHash >, InputTuple, OutputTuple > &  other )

inline

Definition at line 1182 of file _flow_graph_join_impl.h.

                                                : forwarding_base_type((other.forwarding_base_type::graph_ref)), key_to_count_buffer_type(),
        output_buffer_type() {
            my_node = NULL;
            join_helper<N>::set_join_node_pointer(my_inputs, this);
            join_helper<N>::copy_key_functors(my_inputs, const_cast<input_type &>(other.my_inputs));
            my_aggregator.initialize_handler(handler_type(this));
            TtoK_function_body_type *cfb = new TtoK_function_body_leaf_type(key_to_count_func());
            this->set_key_func(cfb);
        }

References internal::join_helper< N >::copy_key_functors(), tbb::interface6::internal::aggregator< handler_type, operation_type >::initialize_handler(), and internal::join_helper< N >::set_join_node_pointer().

Here is the call graph for this function:

Member Function Documentation

decrement_port_count()

template<typename InputTuple , typename OutputTuple , typename K , typename KHash >

task* internal::join_node_FE< key_matching< K, KHash >, InputTuple, OutputTuple >::decrement_port_count ( bool  )

inlinevirtual

Implements internal::forwarding_base.

Definition at line 1209 of file _flow_graph_join_impl.h.

{ __TBB_ASSERT(false, NULL); return NULL; }

References __TBB_ASSERT.

fill_output_buffer()

template<typename InputTuple , typename OutputTuple , typename K , typename KHash >

task* internal::join_node_FE< key_matching< K, KHash >, InputTuple, OutputTuple >::fill_output_buffer ( unref_key_type &  t, bool  should_enqueue, bool  handle_task  )

inlineprivate

Definition at line 1096 of file _flow_graph_join_impl.h.

                                                                                            {
            output_type l_out;
            task *rtask = NULL;
            bool do_fwd = should_enqueue && this->buffer_empty() && internal::is_graph_active(this->graph_ref);
            this->current_key = t;
            this->delete_with_key(this->current_key);   // remove the key
            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->graph_ref.root_task()) ) )
                        forward_task_bypass<base_node_type>(*my_node);
                    if(handle_task) {
                        internal::spawn_in_graph_arena(this->graph_ref, *rtask);
                        rtask = NULL;
                    }
                    do_fwd = false;
                }
                // retire the input values
                join_helper<N>::reset_ports(my_inputs);  //  <== call back
            }
            else {
                __TBB_ASSERT(false, "should have had something to push");
            }
            return rtask;
        }

References __TBB_ASSERT, tbb::flow::interface11::internal::is_graph_active(), internal::join_helper< N >::reset_ports(), tbb::flow::interface11::internal::spawn_in_graph_arena(), and task.

Here is the call graph for this function:

handle_operations()

template<typename InputTuple , typename OutputTuple , typename K , typename KHash >

void internal::join_node_FE< key_matching< K, KHash >, InputTuple, OutputTuple >::handle_operations ( key_matching_FE_operation *  op_list )

inlineprivate

Definition at line 1122 of file _flow_graph_join_impl.h.

                                                                   {
            key_matching_FE_operation *current;
            while(op_list) {
                current = op_list;
                op_list = op_list->next;
                switch(current->type) {
                case res_count:  // called from BE
                    {
                        this->destroy_front();
                        __TBB_store_with_release(current->status, SUCCEEDED);
                    }
                    break;
                case inc_count: {  // called from input ports
                        count_element_type *p = 0;
                        unref_key_type &t = current->my_val;
                        bool do_enqueue = current->enqueue_task;
                        if(!(this->find_ref_with_key(t,p))) {
                            count_element_type ev;
                            ev.my_key = t;
                            ev.my_value = 0;
                            this->insert_with_key(ev);
                            if(!(this->find_ref_with_key(t,p))) {
                                __TBB_ASSERT(false, "should find key after inserting it");
                            }
                        }
                        if(++(p->my_value) == size_t(N)) {
                            task *rtask = fill_output_buffer(t, 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
                    __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 {
                        *(current->my_output) = this->front();
                        __TBB_store_with_release(current->status, SUCCEEDED);
                    }
                    break;
                }
            }
        }

References __TBB_ASSERT, tbb::internal::__TBB_store_with_release(), internal::FAILED, internal::count_element< K >::my_key, internal::count_element< K >::my_value, p, internal::SUCCEEDED, and task.

Here is the call graph for this function:

increment_key_count()

template<typename InputTuple , typename OutputTuple , typename K , typename KHash >

task* internal::join_node_FE< key_matching< K, KHash >, InputTuple, OutputTuple >::increment_key_count ( unref_key_type const &  t, bool  handle_task  )

inlinevirtual

Implements internal::matching_forwarding_base< K >.

Definition at line 1203 of file _flow_graph_join_impl.h.

                                                                                             {  // called from input_ports
            key_matching_FE_operation op_data(t, handle_task, inc_count);
            my_aggregator.execute(&op_data);
            return op_data.bypass_t;
        }

References tbb::interface6::internal::aggregator< handler_type, operation_type >::execute().

Here is the call graph for this function:

increment_port_count()

template<typename InputTuple , typename OutputTuple , typename K , typename KHash >

void internal::join_node_FE< key_matching< K, KHash >, InputTuple, OutputTuple >::increment_port_count ( )

inlinevirtual

Implements internal::forwarding_base.

Definition at line 1211 of file _flow_graph_join_impl.h.

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

References __TBB_ASSERT.

input_ports()

template<typename InputTuple , typename OutputTuple , typename K , typename KHash >

input_type& internal::join_node_FE< key_matching< K, KHash >, InputTuple, OutputTuple >::input_ports ( )

inline

Definition at line 1213 of file _flow_graph_join_impl.h.

{ return my_inputs; }

reset()

template<typename InputTuple , typename OutputTuple , typename K , typename KHash >

void internal::join_node_FE< key_matching< K, KHash >, InputTuple, OutputTuple >::reset ( reset_flags  f )

inlineprotected

Definition at line 1217 of file _flow_graph_join_impl.h.

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

            key_to_count_buffer_type::reset();
            output_buffer_type::reset();
        }

References internal::join_helper< N >::reset_inputs().

Here is the call graph for this function:

reset_port_count()

template<typename InputTuple , typename OutputTuple , typename K , typename KHash >

void internal::join_node_FE< key_matching< K, KHash >, InputTuple, OutputTuple >::reset_port_count ( )

inline

Definition at line 1195 of file _flow_graph_join_impl.h.

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

References tbb::interface6::internal::aggregator< handler_type, operation_type >::execute().

Here is the call graph for this function:

set_my_node()

template<typename InputTuple , typename OutputTuple , typename K , typename KHash >

void internal::join_node_FE< key_matching< K, KHash >, InputTuple, OutputTuple >::set_my_node ( base_node_type *  new_my_node )

inline

Definition at line 1193 of file _flow_graph_join_impl.h.

{ my_node = new_my_node; }

try_to_make_tuple()

template<typename InputTuple , typename OutputTuple , typename K , typename KHash >

bool internal::join_node_FE< key_matching< K, KHash >, InputTuple, OutputTuple >::try_to_make_tuple ( output_type &  out )

inlineprotected

Definition at line 1244 of file _flow_graph_join_impl.h.

                                                 {
            key_matching_FE_operation op_data(&out,try_make);
            my_aggregator.execute(&op_data);
            return op_data.status == SUCCEEDED;
        }

References tbb::interface6::internal::aggregator< handler_type, operation_type >::execute(), and internal::SUCCEEDED.

Here is the call graph for this function:

tuple_accepted()

template<typename InputTuple , typename OutputTuple , typename K , typename KHash >

void internal::join_node_FE< key_matching< K, KHash >, InputTuple, OutputTuple >::tuple_accepted ( )

inlineprotected

Definition at line 1250 of file _flow_graph_join_impl.h.

                              {
            reset_port_count();  // reset current_key after ports reset.
        }

tuple_build_may_succeed()

template<typename InputTuple , typename OutputTuple , typename K , typename KHash >

bool internal::join_node_FE< key_matching< K, KHash >, InputTuple, OutputTuple >::tuple_build_may_succeed ( )

inlineprotected

Definition at line 1236 of file _flow_graph_join_impl.h.

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

References tbb::interface6::internal::aggregator< handler_type, operation_type >::execute(), and internal::SUCCEEDED.

Here is the call graph for this function:

tuple_rejected()

template<typename InputTuple , typename OutputTuple , typename K , typename KHash >

void internal::join_node_FE< key_matching< K, KHash >, InputTuple, OutputTuple >::tuple_rejected ( )

inlineprotected

Definition at line 1254 of file _flow_graph_join_impl.h.

                              {
            // nothing to do.
        }

Friends And Related Function Documentation

internal::aggregating_functor< class_type, key_matching_FE_operation >

template<typename InputTuple , typename OutputTuple , typename K , typename KHash >

friend class internal::aggregating_functor< class_type, key_matching_FE_operation >

friend

Definition at line 1090 of file _flow_graph_join_impl.h.

Member Data Documentation

my_aggregator

template<typename InputTuple , typename OutputTuple , typename K , typename KHash >

aggregator<handler_type, key_matching_FE_operation> internal::join_node_FE< key_matching< K, KHash >, InputTuple, OutputTuple >::my_aggregator

private

Definition at line 1091 of file _flow_graph_join_impl.h.

my_inputs

template<typename InputTuple , typename OutputTuple , typename K , typename KHash >

input_type internal::join_node_FE< key_matching< K, KHash >, InputTuple, OutputTuple >::my_inputs

protected

Definition at line 1258 of file _flow_graph_join_impl.h.

my_node

template<typename InputTuple , typename OutputTuple , typename K , typename KHash >

base_node_type* internal::join_node_FE< key_matching< K, KHash >, InputTuple, OutputTuple >::my_node

protected

Definition at line 1259 of file _flow_graph_join_impl.h.

N

template<typename InputTuple , typename OutputTuple , typename K , typename KHash >

const int internal::join_node_FE< key_matching< K, KHash >, InputTuple, OutputTuple >::N = tbb::flow::tuple_size<OutputTuple>::value

static

Definition at line 1046 of file _flow_graph_join_impl.h.

---

The documentation for this class was generated from the following file:

• _flow_graph_join_impl.h