C++ Mathematical Expression Toolkit (ExprTk) release
Loading...
Searching...
No Matches
Public Member Functions | List of all members
exprtk::details::node_allocator Class Reference

Public Member Functions

template<typename ResultNode , typename OpType , typename ExprNode >
expression_node< typename ResultNode::value_type > * allocate (OpType &operation, ExprNode(&branch)[1])
 
template<typename ResultNode , typename OpType , typename ExprNode >
expression_node< typename ResultNode::value_type > * allocate (OpType &operation, ExprNode(&branch)[2])
 
template<typename ResultNode , typename OpType , typename ExprNode >
expression_node< typename ResultNode::value_type > * allocate (OpType &operation, ExprNode(&branch)[3])
 
template<typename ResultNode , typename OpType , typename ExprNode >
expression_node< typename ResultNode::value_type > * allocate (OpType &operation, ExprNode(&branch)[4])
 
template<typename ResultNode , typename OpType , typename ExprNode >
expression_node< typename ResultNode::value_type > * allocate (OpType &operation, ExprNode(&branch)[5])
 
template<typename ResultNode , typename OpType , typename ExprNode >
expression_node< typename ResultNode::value_type > * allocate (OpType &operation, ExprNode(&branch)[6])
 
template<typename node_type >
expression_node< typename node_type::value_type > * allocate () const
 
template<typename node_type , typename Type , typename Allocator , template< typename, typename > class Sequence>
expression_node< typename node_type::value_type > * allocate (const Sequence< Type, Allocator > &seq) const
 
template<typename node_type , typename T1 >
expression_node< typename node_type::value_type > * allocate (T1 &t1) const
 
template<typename node_type , typename T1 >
expression_node< typename node_type::value_type > * allocate_c (const T1 &t1) const
 
template<typename node_type , typename T1 , typename T2 >
expression_node< typename node_type::value_type > * allocate (const T1 &t1, const T2 &t2) const
 
template<typename node_type , typename T1 , typename T2 >
expression_node< typename node_type::value_type > * allocate_cr (const T1 &t1, T2 &t2) const
 
template<typename node_type , typename T1 , typename T2 >
expression_node< typename node_type::value_type > * allocate_rc (T1 &t1, const T2 &t2) const
 
template<typename node_type , typename T1 , typename T2 >
expression_node< typename node_type::value_type > * allocate_rr (T1 &t1, T2 &t2) const
 
template<typename node_type , typename T1 , typename T2 >
expression_node< typename node_type::value_type > * allocate_tt (T1 t1, T2 t2) const
 
template<typename node_type , typename T1 , typename T2 , typename T3 >
expression_node< typename node_type::value_type > * allocate_ttt (T1 t1, T2 t2, T3 t3) const
 
template<typename node_type , typename T1 , typename T2 , typename T3 , typename T4 >
expression_node< typename node_type::value_type > * allocate_tttt (T1 t1, T2 t2, T3 t3, T4 t4) const
 
template<typename node_type , typename T1 , typename T2 , typename T3 >
expression_node< typename node_type::value_type > * allocate_rrr (T1 &t1, T2 &t2, T3 &t3) const
 
template<typename node_type , typename T1 , typename T2 , typename T3 , typename T4 >
expression_node< typename node_type::value_type > * allocate_rrrr (T1 &t1, T2 &t2, T3 &t3, T4 &t4) const
 
template<typename node_type , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 >
expression_node< typename node_type::value_type > * allocate_rrrrr (T1 &t1, T2 &t2, T3 &t3, T4 &t4, T5 &t5) const
 
template<typename node_type , typename T1 , typename T2 , typename T3 >
expression_node< typename node_type::value_type > * allocate (const T1 &t1, const T2 &t2, const T3 &t3) const
 
template<typename node_type , typename T1 , typename T2 , typename T3 , typename T4 >
expression_node< typename node_type::value_type > * allocate (const T1 &t1, const T2 &t2, const T3 &t3, const T4 &t4) const
 
template<typename node_type , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 >
expression_node< typename node_type::value_type > * allocate (const T1 &t1, const T2 &t2, const T3 &t3, const T4 &t4, const T5 &t5) const
 
template<typename node_type , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 >
expression_node< typename node_type::value_type > * allocate (const T1 &t1, const T2 &t2, const T3 &t3, const T4 &t4, const T5 &t5, const T6 &t6) const
 
template<typename node_type , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 >
expression_node< typename node_type::value_type > * allocate (const T1 &t1, const T2 &t2, const T3 &t3, const T4 &t4, const T5 &t5, const T6 &t6, const T7 &t7) const
 
template<typename node_type , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 >
expression_node< typename node_type::value_type > * allocate (const T1 &t1, const T2 &t2, const T3 &t3, const T4 &t4, const T5 &t5, const T6 &t6, const T7 &t7, const T8 &t8) const
 
template<typename node_type , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 >
expression_node< typename node_type::value_type > * allocate (const T1 &t1, const T2 &t2, const T3 &t3, const T4 &t4, const T5 &t5, const T6 &t6, const T7 &t7, const T8 &t8, const T9 &t9) const
 
template<typename node_type , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 >
expression_node< typename node_type::value_type > * allocate (const T1 &t1, const T2 &t2, const T3 &t3, const T4 &t4, const T5 &t5, const T6 &t6, const T7 &t7, const T8 &t8, const T9 &t9, const T10 &t10) const
 
template<typename node_type , typename T1 , typename T2 , typename T3 >
expression_node< typename node_type::value_type > * allocate_type (T1 t1, T2 t2, T3 t3) const
 
template<typename node_type , typename T1 , typename T2 , typename T3 , typename T4 >
expression_node< typename node_type::value_type > * allocate_type (T1 t1, T2 t2, T3 t3, T4 t4) const
 
template<typename node_type , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 >
expression_node< typename node_type::value_type > * allocate_type (T1 t1, T2 t2, T3 t3, T4 t4, T5 t5) const
 
template<typename node_type , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 >
expression_node< typename node_type::value_type > * allocate_type (T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6) const
 
template<typename node_type , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 >
expression_node< typename node_type::value_type > * allocate_type (T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7) const
 
template<typename T >
void free (expression_node< T > *&e) const
 

Detailed Description

Definition at line 19248 of file exprtk.hpp.

Member Function Documentation

◆ allocate() [1/18]

template<typename node_type >
expression_node< typename node_type::value_type > * exprtk::details::node_allocator::allocate ( ) const
inline

Definition at line 19307 of file exprtk.hpp.

19308 {
19309 return (new node_type());
19310 }

◆ allocate() [2/18]

template<typename node_type , typename Type , typename Allocator , template< typename, typename > class Sequence>
expression_node< typename node_type::value_type > * exprtk::details::node_allocator::allocate ( const Sequence< Type, Allocator > &  seq) const
inline

Definition at line 19316 of file exprtk.hpp.

19317 {
19318 expression_node<typename node_type::value_type>*
19319 result = (new node_type(seq));
19320 result->node_depth();
19321 return result;
19322 }
exprtk::details::match_impl
bool match_impl(const Iterator pattern_begin, const Iterator pattern_end, const Iterator data_begin, const Iterator data_end, const typename std::iterator_traits< Iterator >::value_type &zero_or_more, const typename std::iterator_traits< Iterator >::value_type &exactly_one)
Definition exprtk.hpp:605

References exprtk::details::match_impl(), and exprtk::details::node_depth_base< Node >::node_depth().

Here is the call graph for this function:

◆ allocate() [3/18]

template<typename node_type , typename T1 , typename T2 >
expression_node< typename node_type::value_type > * exprtk::details::node_allocator::allocate ( const T1 &  t1,
const T2 &  t2 
) const
inline

Definition at line 19344 of file exprtk.hpp.

19345 {
19346 expression_node<typename node_type::value_type>*
19347 result = (new node_type(t1, t2));
19348 result->node_depth();
19349 return result;
19350 }

References exprtk::details::node_depth_base< Node >::node_depth().

Here is the call graph for this function:

◆ allocate() [4/18]

template<typename node_type , typename T1 , typename T2 , typename T3 >
expression_node< typename node_type::value_type > * exprtk::details::node_allocator::allocate ( const T1 &  t1,
const T2 &  t2,
const T3 &  t3 
) const
inline

Definition at line 19444 of file exprtk.hpp.

19446 {
19447 expression_node<typename node_type::value_type>*
19448 result = (new node_type(t1, t2, t3));
19449 result->node_depth();
19450 return result;
19451 }

References exprtk::details::node_depth_base< Node >::node_depth().

Here is the call graph for this function:

◆ allocate() [5/18]

template<typename node_type , typename T1 , typename T2 , typename T3 , typename T4 >
expression_node< typename node_type::value_type > * exprtk::details::node_allocator::allocate ( const T1 &  t1,
const T2 &  t2,
const T3 &  t3,
const T4 &  t4 
) const
inline

Definition at line 19456 of file exprtk.hpp.

19458 {
19459 expression_node<typename node_type::value_type>*
19460 result = (new node_type(t1, t2, t3, t4));
19461 result->node_depth();
19462 return result;
19463 }

References exprtk::details::match_impl(), and exprtk::details::node_depth_base< Node >::node_depth().

Here is the call graph for this function:

◆ allocate() [6/18]

template<typename node_type , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 >
expression_node< typename node_type::value_type > * exprtk::details::node_allocator::allocate ( const T1 &  t1,
const T2 &  t2,
const T3 &  t3,
const T4 &  t4,
const T5 &  t5 
) const
inline

Definition at line 19468 of file exprtk.hpp.

19471 {
19472 expression_node<typename node_type::value_type>*
19473 result = (new node_type(t1, t2, t3, t4, t5));
19474 result->node_depth();
19475 return result;
19476 }

References exprtk::details::match_impl(), and exprtk::details::node_depth_base< Node >::node_depth().

Here is the call graph for this function:

◆ allocate() [7/18]

template<typename node_type , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 >
expression_node< typename node_type::value_type > * exprtk::details::node_allocator::allocate ( const T1 &  t1,
const T2 &  t2,
const T3 &  t3,
const T4 &  t4,
const T5 &  t5,
const T6 &  t6 
) const
inline

Definition at line 19481 of file exprtk.hpp.

19484 {
19485 expression_node<typename node_type::value_type>*
19486 result = (new node_type(t1, t2, t3, t4, t5, t6));
19487 result->node_depth();
19488 return result;
19489 }

References exprtk::details::match_impl(), and exprtk::details::node_depth_base< Node >::node_depth().

Here is the call graph for this function:

◆ allocate() [8/18]

template<typename node_type , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 >
expression_node< typename node_type::value_type > * exprtk::details::node_allocator::allocate ( const T1 &  t1,
const T2 &  t2,
const T3 &  t3,
const T4 &  t4,
const T5 &  t5,
const T6 &  t6,
const T7 &  t7 
) const
inline

Definition at line 19495 of file exprtk.hpp.

19499 {
19500 expression_node<typename node_type::value_type>*
19501 result = (new node_type(t1, t2, t3, t4, t5, t6, t7));
19502 result->node_depth();
19503 return result;
19504 }

References exprtk::details::match_impl(), and exprtk::details::node_depth_base< Node >::node_depth().

Here is the call graph for this function:

◆ allocate() [9/18]

template<typename node_type , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 >
expression_node< typename node_type::value_type > * exprtk::details::node_allocator::allocate ( const T1 &  t1,
const T2 &  t2,
const T3 &  t3,
const T4 &  t4,
const T5 &  t5,
const T6 &  t6,
const T7 &  t7,
const T8 &  t8 
) const
inline

Definition at line 19511 of file exprtk.hpp.

19515 {
19516 expression_node<typename node_type::value_type>*
19517 result = (new node_type(t1, t2, t3, t4, t5, t6, t7, t8));
19518 result->node_depth();
19519 return result;
19520 }

References exprtk::details::match_impl(), and exprtk::details::node_depth_base< Node >::node_depth().

Here is the call graph for this function:

◆ allocate() [10/18]

template<typename node_type , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 >
expression_node< typename node_type::value_type > * exprtk::details::node_allocator::allocate ( const T1 &  t1,
const T2 &  t2,
const T3 &  t3,
const T4 &  t4,
const T5 &  t5,
const T6 &  t6,
const T7 &  t7,
const T8 &  t8,
const T9 &  t9 
) const
inline

Definition at line 19527 of file exprtk.hpp.

19532 {
19533 expression_node<typename node_type::value_type>*
19534 result = (new node_type(t1, t2, t3, t4, t5, t6, t7, t8, t9));
19535 result->node_depth();
19536 return result;
19537 }

References exprtk::details::match_impl(), and exprtk::details::node_depth_base< Node >::node_depth().

Here is the call graph for this function:

◆ allocate() [11/18]

template<typename node_type , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 >
expression_node< typename node_type::value_type > * exprtk::details::node_allocator::allocate ( const T1 &  t1,
const T2 &  t2,
const T3 &  t3,
const T4 &  t4,
const T5 &  t5,
const T6 &  t6,
const T7 &  t7,
const T8 &  t8,
const T9 &  t9,
const T10 &  t10 
) const
inline

Definition at line 19545 of file exprtk.hpp.

19550 {
19551 expression_node<typename node_type::value_type>*
19552 result = (new node_type(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10));
19553 result->node_depth();
19554 return result;
19555 }

References exprtk::details::match_impl(), and exprtk::details::node_depth_base< Node >::node_depth().

Here is the call graph for this function:

◆ allocate() [12/18]

template<typename ResultNode , typename OpType , typename ExprNode >
expression_node< typename ResultNode::value_type > * exprtk::details::node_allocator::allocate ( OpType &  operation,
ExprNode(&)  branch[1] 
)
inline

Definition at line 19253 of file exprtk.hpp.

19254 {
19255 expression_node<typename ResultNode::value_type>* result =
19256 allocate<ResultNode>(operation, branch[0]);
19257 result->node_depth();
19258 return result;
19259 }

References exprtk::details::match_impl(), and exprtk::details::node_depth_base< Node >::node_depth().

Referenced by exprtk::parser< T >::expression_generator< Type >::conditional(), exprtk::parser< T >::expression_generator< Type >::conditional_string(), exprtk::parser< T >::expression_generator< Type >::conditional_vector(), exprtk::parser< T >::expression_generator< Type >::const_optimise_mswitch(), exprtk::parser< T >::expression_generator< Type >::const_optimise_sf3(), exprtk::parser< T >::expression_generator< Type >::const_optimise_sf4(), exprtk::parser< T >::expression_generator< Type >::const_optimise_varargfunc(), exprtk::parser< T >::expression_generator< Type >::for_loop(), exprtk::parser< T >::expression_generator< Type >::function(), exprtk::parser< T >::expression_generator< Type >::generic_function_call(), exprtk::parser< T >::expression_generator< Type >::multi_switch_statement(), exprtk::parser< T >::expression_generator< Type >::operator()(), exprtk::parser< T >::expression_generator< Type >::operator()(), exprtk::parser< T >::parse_break_statement(), exprtk::parser< T >::parse_continue_statement(), exprtk::parser< T >::parse_define_constvar_statement(), exprtk::parser< T >::parse_define_var_statement(), exprtk::parser< T >::parse_define_vector_statement(), exprtk::parser< T >::parse_for_loop(), exprtk::parser< T >::parse_multi_sequence(), exprtk::parser< T >::parse_null_statement(), exprtk::parser< T >::parse_repeat_until_loop(), exprtk::parser< T >::parse_string(), exprtk::parser< T >::parse_string_range_statement(), exprtk::parser< T >::parse_swap_statement(), exprtk::parser< T >::parse_uninitialised_var_statement(), exprtk::parser< T >::parse_vector(), exprtk::parser< T >::expression_generator< Type >::repeat_until_loop(), exprtk::parser< T >::expression_generator< Type >::string_function_call(), exprtk::parser< T >::expression_generator< Type >::switch_statement(), exprtk::parser< T >::expression_generator< Type >::synthesize_csocs_expression(), exprtk::parser< T >::expression_generator< Type >::synthesize_expression(), exprtk::parser< T >::expression_generator< Type >::synthesize_expression(), exprtk::parser< T >::expression_generator< Type >::synthesize_null_expression(), exprtk::parser< T >::expression_generator< Type >::synthesize_swap_expression(), exprtk::parser< T >::expression_generator< Type >::vararg_function_call(), exprtk::parser< T >::expression_generator< Type >::vector_element(), and exprtk::parser< T >::expression_generator< Type >::while_loop().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ allocate() [13/18]

template<typename ResultNode , typename OpType , typename ExprNode >
expression_node< typename ResultNode::value_type > * exprtk::details::node_allocator::allocate ( OpType &  operation,
ExprNode(&)  branch[2] 
)
inline

Definition at line 19262 of file exprtk.hpp.

19263 {
19264 expression_node<typename ResultNode::value_type>* result =
19265 allocate<ResultNode>(operation, branch[0], branch[1]);
19266 result->node_depth();
19267 return result;
19268 }

References exprtk::details::match_impl(), and exprtk::details::node_depth_base< Node >::node_depth().

Here is the call graph for this function:

◆ allocate() [14/18]

template<typename ResultNode , typename OpType , typename ExprNode >
expression_node< typename ResultNode::value_type > * exprtk::details::node_allocator::allocate ( OpType &  operation,
ExprNode(&)  branch[3] 
)
inline

Definition at line 19271 of file exprtk.hpp.

19272 {
19273 expression_node<typename ResultNode::value_type>* result =
19274 allocate<ResultNode>(operation, branch[0], branch[1], branch[2]);
19275 result->node_depth();
19276 return result;
19277 }

References exprtk::details::match_impl(), and exprtk::details::node_depth_base< Node >::node_depth().

Here is the call graph for this function:

◆ allocate() [15/18]

template<typename ResultNode , typename OpType , typename ExprNode >
expression_node< typename ResultNode::value_type > * exprtk::details::node_allocator::allocate ( OpType &  operation,
ExprNode(&)  branch[4] 
)
inline

Definition at line 19280 of file exprtk.hpp.

19281 {
19282 expression_node<typename ResultNode::value_type>* result =
19283 allocate<ResultNode>(operation, branch[0], branch[1], branch[2], branch[3]);
19284 result->node_depth();
19285 return result;
19286 }

References exprtk::details::match_impl(), and exprtk::details::node_depth_base< Node >::node_depth().

Here is the call graph for this function:

◆ allocate() [16/18]

template<typename ResultNode , typename OpType , typename ExprNode >
expression_node< typename ResultNode::value_type > * exprtk::details::node_allocator::allocate ( OpType &  operation,
ExprNode(&)  branch[5] 
)
inline

Definition at line 19289 of file exprtk.hpp.

19290 {
19291 expression_node<typename ResultNode::value_type>* result =
19292 allocate<ResultNode>(operation, branch[0],branch[1], branch[2], branch[3], branch[4]);
19293 result->node_depth();
19294 return result;
19295 }

References exprtk::details::match_impl(), and exprtk::details::node_depth_base< Node >::node_depth().

Here is the call graph for this function:

◆ allocate() [17/18]

template<typename ResultNode , typename OpType , typename ExprNode >
expression_node< typename ResultNode::value_type > * exprtk::details::node_allocator::allocate ( OpType &  operation,
ExprNode(&)  branch[6] 
)
inline

Definition at line 19298 of file exprtk.hpp.

19299 {
19300 expression_node<typename ResultNode::value_type>* result =
19301 allocate<ResultNode>(operation, branch[0], branch[1], branch[2], branch[3], branch[4], branch[5]);
19302 result->node_depth();
19303 return result;
19304 }

References exprtk::details::match_impl(), and exprtk::details::node_depth_base< Node >::node_depth().

Here is the call graph for this function:

◆ allocate() [18/18]

template<typename node_type , typename T1 >
expression_node< typename node_type::value_type > * exprtk::details::node_allocator::allocate ( T1 &  t1) const
inline

Definition at line 19325 of file exprtk.hpp.

19326 {
19327 expression_node<typename node_type::value_type>*
19328 result = (new node_type(t1));
19329 result->node_depth();
19330 return result;
19331 }

References exprtk::details::node_depth_base< Node >::node_depth().

Here is the call graph for this function:

◆ allocate_c()

template<typename node_type , typename T1 >
expression_node< typename node_type::value_type > * exprtk::details::node_allocator::allocate_c ( const T1 &  t1) const
inline

Definition at line 19334 of file exprtk.hpp.

19335 {
19336 expression_node<typename node_type::value_type>*
19337 result = (new node_type(t1));
19338 result->node_depth();
19339 return result;
19340 }

References exprtk::details::node_depth_base< Node >::node_depth().

Referenced by exprtk::parser< T >::expression_generator< Type >::cardinal_pow_optimisation(), exprtk::parser< T >::expression_generator< Type >::cardinal_pow_optimisation(), exprtk::parser< T >::parse_switch_statement(), exprtk::parser< T >::expression_generator< Type >::synthesize_csocs_expression(), exprtk::parser< T >::expression_generator< Type >::synthesize_null_expression(), exprtk::parser< T >::expression_generator< Type >::synthesize_shortcircuit_expression(), and exprtk::parser< T >::expression_generator< Type >::synthesize_string_expression().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ allocate_cr()

template<typename node_type , typename T1 , typename T2 >
expression_node< typename node_type::value_type > * exprtk::details::node_allocator::allocate_cr ( const T1 &  t1,
T2 &  t2 
) const
inline

Definition at line 19354 of file exprtk.hpp.

19355 {
19356 expression_node<typename node_type::value_type>*
19357 result = (new node_type(t1, t2));
19358 result->node_depth();
19359 return result;
19360 }

References exprtk::details::node_depth_base< Node >::node_depth().

Here is the call graph for this function:

◆ allocate_rc()

template<typename node_type , typename T1 , typename T2 >
expression_node< typename node_type::value_type > * exprtk::details::node_allocator::allocate_rc ( T1 &  t1,
const T2 &  t2 
) const
inline

Definition at line 19364 of file exprtk.hpp.

19365 {
19366 expression_node<typename node_type::value_type>*
19367 result = (new node_type(t1, t2));
19368 result->node_depth();
19369 return result;
19370 }

References exprtk::details::node_depth_base< Node >::node_depth().

Here is the call graph for this function:

◆ allocate_rr()

template<typename node_type , typename T1 , typename T2 >
expression_node< typename node_type::value_type > * exprtk::details::node_allocator::allocate_rr ( T1 &  t1,
T2 &  t2 
) const
inline

Definition at line 19374 of file exprtk.hpp.

19375 {
19376 expression_node<typename node_type::value_type>*
19377 result = (new node_type(t1, t2));
19378 result->node_depth();
19379 return result;
19380 }

References exprtk::details::node_depth_base< Node >::node_depth().

Referenced by exprtk::parser< T >::expression_generator< Type >::operator()().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ allocate_rrr()

template<typename node_type , typename T1 , typename T2 , typename T3 >
expression_node< typename node_type::value_type > * exprtk::details::node_allocator::allocate_rrr ( T1 &  t1,
T2 &  t2,
T3 &  t3 
) const
inline

Definition at line 19414 of file exprtk.hpp.

19415 {
19416 expression_node<typename node_type::value_type>*
19417 result = (new node_type(t1, t2, t3));
19418 result->node_depth();
19419 return result;
19420 }

References exprtk::details::node_depth_base< Node >::node_depth().

Here is the call graph for this function:

◆ allocate_rrrr()

template<typename node_type , typename T1 , typename T2 , typename T3 , typename T4 >
expression_node< typename node_type::value_type > * exprtk::details::node_allocator::allocate_rrrr ( T1 &  t1,
T2 &  t2,
T3 &  t3,
T4 &  t4 
) const
inline

Definition at line 19424 of file exprtk.hpp.

19425 {
19426 expression_node<typename node_type::value_type>*
19427 result = (new node_type(t1, t2, t3, t4));
19428 result->node_depth();
19429 return result;
19430 }

References exprtk::details::match_impl(), and exprtk::details::node_depth_base< Node >::node_depth().

Referenced by exprtk::parser< T >::expression_generator< Type >::assert_call().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ allocate_rrrrr()

template<typename node_type , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 >
expression_node< typename node_type::value_type > * exprtk::details::node_allocator::allocate_rrrrr ( T1 &  t1,
T2 &  t2,
T3 &  t3,
T4 &  t4,
T5 &  t5 
) const
inline

Definition at line 19434 of file exprtk.hpp.

19435 {
19436 expression_node<typename node_type::value_type>*
19437 result = (new node_type(t1, t2, t3, t4, t5));
19438 result->node_depth();
19439 return result;
19440 }

References exprtk::details::match_impl(), and exprtk::details::node_depth_base< Node >::node_depth().

Here is the call graph for this function:

◆ allocate_tt()

template<typename node_type , typename T1 , typename T2 >
expression_node< typename node_type::value_type > * exprtk::details::node_allocator::allocate_tt ( T1  t1,
T2  t2 
) const
inline

Definition at line 19384 of file exprtk.hpp.

19385 {
19386 expression_node<typename node_type::value_type>*
19387 result = (new node_type(t1, t2));
19388 result->node_depth();
19389 return result;
19390 }

References exprtk::details::node_depth_base< Node >::node_depth().

Referenced by exprtk::parser< T >::expression_generator< Type >::operator()(), and exprtk::parser< T >::expression_generator< Type >::operator()().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ allocate_ttt()

template<typename node_type , typename T1 , typename T2 , typename T3 >
expression_node< typename node_type::value_type > * exprtk::details::node_allocator::allocate_ttt ( T1  t1,
T2  t2,
T3  t3 
) const
inline

Definition at line 19394 of file exprtk.hpp.

19395 {
19396 expression_node<typename node_type::value_type>*
19397 result = (new node_type(t1, t2, t3));
19398 result->node_depth();
19399 return result;
19400 }

References exprtk::details::node_depth_base< Node >::node_depth().

Here is the call graph for this function:

◆ allocate_tttt()

template<typename node_type , typename T1 , typename T2 , typename T3 , typename T4 >
expression_node< typename node_type::value_type > * exprtk::details::node_allocator::allocate_tttt ( T1  t1,
T2  t2,
T3  t3,
T4  t4 
) const
inline

Definition at line 19404 of file exprtk.hpp.

19405 {
19406 expression_node<typename node_type::value_type>*
19407 result = (new node_type(t1, t2, t3, t4));
19408 result->node_depth();
19409 return result;
19410 }

References exprtk::details::match_impl(), and exprtk::details::node_depth_base< Node >::node_depth().

Here is the call graph for this function:

◆ allocate_type() [1/5]

template<typename node_type , typename T1 , typename T2 , typename T3 >
expression_node< typename node_type::value_type > * exprtk::details::node_allocator::allocate_type ( T1  t1,
T2  t2,
T3  t3 
) const
inline

Definition at line 19559 of file exprtk.hpp.

19560 {
19561 expression_node<typename node_type::value_type>*
19562 result = (new node_type(t1, t2, t3));
19563 result->node_depth();
19564 return result;
19565 }

References exprtk::details::node_depth_base< Node >::node_depth().

Referenced by exprtk::parser< T >::expression_generator< Type >::synthesize_string_expression().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ allocate_type() [2/5]

template<typename node_type , typename T1 , typename T2 , typename T3 , typename T4 >
expression_node< typename node_type::value_type > * exprtk::details::node_allocator::allocate_type ( T1  t1,
T2  t2,
T3  t3,
T4  t4 
) const
inline

Definition at line 19570 of file exprtk.hpp.

19572 {
19573 expression_node<typename node_type::value_type>*
19574 result = (new node_type(t1, t2, t3, t4));
19575 result->node_depth();
19576 return result;
19577 }

References exprtk::details::match_impl(), and exprtk::details::node_depth_base< Node >::node_depth().

Here is the call graph for this function:

◆ allocate_type() [3/5]

template<typename node_type , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 >
expression_node< typename node_type::value_type > * exprtk::details::node_allocator::allocate_type ( T1  t1,
T2  t2,
T3  t3,
T4  t4,
T5  t5 
) const
inline

Definition at line 19583 of file exprtk.hpp.

19586 {
19587 expression_node<typename node_type::value_type>*
19588 result = (new node_type(t1, t2, t3, t4, t5));
19589 result->node_depth();
19590 return result;
19591 }

References exprtk::details::match_impl(), and exprtk::details::node_depth_base< Node >::node_depth().

Here is the call graph for this function:

◆ allocate_type() [4/5]

template<typename node_type , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 >
expression_node< typename node_type::value_type > * exprtk::details::node_allocator::allocate_type ( T1  t1,
T2  t2,
T3  t3,
T4  t4,
T5  t5,
T6  t6 
) const
inline

Definition at line 19597 of file exprtk.hpp.

19600 {
19601 expression_node<typename node_type::value_type>*
19602 result = (new node_type(t1, t2, t3, t4, t5, t6));
19603 result->node_depth();
19604 return result;
19605 }

References exprtk::details::match_impl(), and exprtk::details::node_depth_base< Node >::node_depth().

Here is the call graph for this function:

◆ allocate_type() [5/5]

template<typename node_type , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 >
expression_node< typename node_type::value_type > * exprtk::details::node_allocator::allocate_type ( T1  t1,
T2  t2,
T3  t3,
T4  t4,
T5  t5,
T6  t6,
T7  t7 
) const
inline

Definition at line 19611 of file exprtk.hpp.

19615 {
19616 expression_node<typename node_type::value_type>*
19617 result = (new node_type(t1, t2, t3, t4, t5, t6, t7));
19618 result->node_depth();
19619 return result;
19620 }

References exprtk::details::match_impl(), and exprtk::details::node_depth_base< Node >::node_depth().

Here is the call graph for this function:

◆ free()

template<typename T >
void exprtk::details::node_allocator::free ( expression_node< T > *&  e) const
inline

Definition at line 19623 of file exprtk.hpp.

19624 {
19625 exprtk_debug(("node_allocator::free() - deleting expression_node "
19626 "type: %03d addr: %p\n",
19627 static_cast<int>(e->type()),
19628 reinterpret_cast<void*>(e)));
19629 delete e;
19630 e = 0;
19631 }
exprtk_debug
#define exprtk_debug(params)
Definition exprtk.hpp:64

References exprtk_debug.

Referenced by exprtk::parser< T >::expression_generator< Type >::cardinal_pow_optimisation().

Here is the caller graph for this function:
The documentation for this class was generated from the following file:
Generated by doxygen 1.9.8