C++ Mathematical Expression Toolkit (ExprTk) release
Loading...
Searching...
No Matches
Classes | Public Types | Public Member Functions | Protected Types | Static Protected Attributes | Private Types | Private Member Functions | Private Attributes | Friends | List of all members
exprtk::symbol_table< T > Class Template Reference

#include <exprtk.hpp>

Collaboration diagram for exprtk::symbol_table< T >:
[legend]

Classes

struct  control_block
 
struct  freefunc00
 
struct  freefunc01
 
struct  freefunc02
 
struct  freefunc03
 
struct  freefunc04
 
struct  freefunc05
 
struct  freefunc06
 
struct  freefunc07
 
struct  freefunc08
 
struct  freefunc09
 
struct  freefunc10
 
struct  freefunc11
 
struct  freefunc12
 
struct  freefunc13
 
struct  freefunc14
 
struct  freefunc15
 
struct  type_store
 

Public Types

enum  symtab_mutability_type { e_unknown = 0 , e_mutable = 1 , e_immutable = 2 }
 
typedef T(* ff00_functor) ()
 
typedef T(* ff01_functor) (T)
 
typedef T(* ff02_functor) (T, T)
 
typedef T(* ff03_functor) (T, T, T)
 
typedef T(* ff04_functor) (T, T, T, T)
 
typedef T(* ff05_functor) (T, T, T, T, T)
 
typedef T(* ff06_functor) (T, T, T, T, T, T)
 
typedef T(* ff07_functor) (T, T, T, T, T, T, T)
 
typedef T(* ff08_functor) (T, T, T, T, T, T, T, T)
 
typedef T(* ff09_functor) (T, T, T, T, T, T, T, T, T)
 
typedef T(* ff10_functor) (T, T, T, T, T, T, T, T, T, T)
 
typedef T(* ff11_functor) (T, T, T, T, T, T, T, T, T, T, T)
 
typedef T(* ff12_functor) (T, T, T, T, T, T, T, T, T, T, T, T)
 
typedef T(* ff13_functor) (T, T, T, T, T, T, T, T, T, T, T, T, T)
 
typedef T(* ff14_functor) (T, T, T, T, T, T, T, T, T, T, T, T, T, T)
 
typedef T(* ff15_functor) (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)
 
typedef vector_holder_tvector_holder_ptr
 

Public Member Functions

 symbol_table (const symtab_mutability_type mutability=e_mutable)
 
 ~symbol_table ()
 
 symbol_table (const symbol_table< T > &st)
 
symbol_table< T > & operator= (const symbol_table< T > &st)
 
bool operator== (const symbol_table< T > &st) const
 
symtab_mutability_type mutability () const
 
void clear_variables (const bool delete_node=true)
 
void clear_functions ()
 
void clear_strings ()
 
void clear_vectors ()
 
void clear_local_constants ()
 
void clear ()
 
std::size_t variable_count () const
 
std::size_t stringvar_count () const
 
std::size_t function_count () const
 
std::size_t vector_count () const
 
variable_ptr get_variable (const std::string &variable_name) const
 
variable_ptr get_variable (const T &var_ref) const
 
stringvar_ptr get_stringvar (const std::string &string_name) const
 
stringvar_base< T > get_stringvar_base (const std::string &string_name) const
 
function_ptr get_function (const std::string &function_name) const
 
vararg_function_ptr get_vararg_function (const std::string &vararg_function_name) const
 
generic_function_ptr get_generic_function (const std::string &function_name) const
 
generic_function_ptr get_string_function (const std::string &function_name) const
 
generic_function_ptr get_overload_function (const std::string &function_name) const
 
vector_holder_ptr get_vector (const std::string &vector_name) const
 
T & variable_ref (const std::string &symbol_name)
 
std::string & stringvar_ref (const std::string &symbol_name)
 
bool is_constant_node (const std::string &symbol_name) const
 
bool is_constant_string (const std::string &symbol_name) const
 
bool create_variable (const std::string &variable_name, const T &value=T(0))
 
bool create_stringvar (const std::string &stringvar_name, const std::string &value=std::string(""))
 
bool add_variable (const std::string &variable_name, T &t, const bool is_constant=false)
 
bool add_constant (const std::string &constant_name, const T &value)
 
bool add_stringvar (const std::string &stringvar_name, std::string &s, const bool is_constant=false)
 
bool add_function (const std::string &function_name, function_t &function)
 
bool add_function (const std::string &vararg_function_name, vararg_function_t &vararg_function)
 
bool add_function (const std::string &function_name, generic_function_t &function)
 
bool add_function (const std::string &function_name, ff00_functor function)
 
bool add_function (const std::string &function_name, ff01_functor function)
 
bool add_function (const std::string &function_name, ff02_functor function)
 
bool add_function (const std::string &function_name, ff03_functor function)
 
bool add_function (const std::string &function_name, ff04_functor function)
 
bool add_function (const std::string &function_name, ff05_functor function)
 
bool add_function (const std::string &function_name, ff06_functor function)
 
bool add_function (const std::string &function_name, ff07_functor function)
 
bool add_function (const std::string &function_name, ff08_functor function)
 
bool add_function (const std::string &function_name, ff09_functor function)
 
bool add_function (const std::string &function_name, ff10_functor function)
 
bool add_function (const std::string &function_name, ff11_functor function)
 
bool add_function (const std::string &function_name, ff12_functor function)
 
bool add_function (const std::string &function_name, ff13_functor function)
 
bool add_function (const std::string &function_name, ff14_functor function)
 
bool add_function (const std::string &function_name, ff15_functor function)
 
bool add_reserved_function (const std::string &function_name, function_t &function)
 
bool add_reserved_function (const std::string &vararg_function_name, vararg_function_t &vararg_function)
 
bool add_reserved_function (const std::string &function_name, generic_function_t &function)
 
template<std::size_t N>
bool add_vector (const std::string &vector_name, T(&v)[N])
 
bool add_vector (const std::string &vector_name, T *v, const std::size_t &v_size)
 
template<typename Allocator >
bool add_vector (const std::string &vector_name, std::vector< T, Allocator > &v)
 
bool add_vector (const std::string &vector_name, exprtk::vector_view< T > &v)
 
bool remove_variable (const std::string &variable_name, const bool delete_node=true)
 
bool remove_stringvar (const std::string &string_name)
 
bool remove_function (const std::string &function_name)
 
bool remove_vararg_function (const std::string &vararg_function_name)
 
bool remove_vector (const std::string &vector_name)
 
bool add_constants ()
 
bool add_pi ()
 
bool add_epsilon ()
 
bool add_infinity ()
 
template<typename Package >
bool add_package (Package &package)
 
template<typename Allocator , template< typename, typename > class Sequence>
std::size_t get_variable_list (Sequence< std::pair< std::string, T >, Allocator > &vlist) const
 
template<typename Allocator , template< typename, typename > class Sequence>
std::size_t get_variable_list (Sequence< std::string, Allocator > &vlist) const
 
template<typename Allocator , template< typename, typename > class Sequence>
std::size_t get_stringvar_list (Sequence< std::pair< std::string, std::string >, Allocator > &svlist) const
 
template<typename Allocator , template< typename, typename > class Sequence>
std::size_t get_stringvar_list (Sequence< std::string, Allocator > &svlist) const
 
template<typename Allocator , template< typename, typename > class Sequence>
std::size_t get_vector_list (Sequence< std::string, Allocator > &vec_list) const
 
template<typename Allocator , template< typename, typename > class Sequence>
std::size_t get_function_list (Sequence< std::string, Allocator > &function_list) const
 
bool symbol_exists (const std::string &symbol_name, const bool check_reserved_symb=true) const
 
bool is_variable (const std::string &variable_name) const
 
bool is_stringvar (const std::string &stringvar_name) const
 
bool is_conststr_stringvar (const std::string &symbol_name) const
 
bool is_function (const std::string &function_name) const
 
bool is_vararg_function (const std::string &vararg_function_name) const
 
bool is_vector (const std::string &vector_name) const
 
std::string get_variable_name (const expression_ptr &ptr) const
 
std::string get_vector_name (const vector_holder_ptr &ptr) const
 
std::string get_stringvar_name (const expression_ptr &ptr) const
 
std::string get_conststr_stringvar_name (const expression_ptr &ptr) const
 
bool valid () const
 
void load_from (const symbol_table< T > &st)
 
void load_variables_from (const symbol_table< T > &st)
 
void load_vectors_from (const symbol_table< T > &st)
 

Protected Types

typedef details::expression_node< T > * expression_ptr
 
typedef details::variable_node< T > variable_t
 
typedef details::vector_holder< T > vector_holder_t
 
typedef variable_tvariable_ptr
 
typedef details::stringvar_node< T > stringvar_t
 
typedef stringvar_tstringvar_ptr
 
typedef ifunction< T > function_t
 
typedef ivararg_function< T > vararg_function_t
 
typedef igeneric_function< T > generic_function_t
 
typedef function_tfunction_ptr
 
typedef vararg_function_tvararg_function_ptr
 
typedef generic_function_tgeneric_function_ptr
 

Static Protected Attributes

static const std::size_t lut_size = 256
 

Private Types

typedef control_block::st_data local_data_t
 

Private Member Functions

bool valid_symbol (const std::string &symbol, const bool check_reserved_symb=true) const
 
bool valid_function (const std::string &symbol) const
 
local_data_tlocal_data ()
 
const local_data_tlocal_data () const
 

Private Attributes

control_blockcontrol_block_
 

Friends

class parser< T >
 

Detailed Description

template<typename T>
class exprtk::symbol_table< T >

Definition at line 19060 of file exprtk.hpp.

Member Typedef Documentation

◆ expression_ptr

template<typename T >
typedef details::expression_node<T>* exprtk::symbol_table< T >::expression_ptr
protected

Definition at line 19649 of file exprtk.hpp.

◆ ff00_functor

template<typename T >
typedef T(* exprtk::symbol_table< T >::ff00_functor) ()

Definition at line 19071 of file exprtk.hpp.

◆ ff01_functor

template<typename T >
typedef T(* exprtk::symbol_table< T >::ff01_functor) (T)

Definition at line 19072 of file exprtk.hpp.

◆ ff02_functor

template<typename T >
typedef T(* exprtk::symbol_table< T >::ff02_functor) (T, T)

Definition at line 19073 of file exprtk.hpp.

◆ ff03_functor

template<typename T >
typedef T(* exprtk::symbol_table< T >::ff03_functor) (T, T, T)

Definition at line 19074 of file exprtk.hpp.

◆ ff04_functor

template<typename T >
typedef T(* exprtk::symbol_table< T >::ff04_functor) (T, T, T, T)

Definition at line 19075 of file exprtk.hpp.

◆ ff05_functor

template<typename T >
typedef T(* exprtk::symbol_table< T >::ff05_functor) (T, T, T, T, T)

Definition at line 19076 of file exprtk.hpp.

◆ ff06_functor

template<typename T >
typedef T(* exprtk::symbol_table< T >::ff06_functor) (T, T, T, T, T, T)

Definition at line 19077 of file exprtk.hpp.

◆ ff07_functor

template<typename T >
typedef T(* exprtk::symbol_table< T >::ff07_functor) (T, T, T, T, T, T, T)

Definition at line 19078 of file exprtk.hpp.

◆ ff08_functor

template<typename T >
typedef T(* exprtk::symbol_table< T >::ff08_functor) (T, T, T, T, T, T, T, T)

Definition at line 19079 of file exprtk.hpp.

◆ ff09_functor

template<typename T >
typedef T(* exprtk::symbol_table< T >::ff09_functor) (T, T, T, T, T, T, T, T, T)

Definition at line 19080 of file exprtk.hpp.

◆ ff10_functor

template<typename T >
typedef T(* exprtk::symbol_table< T >::ff10_functor) (T, T, T, T, T, T, T, T, T, T)

Definition at line 19081 of file exprtk.hpp.

◆ ff11_functor

template<typename T >
typedef T(* exprtk::symbol_table< T >::ff11_functor) (T, T, T, T, T, T, T, T, T, T, T)

Definition at line 19082 of file exprtk.hpp.

◆ ff12_functor

template<typename T >
typedef T(* exprtk::symbol_table< T >::ff12_functor) (T, T, T, T, T, T, T, T, T, T, T, T)

Definition at line 19083 of file exprtk.hpp.

◆ ff13_functor

template<typename T >
typedef T(* exprtk::symbol_table< T >::ff13_functor) (T, T, T, T, T, T, T, T, T, T, T, T, T)

Definition at line 19084 of file exprtk.hpp.

◆ ff14_functor

template<typename T >
typedef T(* exprtk::symbol_table< T >::ff14_functor) (T, T, T, T, T, T, T, T, T, T, T, T, T, T)

Definition at line 19085 of file exprtk.hpp.

◆ ff15_functor

template<typename T >
typedef T(* exprtk::symbol_table< T >::ff15_functor) (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)

Definition at line 19086 of file exprtk.hpp.

◆ function_ptr

template<typename T >
typedef function_t* exprtk::symbol_table< T >::function_ptr
protected

Definition at line 19660 of file exprtk.hpp.

◆ function_t

template<typename T >
typedef ifunction<T> exprtk::symbol_table< T >::function_t
protected

Definition at line 19657 of file exprtk.hpp.

◆ generic_function_ptr

template<typename T >
typedef generic_function_t* exprtk::symbol_table< T >::generic_function_ptr
protected

Definition at line 19662 of file exprtk.hpp.

◆ generic_function_t

template<typename T >
typedef igeneric_function<T> exprtk::symbol_table< T >::generic_function_t
protected

Definition at line 19659 of file exprtk.hpp.

◆ local_data_t

template<typename T >
typedef control_block::st_data exprtk::symbol_table< T >::local_data_t
private

Definition at line 20746 of file exprtk.hpp.

◆ stringvar_ptr

template<typename T >
typedef stringvar_t* exprtk::symbol_table< T >::stringvar_ptr
protected

Definition at line 19655 of file exprtk.hpp.

◆ stringvar_t

template<typename T >
typedef details::stringvar_node<T> exprtk::symbol_table< T >::stringvar_t
protected

Definition at line 19654 of file exprtk.hpp.

◆ vararg_function_ptr

template<typename T >
typedef vararg_function_t* exprtk::symbol_table< T >::vararg_function_ptr
protected

Definition at line 19661 of file exprtk.hpp.

◆ vararg_function_t

template<typename T >
typedef ivararg_function<T> exprtk::symbol_table< T >::vararg_function_t
protected

Definition at line 19658 of file exprtk.hpp.

◆ variable_ptr

template<typename T >
typedef variable_t* exprtk::symbol_table< T >::variable_ptr
protected

Definition at line 19652 of file exprtk.hpp.

◆ variable_t

template<typename T >
typedef details::variable_node<T> exprtk::symbol_table< T >::variable_t
protected

Definition at line 19650 of file exprtk.hpp.

◆ vector_holder_ptr

template<typename T >
typedef vector_holder_t* exprtk::symbol_table< T >::vector_holder_ptr

Definition at line 19994 of file exprtk.hpp.

◆ vector_holder_t

template<typename T >
typedef details::vector_holder<T> exprtk::symbol_table< T >::vector_holder_t
protected

Definition at line 19651 of file exprtk.hpp.

Member Enumeration Documentation

◆ symtab_mutability_type

Enumerator
e_unknown 
e_mutable 
e_immutable 

Definition at line 19064 of file exprtk.hpp.

19065 {
19066 e_unknown = 0,
19067 e_mutable = 1,
19068 e_immutable = 2
19069 };

Constructor & Destructor Documentation

◆ symbol_table() [1/2]

template<typename T >
exprtk::symbol_table< T >::symbol_table ( const symtab_mutability_type  mutability = e_mutable)
inlineexplicit

Definition at line 19782 of file exprtk.hpp.

19784 {
19786 clear();
19787 }
symtab_mutability_type mutability() const
Definition exprtk.hpp:19819
control_block * control_block_
Definition exprtk.hpp:20758
static control_block * create()
Definition exprtk.hpp:19745
void set_mutability(const symtab_mutability_type mutability)
Definition exprtk.hpp:19770

◆ ~symbol_table()

template<typename T >
exprtk::symbol_table< T >::~symbol_table ( )
inline

Definition at line 19789 of file exprtk.hpp.

19790 {
19791 exprtk::details::dump_ptr("~symbol_table", this);
19793 }
void dump_ptr(const std::string &, const void *)
Definition exprtk.hpp:5090
static void destroy(control_block *&cntrl_blck, SymTab *sym_tab)
Definition exprtk.hpp:19751

References exprtk::details::dump_ptr().

Here is the call graph for this function:

◆ symbol_table() [2/2]

template<typename T >
exprtk::symbol_table< T >::symbol_table ( const symbol_table< T > &  st)
inline

Definition at line 19795 of file exprtk.hpp.

19796 {
19797 control_block_ = st.control_block_;
19799 }

References exprtk::symbol_table< T >::control_block_, and exprtk::symbol_table< T >::control_block::ref_count.

Member Function Documentation

◆ add_constant()

template<typename T >
bool exprtk::symbol_table< T >::add_constant ( const std::string &  constant_name,
const T &  value 
)
inline

Definition at line 20098 of file exprtk.hpp.

20099 {
20100 if (!valid())
20101 return false;
20102 else if (!valid_symbol(constant_name))
20103 return false;
20104 else if (symbol_exists(constant_name))
20105 return false;
20106
20107 local_data().local_symbol_list_.push_back(value);
20108 T& t = local_data().local_symbol_list_.back();
20109
20110 return add_variable(constant_name, t, true);
20111 }
bool valid_symbol(const std::string &symbol, const bool check_reserved_symb=true) const
Definition exprtk.hpp:20694
local_data_t & local_data()
Definition exprtk.hpp:20748
bool add_variable(const std::string &variable_name, T &t, const bool is_constant=false)
Definition exprtk.hpp:20086
bool valid() const
Definition exprtk.hpp:20576
bool symbol_exists(const std::string &symbol_name, const bool check_reserved_symb=true) const
Definition exprtk.hpp:20472

Referenced by exprtk::compute(), exprtk::compute(), exprtk::compute(), exprtk::parser< T >::parse_symtab_symbol(), my_usr_ext< T >::process(), and expression_processor< T >::setup_symbol_table().

Here is the caller graph for this function:

◆ add_constants()

template<typename T >
bool exprtk::symbol_table< T >::add_constants ( )
inline

Definition at line 20359 of file exprtk.hpp.

20360 {
20361 return add_pi () &&
20362 add_epsilon () &&
20363 add_infinity() ;
20364 }

Referenced by exprtk::function_compositor< T >::compile_expression(), exprtk::compute(), exprtk::compute(), exprtk::compute(), exprtk::compute(), main(), main(), run_test04(), run_test05(), run_test09(), run_test10(), run_test14(), run_test15(), run_test16(), run_test17(), run_test18(), run_test20(), expression_processor< T >::setup_symbol_table(), test_expression(), and test_gen().

Here is the caller graph for this function:

◆ add_epsilon()

template<typename T >
bool exprtk::symbol_table< T >::add_epsilon ( )
inline

Definition at line 20373 of file exprtk.hpp.

20374 {
20375 static const T local_epsilon = details::numeric::details::epsilon_type<T>::value();
20376 return add_constant("epsilon",local_epsilon);
20377 }
bool add_constant(const std::string &constant_name, const T &value)
Definition exprtk.hpp:20098

◆ add_function() [1/19]

template<typename T >
bool exprtk::symbol_table< T >::add_function ( const std::string &  function_name,
ff00_functor  function 
)
inline

Definition at line 20197 of file exprtk.hpp.

◆ add_function() [2/19]

template<typename T >
bool exprtk::symbol_table< T >::add_function ( const std::string &  function_name,
ff01_functor  function 
)
inline

Definition at line 20197 of file exprtk.hpp.

◆ add_function() [3/19]

template<typename T >
bool exprtk::symbol_table< T >::add_function ( const std::string &  function_name,
ff02_functor  function 
)
inline

Definition at line 20198 of file exprtk.hpp.

◆ add_function() [4/19]

template<typename T >
bool exprtk::symbol_table< T >::add_function ( const std::string &  function_name,
ff03_functor  function 
)
inline

Definition at line 20198 of file exprtk.hpp.

◆ add_function() [5/19]

template<typename T >
bool exprtk::symbol_table< T >::add_function ( const std::string &  function_name,
ff04_functor  function 
)
inline

Definition at line 20199 of file exprtk.hpp.

◆ add_function() [6/19]

template<typename T >
bool exprtk::symbol_table< T >::add_function ( const std::string &  function_name,
ff05_functor  function 
)
inline

Definition at line 20199 of file exprtk.hpp.

◆ add_function() [7/19]

template<typename T >
bool exprtk::symbol_table< T >::add_function ( const std::string &  function_name,
ff06_functor  function 
)
inline

Definition at line 20200 of file exprtk.hpp.

◆ add_function() [8/19]

template<typename T >
bool exprtk::symbol_table< T >::add_function ( const std::string &  function_name,
ff07_functor  function 
)
inline

Definition at line 20200 of file exprtk.hpp.

◆ add_function() [9/19]

template<typename T >
bool exprtk::symbol_table< T >::add_function ( const std::string &  function_name,
ff08_functor  function 
)
inline

Definition at line 20201 of file exprtk.hpp.

◆ add_function() [10/19]

template<typename T >
bool exprtk::symbol_table< T >::add_function ( const std::string &  function_name,
ff09_functor  function 
)
inline

Definition at line 20201 of file exprtk.hpp.

◆ add_function() [11/19]

template<typename T >
bool exprtk::symbol_table< T >::add_function ( const std::string &  function_name,
ff10_functor  function 
)
inline

Definition at line 20202 of file exprtk.hpp.

◆ add_function() [12/19]

template<typename T >
bool exprtk::symbol_table< T >::add_function ( const std::string &  function_name,
ff11_functor  function 
)
inline

Definition at line 20202 of file exprtk.hpp.

◆ add_function() [13/19]

template<typename T >
bool exprtk::symbol_table< T >::add_function ( const std::string &  function_name,
ff12_functor  function 
)
inline

Definition at line 20203 of file exprtk.hpp.

◆ add_function() [14/19]

template<typename T >
bool exprtk::symbol_table< T >::add_function ( const std::string &  function_name,
ff13_functor  function 
)
inline

Definition at line 20203 of file exprtk.hpp.

◆ add_function() [15/19]

template<typename T >
bool exprtk::symbol_table< T >::add_function ( const std::string &  function_name,
ff14_functor  function 
)
inline

Definition at line 20204 of file exprtk.hpp.

◆ add_function() [16/19]

template<typename T >
bool exprtk::symbol_table< T >::add_function ( const std::string &  function_name,
ff15_functor  function 
)
inline

Definition at line 20204 of file exprtk.hpp.

◆ add_function() [17/19]

template<typename T >
bool exprtk::symbol_table< T >::add_function ( const std::string &  function_name,
function_t function 
)
inline

Definition at line 20127 of file exprtk.hpp.

20128 {
20129 if (!valid())
20130 return false;
20131 else if (!valid_symbol(function_name))
20132 return false;
20133 else if (symbol_exists(function_name))
20134 return false;
20135 else
20136 return local_data().function_store.add(function_name,function);
20137 }
type_store< function_t, function_t > function_store
Definition exprtk.hpp:19672

Referenced by extract_expression_dependents(), exprtk::function_compositor< T >::forward(), my_usr_ext< T >::process(), run_test09(), run_test10(), run_test12(), run_test14(), run_test16(), run_test18(), test_expression(), and test_gen().

Here is the caller graph for this function:

◆ add_function() [18/19]

template<typename T >
bool exprtk::symbol_table< T >::add_function ( const std::string &  function_name,
generic_function_t function 
)
inline

Definition at line 20151 of file exprtk.hpp.

20152 {
20153 if (!valid())
20154 return false;
20155 else if (!valid_symbol(function_name))
20156 return false;
20157 else if (symbol_exists(function_name))
20158 return false;
20159 else
20160 {
20161 switch (function.rtrn_type)
20162 {
20164 return (std::string::npos == function.parameter_sequence.find_first_not_of("STVZ*?|")) ?
20165 local_data().generic_function_store.add(function_name,function) : false;
20166
20168 return (std::string::npos == function.parameter_sequence.find_first_not_of("STVZ*?|")) ?
20169 local_data().string_function_store.add(function_name,function) : false;
20170
20172 return (std::string::npos == function.parameter_sequence.find_first_not_of("STVZ*?|:")) ?
20173 local_data().overload_function_store.add(function_name,function) : false;
20174 }
20175 }
20176
20177 return false;
20178 }
type_store< generic_function_t, generic_function_t > string_function_store
Definition exprtk.hpp:19675
type_store< generic_function_t, generic_function_t > overload_function_store
Definition exprtk.hpp:19676
type_store< generic_function_t, generic_function_t > generic_function_store
Definition exprtk.hpp:19674

References exprtk::igeneric_function< T >::parameter_sequence, and exprtk::igeneric_function< T >::rtrn_type.

◆ add_function() [19/19]

template<typename T >
bool exprtk::symbol_table< T >::add_function ( const std::string &  vararg_function_name,
vararg_function_t vararg_function 
)
inline

Definition at line 20139 of file exprtk.hpp.

20140 {
20141 if (!valid())
20142 return false;
20143 else if (!valid_symbol(vararg_function_name))
20144 return false;
20145 else if (symbol_exists(vararg_function_name))
20146 return false;
20147 else
20148 return local_data().vararg_function_store.add(vararg_function_name,vararg_function);
20149 }
type_store< vararg_function_t, vararg_function_t > vararg_function_store
Definition exprtk.hpp:19673

◆ add_infinity()

template<typename T >
bool exprtk::symbol_table< T >::add_infinity ( )
inline

Definition at line 20379 of file exprtk.hpp.

20380 {
20381 static const T local_infinity = std::numeric_limits<T>::infinity();
20382 return add_constant("inf",local_infinity);
20383 }

◆ add_package()

template<typename T >
template<typename Package >
bool exprtk::symbol_table< T >::add_package ( Package &  package)
inline

Definition at line 20386 of file exprtk.hpp.

20387 {
20388 return package.register_package(*this);
20389 }

Referenced by run_test14().

Here is the caller graph for this function:

◆ add_pi()

template<typename T >
bool exprtk::symbol_table< T >::add_pi ( )
inline

Definition at line 20366 of file exprtk.hpp.

20367 {
20369 static const T local_pi = details::numeric::details::const_pi_impl<T>(num_type);
20370 return add_constant("pi",local_pi);
20371 }

Referenced by run_test10().

Here is the caller graph for this function:

◆ add_reserved_function() [1/3]

template<typename T >
bool exprtk::symbol_table< T >::add_reserved_function ( const std::string &  function_name,
function_t function 
)
inline

Definition at line 20208 of file exprtk.hpp.

20209 {
20210 if (!valid())
20211 return false;
20212 else if (!valid_symbol(function_name,false))
20213 return false;
20214 else if (symbol_exists(function_name,false))
20215 return false;
20216 else
20217 return local_data().function_store.add(function_name,function);
20218 }

◆ add_reserved_function() [2/3]

template<typename T >
bool exprtk::symbol_table< T >::add_reserved_function ( const std::string &  function_name,
generic_function_t function 
)
inline

Definition at line 20232 of file exprtk.hpp.

20233 {
20234 if (!valid())
20235 return false;
20236 else if (!valid_symbol(function_name,false))
20237 return false;
20238 else if (symbol_exists(function_name,false))
20239 return false;
20240 else
20241 {
20242 switch (function.rtrn_type)
20243 {
20245 return (std::string::npos == function.parameter_sequence.find_first_not_of("STVZ*?|")) ?
20246 local_data().generic_function_store.add(function_name,function) : false;
20247
20249 return (std::string::npos == function.parameter_sequence.find_first_not_of("STVZ*?|")) ?
20250 local_data().string_function_store.add(function_name,function) : false;
20251
20253 return (std::string::npos == function.parameter_sequence.find_first_not_of("STVZ*?|:")) ?
20254 local_data().overload_function_store.add(function_name,function) : false;
20255 }
20256 }
20257
20258 return false;
20259 }

References exprtk::igeneric_function< T >::parameter_sequence, and exprtk::igeneric_function< T >::rtrn_type.

◆ add_reserved_function() [3/3]

template<typename T >
bool exprtk::symbol_table< T >::add_reserved_function ( const std::string &  vararg_function_name,
vararg_function_t vararg_function 
)
inline

Definition at line 20220 of file exprtk.hpp.

20221 {
20222 if (!valid())
20223 return false;
20224 else if (!valid_symbol(vararg_function_name,false))
20225 return false;
20226 else if (symbol_exists(vararg_function_name,false))
20227 return false;
20228 else
20229 return local_data().vararg_function_store.add(vararg_function_name,vararg_function);
20230 }

◆ add_stringvar()

template<typename T >
bool exprtk::symbol_table< T >::add_stringvar ( const std::string &  stringvar_name,
std::string &  s,
const bool  is_constant = false 
)
inline

Definition at line 20114 of file exprtk.hpp.

20115 {
20116 if (!valid())
20117 return false;
20118 else if (!valid_symbol(stringvar_name))
20119 return false;
20120 else if (symbol_exists(stringvar_name))
20121 return false;
20122 else
20123 return local_data().stringvar_store.add(stringvar_name, s, is_constant);
20124 }
type_store< stringvar_t, std::string > stringvar_store
Definition exprtk.hpp:19679

Referenced by run_test02(), run_test10(), and run_test18().

Here is the caller graph for this function:

◆ add_variable()

template<typename T >
bool exprtk::symbol_table< T >::add_variable ( const std::string &  variable_name,
T &  t,
const bool  is_constant = false 
)
inline

Definition at line 20086 of file exprtk.hpp.

20087 {
20088 if (!valid())
20089 return false;
20090 else if (!valid_symbol(variable_name))
20091 return false;
20092 else if (symbol_exists(variable_name))
20093 return false;
20094 else
20095 return local_data().variable_store.add(variable_name, t, is_constant);
20096 }
type_store< variable_t, T > variable_store
Definition exprtk.hpp:19671

Referenced by main(), main(), run_test01(), run_test02(), run_test04(), run_test05(), run_test06(), run_test07(), run_test08(), run_test09(), run_test10(), run_test11(), run_test12(), run_test14(), run_test15(), run_test16(), run_test17(), run_test18(), run_test20(), and test_gen().

Here is the caller graph for this function:

◆ add_vector() [1/4]

template<typename T >
bool exprtk::symbol_table< T >::add_vector ( const std::string &  vector_name,
exprtk::vector_view< T > &  v 
)
inline

Definition at line 20303 of file exprtk.hpp.

20304 {
20305 if (!valid())
20306 return false;
20307 else if (!valid_symbol(vector_name))
20308 return false;
20309 else if (symbol_exists(vector_name))
20310 return false;
20311 else if (0 == v.size())
20312 return false;
20313 else
20314 return local_data().vector_store.add(vector_name,v);
20315 }
std::size_t size() const
Definition exprtk.hpp:4525
type_store< vector_holder_t, vector_holder_t > vector_store
Definition exprtk.hpp:19677

References exprtk::vector_view< T >::size().

Here is the call graph for this function:

◆ add_vector() [2/4]

template<typename T >
template<typename Allocator >
bool exprtk::symbol_table< T >::add_vector ( const std::string &  vector_name,
std::vector< T, Allocator > &  v 
)
inline

Definition at line 20289 of file exprtk.hpp.

20290 {
20291 if (!valid())
20292 return false;
20293 else if (!valid_symbol(vector_name))
20294 return false;
20295 else if (symbol_exists(vector_name))
20296 return false;
20297 else if (0 == v.size())
20298 return false;
20299 else
20300 return local_data().vector_store.add(vector_name,v);
20301 }

◆ add_vector() [3/4]

template<typename T >
bool exprtk::symbol_table< T >::add_vector ( const std::string &  vector_name,
T *  v,
const std::size_t &  v_size 
)
inline

Definition at line 20274 of file exprtk.hpp.

20275 {
20276 if (!valid())
20277 return false;
20278 else if (!valid_symbol(vector_name))
20279 return false;
20280 else if (symbol_exists(vector_name))
20281 return false;
20282 else if (0 == v_size)
20283 return false;
20284 else
20285 return local_data().vector_store.add(vector_name, v, v_size);
20286 }

◆ add_vector() [4/4]

template<typename T >
template<std::size_t N>
bool exprtk::symbol_table< T >::add_vector ( const std::string &  vector_name,
T(&)  v[N] 
)
inline

Definition at line 20262 of file exprtk.hpp.

20263 {
20264 if (!valid())
20265 return false;
20266 else if (!valid_symbol(vector_name))
20267 return false;
20268 else if (symbol_exists(vector_name))
20269 return false;
20270 else
20271 return local_data().vector_store.add(vector_name,v);
20272 }

Referenced by exprtk::details::collector_helper< T >::resolve_as_vector::process(), run_test01(), and run_test18().

Here is the caller graph for this function:

◆ clear()

template<typename T >
void exprtk::symbol_table< T >::clear ( )
inline

Definition at line 19851 of file exprtk.hpp.

19852 {
19853 if (!valid()) return;
19854 clear_variables ();
19855 clear_functions ();
19856 clear_strings ();
19857 clear_vectors ();
19859 }
void clear_variables(const bool delete_node=true)
Definition exprtk.hpp:19824

Referenced by expression_processor< T >::clear_functions(), and run_test10().

Here is the caller graph for this function:

◆ clear_functions()

template<typename T >
void exprtk::symbol_table< T >::clear_functions ( )
inline

Definition at line 19829 of file exprtk.hpp.

19830 {
19831 local_data().function_store.clear();
19832 }

◆ clear_local_constants()

template<typename T >
void exprtk::symbol_table< T >::clear_local_constants ( )
inline

Definition at line 19846 of file exprtk.hpp.

19847 {
19849 }

◆ clear_strings()

template<typename T >
void exprtk::symbol_table< T >::clear_strings ( )
inline

Definition at line 19834 of file exprtk.hpp.

19835 {
19836 #ifndef exprtk_disable_string_capabilities
19837 local_data().stringvar_store.clear();
19838 #endif
19839 }

◆ clear_variables()

template<typename T >
void exprtk::symbol_table< T >::clear_variables ( const bool  delete_node = true)
inline

Definition at line 19824 of file exprtk.hpp.

19825 {
19826 local_data().variable_store.clear(delete_node);
19827 }

Referenced by expression_processor< T >::setup_symbol_table().

Here is the caller graph for this function:

◆ clear_vectors()

template<typename T >
void exprtk::symbol_table< T >::clear_vectors ( )
inline

Definition at line 19841 of file exprtk.hpp.

19842 {
19843 local_data().vector_store.clear();
19844 }

◆ create_stringvar()

template<typename T >
bool exprtk::symbol_table< T >::create_stringvar ( const std::string &  stringvar_name,
const std::string &  value = std::string("") 
)
inline

Definition at line 20070 of file exprtk.hpp.

20071 {
20072 if (!valid())
20073 return false;
20074 else if (!valid_symbol(stringvar_name))
20075 return false;
20076 else if (symbol_exists(stringvar_name))
20077 return false;
20078
20079 local_data().local_stringvar_list_.push_back(value);
20080 std::string& s = local_data().local_stringvar_list_.back();
20081
20082 return add_stringvar(stringvar_name,s);
20083 }
bool add_stringvar(const std::string &stringvar_name, std::string &s, const bool is_constant=false)
Definition exprtk.hpp:20114
std::list< std::string > local_stringvar_list_
Definition exprtk.hpp:19720

◆ create_variable()

template<typename T >
bool exprtk::symbol_table< T >::create_variable ( const std::string &  variable_name,
const T &  value = T(0) 
)
inline

Definition at line 20054 of file exprtk.hpp.

20055 {
20056 if (!valid())
20057 return false;
20058 else if (!valid_symbol(variable_name))
20059 return false;
20060 else if (symbol_exists(variable_name))
20061 return false;
20062
20063 local_data().local_symbol_list_.push_back(value);
20064 T& t = local_data().local_symbol_list_.back();
20065
20066 return add_variable(variable_name,t);
20067 }

Referenced by main(), exprtk::parser< T >::parse_symtab_symbol(), and my_usr_ext< T >::process().

Here is the caller graph for this function:

◆ function_count()

template<typename T >
std::size_t exprtk::symbol_table< T >::function_count ( ) const
inline

Definition at line 19879 of file exprtk.hpp.

19880 {
19881 if (valid())
19882 return local_data().function_store.size;
19883 else
19884 return 0;
19885 }

◆ get_conststr_stringvar_name()

template<typename T >
std::string exprtk::symbol_table< T >::get_conststr_stringvar_name ( const expression_ptr ptr) const
inline

Definition at line 20570 of file exprtk.hpp.

20571 {
20572 return local_data().stringvar_store.entity_name(ptr);
20573 }

◆ get_function()

template<typename T >
function_ptr exprtk::symbol_table< T >::get_function ( const std::string &  function_name) const
inline

Definition at line 19944 of file exprtk.hpp.

19945 {
19946 if (!valid())
19947 return reinterpret_cast<function_ptr>(0);
19948 else if (!valid_symbol(function_name))
19949 return reinterpret_cast<function_ptr>(0);
19950 else
19951 return local_data().function_store.get(function_name);
19952 }
function_t * function_ptr
Definition exprtk.hpp:19660

Referenced by exprtk::symbol_table< T >::load_from(), and expression_processor< T >::process_function_definition().

Here is the caller graph for this function:

◆ get_function_list()

template<typename T >
template<typename Allocator , template< typename, typename > class Sequence>
std::size_t exprtk::symbol_table< T >::get_function_list ( Sequence< std::string, Allocator > &  function_list) const
inline

Definition at line 20445 of file exprtk.hpp.

20446 {
20447 if (!valid())
20448 return 0;
20449
20450 std::vector<std::string> function_names;
20451 std::size_t count = 0;
20452
20453 count += local_data().function_store .get_list(function_names);
20454 count += local_data().vararg_function_store .get_list(function_names);
20455 count += local_data().generic_function_store .get_list(function_names);
20456 count += local_data().string_function_store .get_list(function_names);
20457 count += local_data().overload_function_store.get_list(function_names);
20458
20459 std::set<std::string> function_set;
20460
20461 for (std::size_t i = 0; i < function_names.size(); ++i)
20462 {
20463 function_set.insert(function_names[i]);
20464 }
20465
20466 std::copy(function_set.begin(),function_set.end(),
20467 std::back_inserter(function_list));
20468
20469 return count;
20470 }

◆ get_generic_function()

template<typename T >
generic_function_ptr exprtk::symbol_table< T >::get_generic_function ( const std::string &  function_name) const
inline

Definition at line 19964 of file exprtk.hpp.

19965 {
19966 if (!valid())
19967 return reinterpret_cast<generic_function_ptr>(0);
19968 else if (!valid_symbol(function_name))
19969 return reinterpret_cast<generic_function_ptr>(0);
19970 else
19971 return local_data().generic_function_store.get(function_name);
19972 }
generic_function_t * generic_function_ptr
Definition exprtk.hpp:19662

Referenced by exprtk::symbol_table< T >::load_from().

Here is the caller graph for this function:

◆ get_overload_function()

template<typename T >
generic_function_ptr exprtk::symbol_table< T >::get_overload_function ( const std::string &  function_name) const
inline

Definition at line 19984 of file exprtk.hpp.

19985 {
19986 if (!valid())
19987 return reinterpret_cast<generic_function_ptr>(0);
19988 else if (!valid_symbol(function_name))
19989 return reinterpret_cast<generic_function_ptr>(0);
19990 else
19991 return local_data().overload_function_store.get(function_name);
19992 }

Referenced by exprtk::symbol_table< T >::load_from().

Here is the caller graph for this function:

◆ get_string_function()

template<typename T >
generic_function_ptr exprtk::symbol_table< T >::get_string_function ( const std::string &  function_name) const
inline

Definition at line 19974 of file exprtk.hpp.

19975 {
19976 if (!valid())
19977 return reinterpret_cast<generic_function_ptr>(0);
19978 else if (!valid_symbol(function_name))
19979 return reinterpret_cast<generic_function_ptr>(0);
19980 else
19981 return local_data().string_function_store.get(function_name);
19982 }

Referenced by exprtk::symbol_table< T >::load_from().

Here is the caller graph for this function:

◆ get_stringvar()

template<typename T >
stringvar_ptr exprtk::symbol_table< T >::get_stringvar ( const std::string &  string_name) const
inline

Definition at line 19915 of file exprtk.hpp.

19916 {
19917 if (!valid())
19918 return reinterpret_cast<stringvar_ptr>(0);
19919 else if (!valid_symbol(string_name))
19920 return reinterpret_cast<stringvar_ptr>(0);
19921 else
19922 return local_data().stringvar_store.get(string_name);
19923 }
stringvar_t * stringvar_ptr
Definition exprtk.hpp:19655

Referenced by run_test10().

Here is the caller graph for this function:

◆ get_stringvar_base()

template<typename T >
stringvar_base< T > exprtk::symbol_table< T >::get_stringvar_base ( const std::string &  string_name) const
inline

Definition at line 19925 of file exprtk.hpp.

19926 {
19927 static stringvar_base<T> null_stringvar_base("",reinterpret_cast<stringvar_ptr>(0));
19928 if (!valid())
19929 return null_stringvar_base;
19930 else if (!valid_symbol(string_name))
19931 return null_stringvar_base;
19932
19933 stringvar_ptr stringvar = local_data().stringvar_store.get(string_name);
19934
19935 if (0 == stringvar)
19936 {
19937 return null_stringvar_base;
19938 }
19939
19940 return stringvar_base<T>(string_name,stringvar);
19941 }

◆ get_stringvar_list() [1/2]

template<typename T >
template<typename Allocator , template< typename, typename > class Sequence>
std::size_t exprtk::symbol_table< T >::get_stringvar_list ( Sequence< std::pair< std::string, std::string >, Allocator > &  svlist) const
inline

Definition at line 20414 of file exprtk.hpp.

20415 {
20416 if (!valid())
20417 return 0;
20418 else
20419 return local_data().stringvar_store.get_list(svlist);
20420 }

Referenced by run_test10().

Here is the caller graph for this function:

◆ get_stringvar_list() [2/2]

template<typename T >
template<typename Allocator , template< typename, typename > class Sequence>
std::size_t exprtk::symbol_table< T >::get_stringvar_list ( Sequence< std::string, Allocator > &  svlist) const
inline

Definition at line 20424 of file exprtk.hpp.

20425 {
20426 if (!valid())
20427 return 0;
20428 else
20429 return local_data().stringvar_store.get_list(svlist);
20430 }

◆ get_stringvar_name()

template<typename T >
std::string exprtk::symbol_table< T >::get_stringvar_name ( const expression_ptr ptr) const
inline

Definition at line 20565 of file exprtk.hpp.

20566 {
20567 return local_data().stringvar_store.entity_name(ptr);
20568 }

◆ get_vararg_function()

template<typename T >
vararg_function_ptr exprtk::symbol_table< T >::get_vararg_function ( const std::string &  vararg_function_name) const
inline

Definition at line 19954 of file exprtk.hpp.

19955 {
19956 if (!valid())
19957 return reinterpret_cast<vararg_function_ptr>(0);
19958 else if (!valid_symbol(vararg_function_name))
19959 return reinterpret_cast<vararg_function_ptr>(0);
19960 else
19961 return local_data().vararg_function_store.get(vararg_function_name);
19962 }
vararg_function_t * vararg_function_ptr
Definition exprtk.hpp:19661

Referenced by exprtk::symbol_table< T >::load_from().

Here is the caller graph for this function:

◆ get_variable() [1/2]

template<typename T >
variable_ptr exprtk::symbol_table< T >::get_variable ( const std::string &  variable_name) const
inline

Definition at line 19895 of file exprtk.hpp.

19896 {
19897 if (!valid())
19898 return reinterpret_cast<variable_ptr>(0);
19899 else if (!valid_symbol(variable_name))
19900 return reinterpret_cast<variable_ptr>(0);
19901 else
19902 return local_data().variable_store.get(variable_name);
19903 }
variable_t * variable_ptr
Definition exprtk.hpp:19652

Referenced by exprtk::derivative(), exprtk::integrate(), exprtk::symbol_table< T >::load_variables_from(), run_test10(), exprtk::second_derivative(), and exprtk::third_derivative().

Here is the caller graph for this function:

◆ get_variable() [2/2]

template<typename T >
variable_ptr exprtk::symbol_table< T >::get_variable ( const T &  var_ref) const
inline

Definition at line 19905 of file exprtk.hpp.

19906 {
19907 if (!valid())
19908 return reinterpret_cast<variable_ptr>(0);
19909 else
19910 return local_data().variable_store.get_from_varptr(
19911 reinterpret_cast<const void*>(&var_ref));
19912 }

◆ get_variable_list() [1/2]

template<typename T >
template<typename Allocator , template< typename, typename > class Sequence>
std::size_t exprtk::symbol_table< T >::get_variable_list ( Sequence< std::pair< std::string, T >, Allocator > &  vlist) const
inline

Definition at line 20393 of file exprtk.hpp.

20394 {
20395 if (!valid())
20396 return 0;
20397 else
20398 return local_data().variable_store.get_list(vlist);
20399 }

Referenced by expression_processor< T >::list_symbols(), and run_test10().

Here is the caller graph for this function:

◆ get_variable_list() [2/2]

template<typename T >
template<typename Allocator , template< typename, typename > class Sequence>
std::size_t exprtk::symbol_table< T >::get_variable_list ( Sequence< std::string, Allocator > &  vlist) const
inline

Definition at line 20403 of file exprtk.hpp.

20404 {
20405 if (!valid())
20406 return 0;
20407 else
20408 return local_data().variable_store.get_list(vlist);
20409 }

◆ get_variable_name()

template<typename T >
std::string exprtk::symbol_table< T >::get_variable_name ( const expression_ptr ptr) const
inline

Definition at line 20554 of file exprtk.hpp.

20555 {
20556 return local_data().variable_store.entity_name(ptr);
20557 }

◆ get_vector()

template<typename T >
vector_holder_ptr exprtk::symbol_table< T >::get_vector ( const std::string &  vector_name) const
inline

Definition at line 19996 of file exprtk.hpp.

19997 {
19998 if (!valid())
19999 return reinterpret_cast<vector_holder_ptr>(0);
20000 else if (!valid_symbol(vector_name))
20001 return reinterpret_cast<vector_holder_ptr>(0);
20002 else
20003 return local_data().vector_store.get(vector_name);
20004 }
vector_holder_t * vector_holder_ptr
Definition exprtk.hpp:19994

Referenced by exprtk::symbol_table< T >::load_vectors_from().

Here is the caller graph for this function:

◆ get_vector_list()

template<typename T >
template<typename Allocator , template< typename, typename > class Sequence>
std::size_t exprtk::symbol_table< T >::get_vector_list ( Sequence< std::string, Allocator > &  vec_list) const
inline

Definition at line 20435 of file exprtk.hpp.

20436 {
20437 if (!valid())
20438 return 0;
20439 else
20440 return local_data().vector_store.get_list(vec_list);
20441 }

◆ get_vector_name()

template<typename T >
std::string exprtk::symbol_table< T >::get_vector_name ( const vector_holder_ptr ptr) const
inline

Definition at line 20559 of file exprtk.hpp.

20560 {
20561 return local_data().vector_store.entity_name(ptr);
20562 }

◆ is_constant_node()

template<typename T >
bool exprtk::symbol_table< T >::is_constant_node ( const std::string &  symbol_name) const
inline

Definition at line 20030 of file exprtk.hpp.

20031 {
20032 if (!valid())
20033 return false;
20034 else if (!valid_symbol(symbol_name))
20035 return false;
20036 else
20037 return local_data().variable_store.is_constant(symbol_name);
20038 }

◆ is_constant_string()

template<typename T >
bool exprtk::symbol_table< T >::is_constant_string ( const std::string &  symbol_name) const
inline

Definition at line 20041 of file exprtk.hpp.

20042 {
20043 if (!valid())
20044 return false;
20045 else if (!valid_symbol(symbol_name))
20046 return false;
20047 else if (!local_data().stringvar_store.symbol_exists(symbol_name))
20048 return false;
20049 else
20050 return local_data().stringvar_store.is_constant(symbol_name);
20051 }

◆ is_conststr_stringvar()

template<typename T >
bool exprtk::symbol_table< T >::is_conststr_stringvar ( const std::string &  symbol_name) const
inline

Definition at line 20514 of file exprtk.hpp.

20515 {
20516 if (!valid())
20517 return false;
20518 else if (!valid_symbol(symbol_name))
20519 return false;
20520 else if (!local_data().stringvar_store.symbol_exists(symbol_name))
20521 return false;
20522
20523 return (
20524 local_data().stringvar_store.symbol_exists(symbol_name) ||
20525 local_data().stringvar_store.is_constant (symbol_name)
20526 );
20527 }

◆ is_function()

template<typename T >
bool exprtk::symbol_table< T >::is_function ( const std::string &  function_name) const
inline

Definition at line 20530 of file exprtk.hpp.

20531 {
20532 if (!valid())
20533 return false;
20534 else
20535 return local_data().function_store.symbol_exists(function_name);
20536 }

◆ is_stringvar()

template<typename T >
bool exprtk::symbol_table< T >::is_stringvar ( const std::string &  stringvar_name) const
inline

Definition at line 20506 of file exprtk.hpp.

20507 {
20508 if (!valid())
20509 return false;
20510 else
20511 return local_data().stringvar_store.symbol_exists(stringvar_name);
20512 }

◆ is_vararg_function()

template<typename T >
bool exprtk::symbol_table< T >::is_vararg_function ( const std::string &  vararg_function_name) const
inline

Definition at line 20538 of file exprtk.hpp.

20539 {
20540 if (!valid())
20541 return false;
20542 else
20543 return local_data().vararg_function_store.symbol_exists(vararg_function_name);
20544 }

◆ is_variable()

template<typename T >
bool exprtk::symbol_table< T >::is_variable ( const std::string &  variable_name) const
inline

Definition at line 20497 of file exprtk.hpp.

20498 {
20499 if (!valid())
20500 return false;
20501 else
20502 return local_data().variable_store.symbol_exists(variable_name);
20503 }

◆ is_vector()

template<typename T >
bool exprtk::symbol_table< T >::is_vector ( const std::string &  vector_name) const
inline

Definition at line 20546 of file exprtk.hpp.

20547 {
20548 if (!valid())
20549 return false;
20550 else
20551 return local_data().vector_store.symbol_exists(vector_name);
20552 }

◆ load_from()

template<typename T >
void exprtk::symbol_table< T >::load_from ( const symbol_table< T > &  st)
inline

Definition at line 20582 of file exprtk.hpp.

20583 {
20584 {
20585 std::vector<std::string> name_list;
20586
20587 st.local_data().function_store.get_list(name_list);
20588
20589 if (!name_list.empty())
20590 {
20591 for (std::size_t i = 0; i < name_list.size(); ++i)
20592 {
20593 exprtk::ifunction<T>& ifunc = *st.get_function(name_list[i]);
20594 add_function(name_list[i],ifunc);
20595 }
20596 }
20597 }
20598
20599 {
20600 std::vector<std::string> name_list;
20601
20602 st.local_data().vararg_function_store.get_list(name_list);
20603
20604 if (!name_list.empty())
20605 {
20606 for (std::size_t i = 0; i < name_list.size(); ++i)
20607 {
20608 exprtk::ivararg_function<T>& ivafunc = *st.get_vararg_function(name_list[i]);
20609 add_function(name_list[i],ivafunc);
20610 }
20611 }
20612 }
20613
20614 {
20615 std::vector<std::string> name_list;
20616
20617 st.local_data().generic_function_store.get_list(name_list);
20618
20619 if (!name_list.empty())
20620 {
20621 for (std::size_t i = 0; i < name_list.size(); ++i)
20622 {
20623 exprtk::igeneric_function<T>& ifunc = *st.get_generic_function(name_list[i]);
20624 add_function(name_list[i],ifunc);
20625 }
20626 }
20627 }
20628
20629 {
20630 std::vector<std::string> name_list;
20631
20632 st.local_data().string_function_store.get_list(name_list);
20633
20634 if (!name_list.empty())
20635 {
20636 for (std::size_t i = 0; i < name_list.size(); ++i)
20637 {
20638 exprtk::igeneric_function<T>& ifunc = *st.get_string_function(name_list[i]);
20639 add_function(name_list[i],ifunc);
20640 }
20641 }
20642 }
20643
20644 {
20645 std::vector<std::string> name_list;
20646
20647 st.local_data().overload_function_store.get_list(name_list);
20648
20649 if (!name_list.empty())
20650 {
20651 for (std::size_t i = 0; i < name_list.size(); ++i)
20652 {
20653 exprtk::igeneric_function<T>& ifunc = *st.get_overload_function(name_list[i]);
20654 add_function(name_list[i],ifunc);
20655 }
20656 }
20657 }
20658 }
bool add_function(const std::string &function_name, function_t &function)
Definition exprtk.hpp:20127

References exprtk::symbol_table< T >::control_block::st_data::function_store, exprtk::symbol_table< T >::control_block::st_data::generic_function_store, exprtk::symbol_table< T >::get_function(), exprtk::symbol_table< T >::get_generic_function(), exprtk::symbol_table< T >::get_overload_function(), exprtk::symbol_table< T >::get_string_function(), exprtk::symbol_table< T >::get_vararg_function(), exprtk::symbol_table< T >::local_data(), exprtk::symbol_table< T >::control_block::st_data::overload_function_store, exprtk::symbol_table< T >::control_block::st_data::string_function_store, and exprtk::symbol_table< T >::control_block::st_data::vararg_function_store.

Referenced by exprtk::function_compositor< T >::compile_expression().

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

◆ load_variables_from()

template<typename T >
void exprtk::symbol_table< T >::load_variables_from ( const symbol_table< T > &  st)
inline

Definition at line 20660 of file exprtk.hpp.

20661 {
20662 std::vector<std::string> name_list;
20663
20664 st.local_data().variable_store.get_list(name_list);
20665
20666 if (!name_list.empty())
20667 {
20668 for (std::size_t i = 0; i < name_list.size(); ++i)
20669 {
20670 T& variable = st.get_variable(name_list[i])->ref();
20671 add_variable(name_list[i], variable);
20672 }
20673 }
20674 }

References exprtk::symbol_table< T >::get_variable(), exprtk::symbol_table< T >::local_data(), exprtk::details::variable_node< T >::ref(), and exprtk::symbol_table< T >::control_block::st_data::variable_store.

Referenced by exprtk::function_compositor< T >::compile_expression().

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

◆ load_vectors_from()

template<typename T >
void exprtk::symbol_table< T >::load_vectors_from ( const symbol_table< T > &  st)
inline

Definition at line 20676 of file exprtk.hpp.

20677 {
20678 std::vector<std::string> name_list;
20679
20680 st.local_data().vector_store.get_list(name_list);
20681
20682 if (!name_list.empty())
20683 {
20684 for (std::size_t i = 0; i < name_list.size(); ++i)
20685 {
20686 vector_holder_t& vecholder = *st.get_vector(name_list[i]);
20687 add_vector(name_list[i], vecholder.data(), vecholder.size());
20688 }
20689 }
20690 }
details::vector_holder< T > vector_holder_t
Definition exprtk.hpp:19651
bool add_vector(const std::string &vector_name, T(&v)[N])
Definition exprtk.hpp:20262

References exprtk::details::vector_holder< Type >::data(), exprtk::symbol_table< T >::get_vector(), exprtk::symbol_table< T >::local_data(), exprtk::details::vector_holder< Type >::size(), and exprtk::symbol_table< T >::control_block::st_data::vector_store.

Referenced by exprtk::function_compositor< T >::compile_expression().

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

◆ local_data() [1/2]

template<typename T >
local_data_t & exprtk::symbol_table< T >::local_data ( )
inlineprivate

Definition at line 20748 of file exprtk.hpp.

20749 {
20750 return *(control_block_->data_);
20751 }

Referenced by exprtk::symbol_table< T >::load_from(), exprtk::symbol_table< T >::load_variables_from(), and exprtk::symbol_table< T >::load_vectors_from().

Here is the caller graph for this function:

◆ local_data() [2/2]

template<typename T >
const local_data_t & exprtk::symbol_table< T >::local_data ( ) const
inlineprivate

Definition at line 20753 of file exprtk.hpp.

20754 {
20755 return *(control_block_->data_);
20756 }

◆ mutability()

template<typename T >
symtab_mutability_type exprtk::symbol_table< T >::mutability ( ) const
inline

Definition at line 19819 of file exprtk.hpp.

19820 {
19822 }
symtab_mutability_type mutability_
Definition exprtk.hpp:19777

◆ operator=()

template<typename T >
symbol_table< T > & exprtk::symbol_table< T >::operator= ( const symbol_table< T > &  st)
inline

Definition at line 19801 of file exprtk.hpp.

19802 {
19803 if (this != &st)
19804 {
19805 control_block::destroy(control_block_,reinterpret_cast<symbol_table<T>*>(0));
19806
19807 control_block_ = st.control_block_;
19809 }
19810
19811 return (*this);
19812 }

References exprtk::symbol_table< T >::control_block_, and exprtk::symbol_table< T >::control_block::ref_count.

◆ operator==()

template<typename T >
bool exprtk::symbol_table< T >::operator== ( const symbol_table< T > &  st) const
inline

Definition at line 19814 of file exprtk.hpp.

19815 {
19816 return (this == &st) || (control_block_ == st.control_block_);
19817 }

References exprtk::symbol_table< T >::control_block_.

◆ remove_function()

template<typename T >
bool exprtk::symbol_table< T >::remove_function ( const std::string &  function_name)
inline

Definition at line 20335 of file exprtk.hpp.

20336 {
20337 if (!valid())
20338 return false;
20339 else
20340 return local_data().function_store.remove(function_name);
20341 }

Referenced by expression_processor< T >::process_function_definition(), run_test10(), and run_test18().

Here is the caller graph for this function:

◆ remove_stringvar()

template<typename T >
bool exprtk::symbol_table< T >::remove_stringvar ( const std::string &  string_name)
inline

Definition at line 20326 of file exprtk.hpp.

20327 {
20328 if (!valid())
20329 return false;
20330 else
20331 return local_data().stringvar_store.remove(string_name);
20332 }

Referenced by run_test10(), and run_test18().

Here is the caller graph for this function:

◆ remove_vararg_function()

template<typename T >
bool exprtk::symbol_table< T >::remove_vararg_function ( const std::string &  vararg_function_name)
inline

Definition at line 20343 of file exprtk.hpp.

20344 {
20345 if (!valid())
20346 return false;
20347 else
20348 return local_data().vararg_function_store.remove(vararg_function_name);
20349 }

Referenced by run_test18().

Here is the caller graph for this function:

◆ remove_variable()

template<typename T >
bool exprtk::symbol_table< T >::remove_variable ( const std::string &  variable_name,
const bool  delete_node = true 
)
inline

Definition at line 20317 of file exprtk.hpp.

20318 {
20319 if (!valid())
20320 return false;
20321 else
20322 return local_data().variable_store.remove(variable_name, delete_node);
20323 }

Referenced by run_test10(), and run_test18().

Here is the caller graph for this function:

◆ remove_vector()

template<typename T >
bool exprtk::symbol_table< T >::remove_vector ( const std::string &  vector_name)
inline

Definition at line 20351 of file exprtk.hpp.

20352 {
20353 if (!valid())
20354 return false;
20355 else
20356 return local_data().vector_store.remove(vector_name);
20357 }

Referenced by run_test18().

Here is the caller graph for this function:

◆ stringvar_count()

template<typename T >
std::size_t exprtk::symbol_table< T >::stringvar_count ( ) const
inline

Definition at line 19870 of file exprtk.hpp.

19871 {
19872 if (valid())
19873 return local_data().stringvar_store.size;
19874 else
19875 return 0;
19876 }

Referenced by run_test10().

Here is the caller graph for this function:

◆ stringvar_ref()

template<typename T >
std::string & exprtk::symbol_table< T >::stringvar_ref ( const std::string &  symbol_name)
inline

Definition at line 20018 of file exprtk.hpp.

20019 {
20020 static std::string null_stringvar;
20021 if (!valid())
20022 return null_stringvar;
20023 else if (!valid_symbol(symbol_name))
20024 return null_stringvar;
20025 else
20026 return local_data().stringvar_store.type_ref(symbol_name);
20027 }

◆ symbol_exists()

template<typename T >
bool exprtk::symbol_table< T >::symbol_exists ( const std::string &  symbol_name,
const bool  check_reserved_symb = true 
) const
inline

Definition at line 20472 of file exprtk.hpp.

20473 {
20474 /*
20475 Function will return true if symbol_name exists as either a
20476 reserved symbol, variable, stringvar, vector or function name
20477 in any of the type stores.
20478 */
20479 if (!valid())
20480 return false;
20481 else if (local_data().variable_store.symbol_exists(symbol_name))
20482 return true;
20483 #ifndef exprtk_disable_string_capabilities
20484 else if (local_data().stringvar_store.symbol_exists(symbol_name))
20485 return true;
20486 #endif
20487 else if (local_data().vector_store.symbol_exists(symbol_name))
20488 return true;
20489 else if (local_data().function_store.symbol_exists(symbol_name))
20490 return true;
20491 else if (check_reserved_symb && local_data().is_reserved_symbol(symbol_name))
20492 return true;
20493 else
20494 return false;
20495 }
bool is_reserved_symbol(const std::string &symbol)
Definition exprtk.hpp:522

Referenced by run_test10().

Here is the caller graph for this function:

◆ valid()

template<typename T >
bool exprtk::symbol_table< T >::valid ( ) const
inline

Definition at line 20576 of file exprtk.hpp.

20577 {
20578 // Symbol table sanity check.
20580 }

Referenced by exprtk::derivative(), exprtk::integrate(), exprtk::second_derivative(), and exprtk::third_derivative().

Here is the caller graph for this function:

◆ valid_function()

template<typename T >
bool exprtk::symbol_table< T >::valid_function ( const std::string &  symbol) const
inlineprivate

Definition at line 20720 of file exprtk.hpp.

20721 {
20722 if (symbol.empty())
20723 return false;
20724 else if (!details::is_letter(symbol[0]))
20725 return false;
20726 else if (symbol.size() > 1)
20727 {
20728 for (std::size_t i = 1; i < symbol.size(); ++i)
20729 {
20730 if (
20731 !details::is_letter_or_digit(symbol[i]) &&
20732 ('_' != symbol[i])
20733 )
20734 {
20735 if ((i < (symbol.size() - 1)) && ('.' == symbol[i]))
20736 continue;
20737 else
20738 return false;
20739 }
20740 }
20741 }
20742
20743 return true;
20744 }
bool is_letter_or_digit(const char_t c)
Definition exprtk.hpp:131
bool is_letter(const char_t c)
Definition exprtk.hpp:120

◆ valid_symbol()

template<typename T >
bool exprtk::symbol_table< T >::valid_symbol ( const std::string &  symbol,
const bool  check_reserved_symb = true 
) const
inlineprivate

Definition at line 20694 of file exprtk.hpp.

20695 {
20696 if (symbol.empty())
20697 return false;
20698 else if (!details::is_letter(symbol[0]))
20699 return false;
20700 else if (symbol.size() > 1)
20701 {
20702 for (std::size_t i = 1; i < symbol.size(); ++i)
20703 {
20704 if (
20705 !details::is_letter_or_digit(symbol[i]) &&
20706 ('_' != symbol[i])
20707 )
20708 {
20709 if ((i < (symbol.size() - 1)) && ('.' == symbol[i]))
20710 continue;
20711 else
20712 return false;
20713 }
20714 }
20715 }
20716
20717 return (check_reserved_symb) ? (!local_data().is_reserved_symbol(symbol)) : true;
20718 }
bool is_reserved_symbol(const std::string &symbol) const
Definition exprtk.hpp:19703

◆ variable_count()

template<typename T >
std::size_t exprtk::symbol_table< T >::variable_count ( ) const
inline

Definition at line 19861 of file exprtk.hpp.

19862 {
19863 if (valid())
19864 return local_data().variable_store.size;
19865 else
19866 return 0;
19867 }

◆ variable_ref()

template<typename T >
T & exprtk::symbol_table< T >::variable_ref ( const std::string &  symbol_name)
inline

Definition at line 20006 of file exprtk.hpp.

20007 {
20008 static T null_var = T(0);
20009 if (!valid())
20010 return null_var;
20011 else if (!valid_symbol(symbol_name))
20012 return null_var;
20013 else
20014 return local_data().variable_store.type_ref(symbol_name);
20015 }

◆ vector_count()

template<typename T >
std::size_t exprtk::symbol_table< T >::vector_count ( ) const
inline

Definition at line 19887 of file exprtk.hpp.

19888 {
19889 if (valid())
19890 return local_data().vector_store.size;
19891 else
19892 return 0;
19893 }

Friends And Related Symbol Documentation

◆ parser< T >

template<typename T >
friend class parser< T >
friend

Definition at line 20758 of file exprtk.hpp.

Member Data Documentation

◆ control_block_

template<typename T >
control_block* exprtk::symbol_table< T >::control_block_
private

◆ lut_size

template<typename T >
const std::size_t exprtk::symbol_table< T >::lut_size = 256
staticprotected

Definition at line 19664 of file exprtk.hpp.


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