GranOO  3.0
A robust and versatile workbench to build 3D dynamic simulations based on the Discrete Element Method
Classes | Public Types | Public Member Functions | Private Types | Private Member Functions | Static Private Member Functions | Private Attributes | List of all members
exprtk::function_compositor< T > Class Template Reference

#include <Exprtk.hpp>

Classes

struct  base_func
 
struct  func_0param
 
struct  func_1param
 
struct  func_2param
 
struct  func_3param
 
struct  func_4param
 
struct  func_5param
 
struct  func_6param
 
struct  function
 
struct  scoped_bft
 

Public Types

typedef exprtk::expression< T > expression_t
 
typedef exprtk::symbol_table< T > symbol_table_t
 
typedef exprtk::parser< T > parser_t
 
typedef parser_t::settings_store settings_t
 

Public Member Functions

 function_compositor ()
 
 function_compositor (const symbol_table_t &st)
 
 ~function_compositor ()
 
symbol_table_t & symbol_table ()
 
const symbol_table_t & symbol_table () const
 
void add_auxiliary_symtab (symbol_table_t &symtab)
 
void load_variables (const bool load=true)
 
void load_vectors (const bool load=true)
 
void clear ()
 
bool add (const function &f, const bool override=false)
 
std::string error () const
 
std::size_t error_count () const
 
parser_error::type get_error (const std::size_t &index) const
 

Private Types

typedef std::map< std::string, base_func * > funcparam_t
 
typedef const T & type
 

Private Member Functions

 def_fp_retval (0) def_fp_retval(1) def_fp_retval(2) def_fp_retval(3) def_fp_retval(4) def_fp_retval(5) def_fp_retval(6) template< typename Allocator
 
template<typename , typename >
class Sequence inline bool add (const std::string &name, const std::string &expression, const Sequence< std::string, Allocator > &var_list, const bool override=false)
 
template<typename Allocator , template< typename, typename > class Sequence>
bool compile_expression (const std::string &name, const std::string &expression, const Sequence< std::string, Allocator > &input_var_list, bool return_present=false)
 
bool symbol_used (const std::string &symbol) const
 
bool valid (const std::string &name, const std::size_t &arg_count) const
 
bool forward (const std::string &name, const std::size_t &arg_count, symbol_table_t &sym_table, const bool ret_present=false)
 
void remove (const std::string &name, const std::size_t &arg_count)
 

Static Private Member Functions

static T return_value (expression_t &e)
 

Private Attributes

symbol_table_t symbol_table_
 
parser_t parser_
 
std::map< std::string, expression_t > expr_map_
 
std::vector< funcparam_t > fp_map_
 
std::vector< symbol_table_t * > auxiliary_symtab_list_
 
std::deque< parser_error::type > error_list_
 
bool load_variables_
 
bool load_vectors_
 

Member Typedef Documentation

◆ expression_t

template<typename T >
typedef exprtk::expression<T> exprtk::function_compositor< T >::expression_t

◆ funcparam_t

template<typename T >
typedef std::map<std::string,base_func*> exprtk::function_compositor< T >::funcparam_t
private

◆ parser_t

template<typename T >
typedef exprtk::parser<T> exprtk::function_compositor< T >::parser_t

◆ settings_t

template<typename T >
typedef parser_t::settings_store exprtk::function_compositor< T >::settings_t

◆ symbol_table_t

template<typename T >
typedef exprtk::symbol_table<T> exprtk::function_compositor< T >::symbol_table_t

◆ type

template<typename T >
typedef const T& exprtk::function_compositor< T >::type
private

Constructor & Destructor Documentation

◆ function_compositor() [1/2]

template<typename T >
exprtk::function_compositor< T >::function_compositor ( )
inline

◆ function_compositor() [2/2]

template<typename T >
exprtk::function_compositor< T >::function_compositor ( const symbol_table_t &  st)
inlineexplicit

◆ ~function_compositor()

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

Member Function Documentation

◆ add() [1/2]

template<typename T >
bool exprtk::function_compositor< T >::add ( const function &  f,
const bool  override = false 
)
inline

◆ add() [2/2]

template<typename T >
template<typename , typename >
class Sequence inline bool exprtk::function_compositor< T >::add ( const std::string &  name,
const std::string &  expression,
const Sequence< std::string, Allocator > &  var_list,
const bool  override = false 
)
inlineprivate

◆ add_auxiliary_symtab()

template<typename T >
void exprtk::function_compositor< T >::add_auxiliary_symtab ( symbol_table_t &  symtab)
inline

◆ clear()

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

◆ compile_expression()

template<typename T >
template<typename Allocator , template< typename, typename > class Sequence>
bool exprtk::function_compositor< T >::compile_expression ( const std::string &  name,
const std::string &  expression,
const Sequence< std::string, Allocator > &  input_var_list,
bool  return_present = false 
)
inlineprivate

◆ def_fp_retval()

template<typename T >
exprtk::function_compositor< T >::def_fp_retval ( 0  )
private

◆ error()

template<typename T >
std::string exprtk::function_compositor< T >::error ( ) const
inline

◆ error_count()

template<typename T >
std::size_t exprtk::function_compositor< T >::error_count ( ) const
inline

◆ forward()

template<typename T >
bool exprtk::function_compositor< T >::forward ( const std::string &  name,
const std::size_t &  arg_count,
symbol_table_t &  sym_table,
const bool  ret_present = false 
)
inlineprivate

◆ get_error()

template<typename T >
parser_error::type exprtk::function_compositor< T >::get_error ( const std::size_t &  index) const
inline

◆ load_variables()

template<typename T >
void exprtk::function_compositor< T >::load_variables ( const bool  load = true)
inline

◆ load_vectors()

template<typename T >
void exprtk::function_compositor< T >::load_vectors ( const bool  load = true)
inline

◆ remove()

template<typename T >
void exprtk::function_compositor< T >::remove ( const std::string &  name,
const std::size_t &  arg_count 
)
inlineprivate

◆ return_value()

template<typename T >
static T exprtk::function_compositor< T >::return_value ( expression_t &  e)
inlinestaticprivate

◆ symbol_table() [1/2]

template<typename T >
symbol_table_t& exprtk::function_compositor< T >::symbol_table ( )
inline

◆ symbol_table() [2/2]

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

◆ symbol_used()

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

◆ valid()

template<typename T >
bool exprtk::function_compositor< T >::valid ( const std::string &  name,
const std::size_t &  arg_count 
) const
inlineprivate

Member Data Documentation

◆ auxiliary_symtab_list_

template<typename T >
std::vector<symbol_table_t*> exprtk::function_compositor< T >::auxiliary_symtab_list_
private

◆ error_list_

template<typename T >
std::deque<parser_error::type> exprtk::function_compositor< T >::error_list_
private

◆ expr_map_

template<typename T >
std::map<std::string,expression_t> exprtk::function_compositor< T >::expr_map_
private

◆ fp_map_

template<typename T >
std::vector<funcparam_t> exprtk::function_compositor< T >::fp_map_
private

◆ load_variables_

template<typename T >
bool exprtk::function_compositor< T >::load_variables_
private

◆ load_vectors_

template<typename T >
bool exprtk::function_compositor< T >::load_vectors_
private

◆ parser_

template<typename T >
parser_t exprtk::function_compositor< T >::parser_
private

◆ symbol_table_

template<typename T >
symbol_table_t exprtk::function_compositor< T >::symbol_table_
private
The documentation for this class was generated from the following file:
Generated on Wed May 14 2025 01:00:27 for GranOO by doxygen 1.9.1