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 19009 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 19068 of file exprtk.hpp.

19069 {
19070 return (new node_type());
19071 }

◆ 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 19077 of file exprtk.hpp.

19078 {
19079 expression_node<typename node_type::value_type>*
19080 result = (new node_type(seq));
19081 result->node_depth();
19082 return result;
19083 }
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:598

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 19105 of file exprtk.hpp.

19106 {
19107 expression_node<typename node_type::value_type>*
19108 result = (new node_type(t1, t2));
19109 result->node_depth();
19110 return result;
19111 }

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 19205 of file exprtk.hpp.

19207 {
19208 expression_node<typename node_type::value_type>*
19209 result = (new node_type(t1, t2, t3));
19210 result->node_depth();
19211 return result;
19212 }

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 19217 of file exprtk.hpp.

19219 {
19220 expression_node<typename node_type::value_type>*
19221 result = (new node_type(t1, t2, t3, t4));
19222 result->node_depth();
19223 return result;
19224 }

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 19229 of file exprtk.hpp.

19232 {
19233 expression_node<typename node_type::value_type>*
19234 result = (new node_type(t1, t2, t3, t4, t5));
19235 result->node_depth();
19236 return result;
19237 }

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 19242 of file exprtk.hpp.

19245 {
19246 expression_node<typename node_type::value_type>*
19247 result = (new node_type(t1, t2, t3, t4, t5, t6));
19248 result->node_depth();
19249 return result;
19250 }

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 19256 of file exprtk.hpp.

19260 {
19261 expression_node<typename node_type::value_type>*
19262 result = (new node_type(t1, t2, t3, t4, t5, t6, t7));
19263 result->node_depth();
19264 return result;
19265 }

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 19272 of file exprtk.hpp.

19276 {
19277 expression_node<typename node_type::value_type>*
19278 result = (new node_type(t1, t2, t3, t4, t5, t6, t7, t8));
19279 result->node_depth();
19280 return result;
19281 }

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 19288 of file exprtk.hpp.

19293 {
19294 expression_node<typename node_type::value_type>*
19295 result = (new node_type(t1, t2, t3, t4, t5, t6, t7, t8, t9));
19296 result->node_depth();
19297 return result;
19298 }

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 19306 of file exprtk.hpp.

19311 {
19312 expression_node<typename node_type::value_type>*
19313 result = (new node_type(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10));
19314 result->node_depth();
19315 return result;
19316 }

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 19014 of file exprtk.hpp.

19015 {
19016 expression_node<typename ResultNode::value_type>* result =
19017 allocate<ResultNode>(operation, branch[0]);
19018 result->node_depth();
19019 return result;
19020 }

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 19023 of file exprtk.hpp.

19024 {
19025 expression_node<typename ResultNode::value_type>* result =
19026 allocate<ResultNode>(operation, branch[0], branch[1]);
19027 result->node_depth();
19028 return result;
19029 }

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 19032 of file exprtk.hpp.

19033 {
19034 expression_node<typename ResultNode::value_type>* result =
19035 allocate<ResultNode>(operation, branch[0], branch[1], branch[2]);
19036 result->node_depth();
19037 return result;
19038 }

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 19041 of file exprtk.hpp.

19042 {
19043 expression_node<typename ResultNode::value_type>* result =
19044 allocate<ResultNode>(operation, branch[0], branch[1], branch[2], branch[3]);
19045 result->node_depth();
19046 return result;
19047 }

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 19050 of file exprtk.hpp.

19051 {
19052 expression_node<typename ResultNode::value_type>* result =
19053 allocate<ResultNode>(operation, branch[0],branch[1], branch[2], branch[3], branch[4]);
19054 result->node_depth();
19055 return result;
19056 }

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 19059 of file exprtk.hpp.

19060 {
19061 expression_node<typename ResultNode::value_type>* result =
19062 allocate<ResultNode>(operation, branch[0], branch[1], branch[2], branch[3], branch[4], branch[5]);
19063 result->node_depth();
19064 return result;
19065 }

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 19086 of file exprtk.hpp.

19087 {
19088 expression_node<typename node_type::value_type>*
19089 result = (new node_type(t1));
19090 result->node_depth();
19091 return result;
19092 }

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 19095 of file exprtk.hpp.

19096 {
19097 expression_node<typename node_type::value_type>*
19098 result = (new node_type(t1));
19099 result->node_depth();
19100 return result;
19101 }

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 19115 of file exprtk.hpp.

19116 {
19117 expression_node<typename node_type::value_type>*
19118 result = (new node_type(t1, t2));
19119 result->node_depth();
19120 return result;
19121 }

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 19125 of file exprtk.hpp.

19126 {
19127 expression_node<typename node_type::value_type>*
19128 result = (new node_type(t1, t2));
19129 result->node_depth();
19130 return result;
19131 }

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 19135 of file exprtk.hpp.

19136 {
19137 expression_node<typename node_type::value_type>*
19138 result = (new node_type(t1, t2));
19139 result->node_depth();
19140 return result;
19141 }

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 19175 of file exprtk.hpp.

19176 {
19177 expression_node<typename node_type::value_type>*
19178 result = (new node_type(t1, t2, t3));
19179 result->node_depth();
19180 return result;
19181 }

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 19185 of file exprtk.hpp.

19186 {
19187 expression_node<typename node_type::value_type>*
19188 result = (new node_type(t1, t2, t3, t4));
19189 result->node_depth();
19190 return result;
19191 }

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 19195 of file exprtk.hpp.

19196 {
19197 expression_node<typename node_type::value_type>*
19198 result = (new node_type(t1, t2, t3, t4, t5));
19199 result->node_depth();
19200 return result;
19201 }

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 19145 of file exprtk.hpp.

19146 {
19147 expression_node<typename node_type::value_type>*
19148 result = (new node_type(t1, t2));
19149 result->node_depth();
19150 return result;
19151 }

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 19155 of file exprtk.hpp.

19156 {
19157 expression_node<typename node_type::value_type>*
19158 result = (new node_type(t1, t2, t3));
19159 result->node_depth();
19160 return result;
19161 }

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 19165 of file exprtk.hpp.

19166 {
19167 expression_node<typename node_type::value_type>*
19168 result = (new node_type(t1, t2, t3, t4));
19169 result->node_depth();
19170 return result;
19171 }

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 19320 of file exprtk.hpp.

19321 {
19322 expression_node<typename node_type::value_type>*
19323 result = (new node_type(t1, t2, t3));
19324 result->node_depth();
19325 return result;
19326 }

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 19331 of file exprtk.hpp.

19333 {
19334 expression_node<typename node_type::value_type>*
19335 result = (new node_type(t1, t2, t3, t4));
19336 result->node_depth();
19337 return result;
19338 }

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 19344 of file exprtk.hpp.

19347 {
19348 expression_node<typename node_type::value_type>*
19349 result = (new node_type(t1, t2, t3, t4, t5));
19350 result->node_depth();
19351 return result;
19352 }

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 19358 of file exprtk.hpp.

19361 {
19362 expression_node<typename node_type::value_type>*
19363 result = (new node_type(t1, t2, t3, t4, t5, t6));
19364 result->node_depth();
19365 return result;
19366 }

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 19372 of file exprtk.hpp.

19376 {
19377 expression_node<typename node_type::value_type>*
19378 result = (new node_type(t1, t2, t3, t4, t5, t6, t7));
19379 result->node_depth();
19380 return result;
19381 }

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 19384 of file exprtk.hpp.

19385 {
19386 exprtk_debug(("node_allocator::free() - deleting expression_node "
19387 "type: %03d addr: %p\n",
19388 static_cast<int>(e->type()),
19389 reinterpret_cast<void*>(e)));
19390 delete e;
19391 e = 0;
19392 }
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