exprtk::parser< T >::symtab_store Struct Reference

Collaboration diagram for exprtk::parser< T >::symtab_store:

Classes
struct	variable_context
struct	vector_context
struct	string_context

Public Types
typedef symbol_table_t::local_data_t	local_data_t
typedef symbol_table_t::variable_ptr	variable_ptr
typedef symbol_table_t::function_ptr	function_ptr
typedef symbol_table_t::stringvar_ptr	stringvar_ptr
typedef symbol_table_t::vector_holder_ptr	vector_holder_ptr
typedef symbol_table_t::vararg_function_ptr	vararg_function_ptr
typedef symbol_table_t::generic_function_ptr	generic_function_ptr

Public Member Functions
bool	empty () const
void	clear ()
bool	valid () const
bool	valid_symbol (const std::string &symbol) const
bool	valid_function_name (const std::string &symbol) const
variable_context	get_variable_context (const std::string &variable_name) const
variable_ptr	get_variable (const std::string &variable_name) const
variable_ptr	get_variable (const T &var_ref) const
string_context	get_string_context (const std::string &string_name) const
stringvar_ptr	get_stringvar (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_context	get_vector_context (const std::string &vector_name) const
vector_holder_ptr	get_vector (const std::string &vector_name) const
bool	is_constant_node (const std::string &symbol_name) const
bool	is_constant_string (const std::string &symbol_name) const
bool	symbol_exists (const std::string &symbol) 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_node_ptr &ptr) const
std::string	get_vector_name (const vector_holder_ptr &ptr) const
std::string	get_stringvar_name (const expression_node_ptr &ptr) const
std::string	get_conststr_stringvar_name (const expression_node_ptr &ptr) const
local_data_t &	local_data (const std::size_t &index=0)
const local_data_t &	local_data (const std::size_t &index=0) const
symbol_table_t &	get_symbol_table (const std::size_t &index=0)

Public Attributes
symbol_table_list_t	symtab_list_

Detailed Description

template<typename T>
struct exprtk::parser< T >::symtab_store

Definition at line 23191 of file exprtk.hpp.

Member Typedef Documentation

function_ptr

template<typename T>

typedef symbol_table_t::function_ptr exprtk::parser< T >::symtab_store::function_ptr

Definition at line 23197 of file exprtk.hpp.

generic_function_ptr

template<typename T>

typedef symbol_table_t::generic_function_ptr exprtk::parser< T >::symtab_store::generic_function_ptr

Definition at line 23203 of file exprtk.hpp.

local_data_t

template<typename T>

typedef symbol_table_t::local_data_t exprtk::parser< T >::symtab_store::local_data_t

Definition at line 23195 of file exprtk.hpp.

stringvar_ptr

template<typename T>

typedef symbol_table_t::stringvar_ptr exprtk::parser< T >::symtab_store::stringvar_ptr

Definition at line 23199 of file exprtk.hpp.

vararg_function_ptr

template<typename T>

typedef symbol_table_t::vararg_function_ptr exprtk::parser< T >::symtab_store::vararg_function_ptr

Definition at line 23202 of file exprtk.hpp.

variable_ptr

template<typename T>

typedef symbol_table_t::variable_ptr exprtk::parser< T >::symtab_store::variable_ptr

Definition at line 23196 of file exprtk.hpp.

vector_holder_ptr

template<typename T>

typedef symbol_table_t::vector_holder_ptr exprtk::parser< T >::symtab_store::vector_holder_ptr

Definition at line 23201 of file exprtk.hpp.

Member Function Documentation

clear()

template<typename T>

void exprtk::parser< T >::symtab_store::clear ( )

inline

Definition at line 23245 of file exprtk.hpp.

         {
            symtab_list_.clear();
         }

References symtab_list_.

empty()

template<typename T>

bool exprtk::parser< T >::symtab_store::empty ( ) const

inline

Definition at line 23240 of file exprtk.hpp.

         {
            return symtab_list_.empty();
         }

References symtab_list_.

Referenced by valid().

Here is the caller graph for this function:

get_conststr_stringvar_name()

template<typename T>

std::string exprtk::parser< T >::symtab_store::get_conststr_stringvar_name ( const expression_node_ptr & ptr ) const

inline

Definition at line 23728 of file exprtk.hpp.

         {
            return local_data().stringvar_store.entity_name(ptr);
         }

References local_data(), and exprtk::symbol_table< T >::control_block::st_data::stringvar_store.

Here is the call graph for this function:

get_function()

template<typename T>

function_ptr exprtk::parser< T >::symtab_store::get_function ( const std::string & function_name ) const

inline

Definition at line 23394 of file exprtk.hpp.

         {
            if (!valid_function_name(function_name))
               return reinterpret_cast<function_ptr>(0);
 
            function_ptr result = reinterpret_cast<function_ptr>(0);
 
            for (std::size_t i = 0; i < symtab_list_.size(); ++i)
            {
               if (!symtab_list_[i].valid())
                  continue;
               else
                  result = local_data(i)
                              .function_store.get(function_name);
 
               if (result) break;
            }
 
            return result;
         }

References exprtk::symbol_table< T >::control_block::st_data::function_store, local_data(), symtab_list_, valid(), and valid_function_name().

Here is the call graph for this function:

get_generic_function()

template<typename T>

generic_function_ptr exprtk::parser< T >::symtab_store::get_generic_function ( const std::string & function_name ) const

inline

Definition at line 23436 of file exprtk.hpp.

         {
            if (!valid_function_name(function_name))
               return reinterpret_cast<generic_function_ptr>(0);
 
            generic_function_ptr result = reinterpret_cast<generic_function_ptr>(0);
 
            for (std::size_t i = 0; i < symtab_list_.size(); ++i)
            {
               if (!symtab_list_[i].valid())
                  continue;
               else
                  result = local_data(i)
                              .generic_function_store.get(function_name);
 
               if (result) break;
            }
 
            return result;
         }

References exprtk::symbol_table< T >::control_block::st_data::generic_function_store, local_data(), symtab_list_, valid(), and valid_function_name().

Here is the call graph for this function:

get_overload_function()

template<typename T>

generic_function_ptr exprtk::parser< T >::symtab_store::get_overload_function ( const std::string & function_name ) const

inline

Definition at line 23478 of file exprtk.hpp.

         {
            if (!valid_function_name(function_name))
               return reinterpret_cast<generic_function_ptr>(0);
 
            generic_function_ptr result = reinterpret_cast<generic_function_ptr>(0);
 
            for (std::size_t i = 0; i < symtab_list_.size(); ++i)
            {
               if (!symtab_list_[i].valid())
                  continue;
               else
                  result =
                     local_data(i).overload_function_store.get(function_name);
 
               if (result) break;
            }
 
            return result;
         }

References local_data(), exprtk::symbol_table< T >::control_block::st_data::overload_function_store, symtab_list_, valid(), and valid_function_name().

Here is the call graph for this function:

get_string_context()

template<typename T>

string_context exprtk::parser< T >::symtab_store::get_string_context ( const std::string & string_name ) const

inline

Definition at line 23346 of file exprtk.hpp.

         {
            string_context result;
 
            if (!valid_symbol(string_name))
               return result;
 
            for (std::size_t i = 0; i < symtab_list_.size(); ++i)
            {
               if (!symtab_list_[i].valid())
               {
                  continue;
               }
 
               result.str_var = local_data(i).stringvar_store.get(string_name);
 
               if (result.str_var)
               {
                  result.symbol_table = &symtab_list_[i];
                  break;
               }
            }
 
            return result;
         }

References local_data(), exprtk::parser< T >::symtab_store::string_context::str_var, exprtk::symbol_table< T >::control_block::st_data::stringvar_store, exprtk::parser< T >::symtab_store::string_context::symbol_table, symtab_list_, valid(), and valid_symbol().

Here is the call graph for this function:

get_string_function()

template<typename T>

generic_function_ptr exprtk::parser< T >::symtab_store::get_string_function ( const std::string & function_name ) const

inline

Definition at line 23457 of file exprtk.hpp.

         {
            if (!valid_function_name(function_name))
               return reinterpret_cast<generic_function_ptr>(0);
 
            generic_function_ptr result = reinterpret_cast<generic_function_ptr>(0);
 
            for (std::size_t i = 0; i < symtab_list_.size(); ++i)
            {
               if (!symtab_list_[i].valid())
                  continue;
               else
                  result =
                     local_data(i).string_function_store.get(function_name);
 
               if (result) break;
            }
 
            return result;
         }

References local_data(), exprtk::symbol_table< T >::control_block::st_data::string_function_store, symtab_list_, valid(), and valid_function_name().

Here is the call graph for this function:

get_stringvar()

template<typename T>

stringvar_ptr exprtk::parser< T >::symtab_store::get_stringvar ( const std::string & string_name ) const

inline

Definition at line 23372 of file exprtk.hpp.

         {
            if (!valid_symbol(string_name))
               return reinterpret_cast<stringvar_ptr>(0);
 
            stringvar_ptr result = reinterpret_cast<stringvar_ptr>(0);
 
            for (std::size_t i = 0; i < symtab_list_.size(); ++i)
            {
               if (!symtab_list_[i].valid())
                  continue;
               else
                  result = local_data(i)
                              .stringvar_store.get(string_name);
 
               if (result) break;
            }
 
            return result;
         }

References local_data(), exprtk::symbol_table< T >::control_block::st_data::stringvar_store, symtab_list_, valid(), and valid_symbol().

Here is the call graph for this function:

get_stringvar_name()

template<typename T>

std::string exprtk::parser< T >::symtab_store::get_stringvar_name ( const expression_node_ptr & ptr ) const

inline

Definition at line 23723 of file exprtk.hpp.

         {
            return local_data().stringvar_store.entity_name(ptr);
         }

References local_data(), and exprtk::symbol_table< T >::control_block::st_data::stringvar_store.

Here is the call graph for this function:

get_symbol_table()

template<typename T>

symbol_table_t & exprtk::parser< T >::symtab_store::get_symbol_table ( const std::size_t & index = 0 )

inline

Definition at line 23744 of file exprtk.hpp.

         {
            return symtab_list_[index];
         }

References symtab_list_.

get_vararg_function()

template<typename T>

vararg_function_ptr exprtk::parser< T >::symtab_store::get_vararg_function ( const std::string & vararg_function_name ) const

inline

Definition at line 23415 of file exprtk.hpp.

         {
            if (!valid_function_name(vararg_function_name))
               return reinterpret_cast<vararg_function_ptr>(0);
 
            vararg_function_ptr result = reinterpret_cast<vararg_function_ptr>(0);
 
            for (std::size_t i = 0; i < symtab_list_.size(); ++i)
            {
               if (!symtab_list_[i].valid())
                  continue;
               else
                  result = local_data(i)
                              .vararg_function_store.get(vararg_function_name);
 
               if (result) break;
            }
 
            return result;
         }

References local_data(), symtab_list_, valid(), valid_function_name(), and exprtk::symbol_table< T >::control_block::st_data::vararg_function_store.

Here is the call graph for this function:

get_variable() [1/2]

template<typename T>

variable_ptr exprtk::parser< T >::symtab_store::get_variable ( const std::string & variable_name ) const

inline

Definition at line 23306 of file exprtk.hpp.

         {
            if (!valid_symbol(variable_name))
               return reinterpret_cast<variable_ptr>(0);
 
            variable_ptr result = reinterpret_cast<variable_ptr>(0);
 
            for (std::size_t i = 0; i < symtab_list_.size(); ++i)
            {
               if (!symtab_list_[i].valid())
                  continue;
               else
                  result = local_data(i)
                              .variable_store.get(variable_name);
 
               if (result) break;
            }
 
            return result;
         }

References local_data(), symtab_list_, valid(), valid_symbol(), and exprtk::symbol_table< T >::control_block::st_data::variable_store.

Here is the call graph for this function:

get_variable() [2/2]

template<typename T>

variable_ptr exprtk::parser< T >::symtab_store::get_variable ( const T & var_ref ) const

inline

Definition at line 23327 of file exprtk.hpp.

         {
            variable_ptr result = reinterpret_cast<variable_ptr>(0);
 
            for (std::size_t i = 0; i < symtab_list_.size(); ++i)
            {
               if (!symtab_list_[i].valid())
                  continue;
               else
                  result = local_data(i).variable_store
                              .get_from_varptr(reinterpret_cast<const void*>(&var_ref));
 
               if (result) break;
            }
 
            return result;
         }

References local_data(), symtab_list_, valid(), and exprtk::symbol_table< T >::control_block::st_data::variable_store.

Here is the call graph for this function:

get_variable_context()

template<typename T>

variable_context exprtk::parser< T >::symtab_store::get_variable_context ( const std::string & variable_name ) const

inline

Definition at line 23280 of file exprtk.hpp.

         {
            variable_context result;
 
            if (valid_symbol(variable_name))
            {
               for (std::size_t i = 0; i < symtab_list_.size(); ++i)
               {
                  if (!symtab_list_[i].valid())
                  {
                     continue;
                  }
 
                  result.variable = local_data(i)
                                       .variable_store.get(variable_name);
                  if (result.variable)
                  {
                     result.symbol_table = &symtab_list_[i];
                     break;
                  }
               }
            }
 
            return result;
         }

References local_data(), exprtk::parser< T >::symtab_store::variable_context::symbol_table, symtab_list_, valid(), valid_symbol(), exprtk::parser< T >::symtab_store::variable_context::variable, and exprtk::symbol_table< T >::control_block::st_data::variable_store.

Here is the call graph for this function:

get_variable_name()

template<typename T>

std::string exprtk::parser< T >::symtab_store::get_variable_name ( const expression_node_ptr & ptr ) const

inline

Definition at line 23712 of file exprtk.hpp.

         {
            return local_data().variable_store.entity_name(ptr);
         }

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

Here is the call graph for this function:

get_vector()

template<typename T>

vector_holder_ptr exprtk::parser< T >::symtab_store::get_vector ( const std::string & vector_name ) const

inline

Definition at line 23524 of file exprtk.hpp.

         {
            if (!valid_symbol(vector_name))
               return reinterpret_cast<vector_holder_ptr>(0);
 
            vector_holder_ptr result = reinterpret_cast<vector_holder_ptr>(0);
 
            for (std::size_t i = 0; i < symtab_list_.size(); ++i)
            {
               if (!symtab_list_[i].valid())
               {
                  continue;
               }
 
               result = local_data(i).vector_store.get(vector_name);
 
               if (result)
               {
                  break;
               }
            }
 
            return result;
         }

References local_data(), symtab_list_, valid(), valid_symbol(), and exprtk::symbol_table< T >::control_block::st_data::vector_store.

Here is the call graph for this function:

get_vector_context()

template<typename T>

vector_context exprtk::parser< T >::symtab_store::get_vector_context ( const std::string & vector_name ) const

inline

Definition at line 23499 of file exprtk.hpp.

         {
            vector_context result;
            if (!valid_symbol(vector_name))
               return result;
 
            for (std::size_t i = 0; i < symtab_list_.size(); ++i)
            {
               if (!symtab_list_[i].valid())
               {
                  continue;
               }
 
               result.vector_holder = local_data(i).vector_store.get(vector_name);
 
               if (result.vector_holder)
               {
                  result.symbol_table = &symtab_list_[i];
                  break;
               }
            }
 
            return result;
         }

References local_data(), exprtk::parser< T >::symtab_store::vector_context::symbol_table, symtab_list_, valid(), valid_symbol(), exprtk::parser< T >::symtab_store::vector_context::vector_holder, and exprtk::symbol_table< T >::control_block::st_data::vector_store.

Here is the call graph for this function:

get_vector_name()

template<typename T>

std::string exprtk::parser< T >::symtab_store::get_vector_name ( const vector_holder_ptr & ptr ) const

inline

Definition at line 23717 of file exprtk.hpp.

         {
            return local_data().vector_store.entity_name(ptr);
         }

References local_data(), and exprtk::symbol_table< T >::control_block::st_data::vector_store.

Here is the call graph for this function:

is_constant_node()

template<typename T>

bool exprtk::parser< T >::symtab_store::is_constant_node ( const std::string & symbol_name ) const

inline

Definition at line 23549 of file exprtk.hpp.

         {
            if (!valid_symbol(symbol_name))
               return false;
 
            for (std::size_t i = 0; i < symtab_list_.size(); ++i)
            {
               if (!symtab_list_[i].valid())
               {
                  continue;
               }
 
               if (local_data(i).variable_store.is_constant(symbol_name))
               {
                  return true;
               }
            }
 
            return false;
         }

References local_data(), symtab_list_, valid(), and valid_symbol().

Here is the call graph for this function:

is_constant_string()

template<typename T>

bool exprtk::parser< T >::symtab_store::is_constant_string ( const std::string & symbol_name ) const

inline

Definition at line 23571 of file exprtk.hpp.

         {
            if (!valid_symbol(symbol_name))
               return false;
 
            for (std::size_t i = 0; i < symtab_list_.size(); ++i)
            {
               if (!symtab_list_[i].valid())
                  continue;
               else if (!local_data(i).stringvar_store.symbol_exists(symbol_name))
                  continue;
               else if (local_data(i).stringvar_store.is_constant(symbol_name))
                  return true;
            }
 
            return false;
         }

References local_data(), symtab_list_, valid(), and valid_symbol().

Here is the call graph for this function:

is_conststr_stringvar()

template<typename T>

bool exprtk::parser< T >::symtab_store::is_conststr_stringvar ( const std::string & symbol_name ) const

inline

Definition at line 23641 of file exprtk.hpp.

         {
            for (std::size_t i = 0; i < symtab_list_.size(); ++i)
            {
               if (!symtab_list_[i].valid())
                  continue;
               else if (
                         symtab_list_[i].local_data().stringvar_store
                           .symbol_exists(symbol_name)
                       )
               {
                  return (
                           local_data(i).stringvar_store.symbol_exists(symbol_name) ||
                           local_data(i).stringvar_store.is_constant  (symbol_name)
                         );
 
               }
            }
 
            return false;
         }

References local_data(), symbol_exists(), symtab_list_, and valid().

Here is the call graph for this function:

is_function()

template<typename T>

bool exprtk::parser< T >::symtab_store::is_function ( const std::string & function_name ) const

inline

Definition at line 23664 of file exprtk.hpp.

         {
            for (std::size_t i = 0; i < symtab_list_.size(); ++i)
            {
               if (!symtab_list_[i].valid())
                  continue;
               else if (
                         local_data(i).vararg_function_store
                           .symbol_exists(function_name)
                       )
                  return true;
            }
 
            return false;
         }

References local_data(), symbol_exists(), symtab_list_, and valid().

Here is the call graph for this function:

is_stringvar()

template<typename T>

bool exprtk::parser< T >::symtab_store::is_stringvar ( const std::string & stringvar_name ) const

inline

Definition at line 23625 of file exprtk.hpp.

         {
            for (std::size_t i = 0; i < symtab_list_.size(); ++i)
            {
               if (!symtab_list_[i].valid())
                  continue;
               else if (
                         symtab_list_[i].local_data().stringvar_store
                           .symbol_exists(stringvar_name)
                       )
                  return true;
            }
 
            return false;
         }

References local_data(), symbol_exists(), symtab_list_, and valid().

Here is the call graph for this function:

is_vararg_function()

template<typename T>

bool exprtk::parser< T >::symtab_store::is_vararg_function ( const std::string & vararg_function_name ) const

inline

Definition at line 23680 of file exprtk.hpp.

         {
            for (std::size_t i = 0; i < symtab_list_.size(); ++i)
            {
               if (!symtab_list_[i].valid())
                  continue;
               else if (
                         local_data(i).vararg_function_store
                           .symbol_exists(vararg_function_name)
                       )
                  return true;
            }
 
            return false;
         }

References local_data(), symbol_exists(), symtab_list_, and valid().

Here is the call graph for this function:

is_variable()

template<typename T>

bool exprtk::parser< T >::symtab_store::is_variable ( const std::string & variable_name ) const

inline

Definition at line 23608 of file exprtk.hpp.

         {
            for (std::size_t i = 0; i < symtab_list_.size(); ++i)
            {
               if (!symtab_list_[i].valid())
                  continue;
               else if (
                         symtab_list_[i].local_data().variable_store
                           .symbol_exists(variable_name)
                       )
                  return true;
            }
 
            return false;
         }

References local_data(), symbol_exists(), symtab_list_, and valid().

Here is the call graph for this function:

is_vector()

template<typename T>

bool exprtk::parser< T >::symtab_store::is_vector ( const std::string & vector_name ) const

inline

Definition at line 23696 of file exprtk.hpp.

         {
            for (std::size_t i = 0; i < symtab_list_.size(); ++i)
            {
               if (!symtab_list_[i].valid())
                  continue;
               else if (
                         local_data(i).vector_store
                           .symbol_exists(vector_name)
                       )
                  return true;
            }
 
            return false;
         }

References local_data(), symbol_exists(), symtab_list_, and valid().

Here is the call graph for this function:

local_data() [1/2]

template<typename T>

local_data_t & exprtk::parser< T >::symtab_store::local_data ( const std::size_t & index = 0 )

inline

Definition at line 23734 of file exprtk.hpp.

         {
            return symtab_list_[index].local_data();
         }

References symtab_list_.

Referenced by get_conststr_stringvar_name(), get_function(), get_generic_function(), get_overload_function(), get_string_context(), get_string_function(), get_stringvar(), get_stringvar_name(), get_vararg_function(), get_variable(), get_variable(), get_variable_context(), get_variable_name(), get_vector(), get_vector_context(), get_vector_name(), is_constant_node(), is_constant_string(), is_conststr_stringvar(), is_function(), is_stringvar(), is_vararg_function(), is_variable(), and is_vector().

Here is the caller graph for this function:

local_data() [2/2]

template<typename T>

const local_data_t & exprtk::parser< T >::symtab_store::local_data ( const std::size_t & index = 0 ) const

inline

Definition at line 23739 of file exprtk.hpp.

         {
            return symtab_list_[index].local_data();
         }

References symtab_list_.

symbol_exists()

template<typename T>

bool exprtk::parser< T >::symtab_store::symbol_exists ( const std::string & symbol ) const

inline

Definition at line 23590 of file exprtk.hpp.

         {
            for (std::size_t i = 0; i < symtab_list_.size(); ++i)
            {
               if (!symtab_list_[i].valid())
               {
                  continue;
               }
 
               if (symtab_list_[i].symbol_exists(symbol))
               {
                  return true;
               }
            }
 
            return false;
         }

References symbol_exists(), symtab_list_, and valid().

Referenced by is_conststr_stringvar(), is_function(), is_stringvar(), is_vararg_function(), is_variable(), is_vector(), and symbol_exists().

Here is the call graph for this function:

Here is the caller graph for this function:

valid()

template<typename T>

bool exprtk::parser< T >::symtab_store::valid ( ) const

inline

Definition at line 23250 of file exprtk.hpp.

         {
            if (!empty())
            {
               for (std::size_t i = 0; i < symtab_list_.size(); ++i)
               {
                  if (symtab_list_[i].valid())
                     return true;
               }
            }
 
            return false;
         }

References empty(), symtab_list_, and valid().

Referenced by get_function(), get_generic_function(), get_overload_function(), get_string_context(), get_string_function(), get_stringvar(), get_vararg_function(), get_variable(), get_variable(), get_variable_context(), get_vector(), get_vector_context(), is_constant_node(), is_constant_string(), is_conststr_stringvar(), is_function(), is_stringvar(), is_vararg_function(), is_variable(), is_vector(), symbol_exists(), and valid().

Here is the call graph for this function:

Here is the caller graph for this function:

valid_function_name()

template<typename T>

bool exprtk::parser< T >::symtab_store::valid_function_name ( const std::string & symbol ) const

inline

Definition at line 23272 of file exprtk.hpp.

         {
            if (!symtab_list_.empty())
               return symtab_list_[0].valid_function(symbol);
            else
               return false;
         }

References symtab_list_.

Referenced by get_function(), get_generic_function(), get_overload_function(), get_string_function(), and get_vararg_function().

Here is the caller graph for this function:

valid_symbol()

template<typename T>

bool exprtk::parser< T >::symtab_store::valid_symbol ( const std::string & symbol ) const

inline

Definition at line 23264 of file exprtk.hpp.

         {
            if (!symtab_list_.empty())
               return symtab_list_[0].valid_symbol(symbol);
            else
               return false;
         }

References symtab_list_.

Referenced by get_string_context(), get_stringvar(), get_variable(), get_variable_context(), get_vector(), get_vector_context(), is_constant_node(), and is_constant_string().

Here is the caller graph for this function:

Member Data Documentation

symtab_list_

template<typename T>

symbol_table_list_t exprtk::parser< T >::symtab_store::symtab_list_

Definition at line 23193 of file exprtk.hpp.

Referenced by clear(), empty(), get_function(), get_generic_function(), get_overload_function(), get_string_context(), get_string_function(), get_stringvar(), get_symbol_table(), get_vararg_function(), get_variable(), get_variable(), get_variable_context(), get_vector(), get_vector_context(), is_constant_node(), is_constant_string(), is_conststr_stringvar(), is_function(), is_stringvar(), is_vararg_function(), is_variable(), is_vector(), local_data(), local_data(), symbol_exists(), valid(), valid_function_name(), and valid_symbol().

---

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

• exprtk/exprtk.hpp