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

#include <exprtk.hpp>

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

19388 {
19389 return (new node_type());
19390 }

Referenced by allocate(), allocate(), allocate(), allocate(), allocate(), and allocate().

Here is the caller graph for this function:

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

19397 {
19398 expression_node<typename node_type::value_type>*
19399 result = (new node_type(seq));
19400 result->node_depth();
19401 return result;
19402 }
exprtk::details::result
const expression_node< T >::node_type nodetype_T0oT1< T, T0, T1 >::result
Definition exprtk.hpp:17438
exprtk::details::node_depth_base::node_depth
virtual std::size_t node_depth() const
Definition exprtk.hpp:6208

References exprtk::details::nodetype_T0oT1< T, T0, T1 >::result.

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

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

References exprtk::details::nodetype_T0oT1< T, T0, T1 >::result.

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

19526 {
19527 expression_node<typename node_type::value_type>*
19528 result = (new node_type(t1, t2, t3));
19529 result->node_depth();
19530 return result;
19531 }

References exprtk::details::nodetype_T0oT1< T, T0, T1 >::result.

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

19538 {
19539 expression_node<typename node_type::value_type>*
19540 result = (new node_type(t1, t2, t3, t4));
19541 result->node_depth();
19542 return result;
19543 }

References exprtk::details::nodetype_T0oT1< T, T0, T1 >::result.

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

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

References exprtk::details::nodetype_T0oT1< T, T0, T1 >::result.

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

19564 {
19565 expression_node<typename node_type::value_type>*
19566 result = (new node_type(t1, t2, t3, t4, t5, t6));
19567 result->node_depth();
19568 return result;
19569 }

References exprtk::details::nodetype_T0oT1< T, T0, T1 >::result.

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

19579 {
19580 expression_node<typename node_type::value_type>*
19581 result = (new node_type(t1, t2, t3, t4, t5, t6, t7));
19582 result->node_depth();
19583 return result;
19584 }

References exprtk::details::nodetype_T0oT1< T, T0, T1 >::result.

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

19595 {
19596 expression_node<typename node_type::value_type>*
19597 result = (new node_type(t1, t2, t3, t4, t5, t6, t7, t8));
19598 result->node_depth();
19599 return result;
19600 }

References exprtk::details::nodetype_T0oT1< T, T0, T1 >::result.

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

19612 {
19613 expression_node<typename node_type::value_type>*
19614 result = (new node_type(t1, t2, t3, t4, t5, t6, t7, t8, t9));
19615 result->node_depth();
19616 return result;
19617 }

References exprtk::details::nodetype_T0oT1< T, T0, T1 >::result.

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

19630 {
19631 expression_node<typename node_type::value_type>*
19632 result = (new node_type(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10));
19633 result->node_depth();
19634 return result;
19635 }

References exprtk::details::nodetype_T0oT1< T, T0, T1 >::result.

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

19334 {
19335 expression_node<typename ResultNode::value_type>* result =
19336 allocate<ResultNode>(operation, branch[0]);
19337 result->node_depth();
19338 return result;
19339 }
exprtk::details::node_allocator::allocate
expression_node< typename node_type::value_type > * allocate() const
Definition exprtk.hpp:19387

References allocate(), and exprtk::details::nodetype_T0oT1< T, T0, T1 >::result.

Here is the call 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 19342 of file exprtk.hpp.

19343 {
19344 expression_node<typename ResultNode::value_type>* result =
19345 allocate<ResultNode>(operation, branch[0], branch[1]);
19346 result->node_depth();
19347 return result;
19348 }

References allocate(), and exprtk::details::nodetype_T0oT1< T, T0, T1 >::result.

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

19352 {
19353 expression_node<typename ResultNode::value_type>* result =
19354 allocate<ResultNode>(operation, branch[0], branch[1], branch[2]);
19355 result->node_depth();
19356 return result;
19357 }

References allocate(), and exprtk::details::nodetype_T0oT1< T, T0, T1 >::result.

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

19361 {
19362 expression_node<typename ResultNode::value_type>* result =
19363 allocate<ResultNode>(operation, branch[0], branch[1], branch[2], branch[3]);
19364 result->node_depth();
19365 return result;
19366 }

References allocate(), and exprtk::details::nodetype_T0oT1< T, T0, T1 >::result.

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

19370 {
19371 expression_node<typename ResultNode::value_type>* result =
19372 allocate<ResultNode>(operation, branch[0],branch[1], branch[2], branch[3], branch[4]);
19373 result->node_depth();
19374 return result;
19375 }

References allocate(), and exprtk::details::nodetype_T0oT1< T, T0, T1 >::result.

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

19379 {
19380 expression_node<typename ResultNode::value_type>* result =
19381 allocate<ResultNode>(operation, branch[0], branch[1], branch[2], branch[3], branch[4], branch[5]);
19382 result->node_depth();
19383 return result;
19384 }

References allocate(), and exprtk::details::nodetype_T0oT1< T, T0, T1 >::result.

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

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

References exprtk::details::nodetype_T0oT1< T, T0, T1 >::result.

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

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

References exprtk::details::nodetype_T0oT1< T, T0, T1 >::result.

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

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

References exprtk::details::nodetype_T0oT1< T, T0, T1 >::result.

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

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

References exprtk::details::nodetype_T0oT1< T, T0, T1 >::result.

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

19455 {
19456 expression_node<typename node_type::value_type>*
19457 result = (new node_type(t1, t2));
19458 result->node_depth();
19459 return result;
19460 }

References exprtk::details::nodetype_T0oT1< T, T0, T1 >::result.

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

19495 {
19496 expression_node<typename node_type::value_type>*
19497 result = (new node_type(t1, t2, t3));
19498 result->node_depth();
19499 return result;
19500 }

References exprtk::details::nodetype_T0oT1< T, T0, T1 >::result.

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

19505 {
19506 expression_node<typename node_type::value_type>*
19507 result = (new node_type(t1, t2, t3, t4));
19508 result->node_depth();
19509 return result;
19510 }

References exprtk::details::nodetype_T0oT1< T, T0, T1 >::result.

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

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

References exprtk::details::nodetype_T0oT1< T, T0, T1 >::result.

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

19465 {
19466 expression_node<typename node_type::value_type>*
19467 result = (new node_type(t1, t2));
19468 result->node_depth();
19469 return result;
19470 }

References exprtk::details::nodetype_T0oT1< T, T0, T1 >::result.

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

19475 {
19476 expression_node<typename node_type::value_type>*
19477 result = (new node_type(t1, t2, t3));
19478 result->node_depth();
19479 return result;
19480 }

References exprtk::details::nodetype_T0oT1< T, T0, T1 >::result.

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

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

References exprtk::details::nodetype_T0oT1< T, T0, T1 >::result.

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

19640 {
19641 expression_node<typename node_type::value_type>*
19642 result = (new node_type(t1, t2, t3));
19643 result->node_depth();
19644 return result;
19645 }

References exprtk::details::nodetype_T0oT1< T, T0, T1 >::result.

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

19652 {
19653 expression_node<typename node_type::value_type>*
19654 result = (new node_type(t1, t2, t3, t4));
19655 result->node_depth();
19656 return result;
19657 }

References exprtk::details::nodetype_T0oT1< T, T0, T1 >::result.

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

19666 {
19667 expression_node<typename node_type::value_type>*
19668 result = (new node_type(t1, t2, t3, t4, t5));
19669 result->node_depth();
19670 return result;
19671 }

References exprtk::details::nodetype_T0oT1< T, T0, T1 >::result.

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

19680 {
19681 expression_node<typename node_type::value_type>*
19682 result = (new node_type(t1, t2, t3, t4, t5, t6));
19683 result->node_depth();
19684 return result;
19685 }

References exprtk::details::nodetype_T0oT1< T, T0, T1 >::result.

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

19695 {
19696 expression_node<typename node_type::value_type>*
19697 result = (new node_type(t1, t2, t3, t4, t5, t6, t7));
19698 result->node_depth();
19699 return result;
19700 }

References exprtk::details::nodetype_T0oT1< T, T0, T1 >::result.

◆ free()

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

Definition at line 19703 of file exprtk.hpp.

19704 {
19705 exprtk_debug(("node_allocator::free() - deleting expression_node "
19706 "type: %03d addr: %p\n",
19707 static_cast<int>(e->type()),
19708 reinterpret_cast<void*>(e)));
19709 delete e;
19710 e = 0;
19711 }
exprtk_debug
#define exprtk_debug(params)
Definition exprtk.hpp:64

References exprtk_debug.

The documentation for this class was generated from the following file:
Generated by doxygen 1.17.0