exprtk::parser< T >::scope_element_manager Class Reference

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

Public Types
typedef expression_node_t *	expression_node_ptr
typedef variable_node_t *	variable_node_ptr
typedef parser< T >	parser_t

Public Member Functions
	scope_element_manager (parser< T > &p)
std::size_t	size () const
bool	empty () const
scope_element &	get_element (const std::size_t &index)
scope_element &	get_element (const std::string &var_name, const std::size_t index=std::numeric_limits< std::size_t >::max())
scope_element &	get_active_element (const std::string &var_name, const std::size_t index=std::numeric_limits< std::size_t >::max())
bool	add_element (const scope_element &se)
void	deactivate (const std::size_t &scope_depth)
void	free_element (scope_element &se)
void	cleanup ()
std::size_t	total_local_symb_size_bytes () const
std::size_t	next_ip_index ()
expression_node_ptr	get_variable (const T &v)
std::string	get_vector_name (const T *data)

Private Member Functions
	scope_element_manager (const scope_element_manager &)
scope_element_manager &	operator= (const scope_element_manager &)

Private Attributes
parser_t &	parser_
std::vector< scope_element >	element_
scope_element	null_element_
std::size_t	input_param_cnt_
std::size_t	total_local_symb_size_bytes_

Detailed Description

template<typename T>
class exprtk::parser< T >::scope_element_manager

Definition at line 22745 of file exprtk.hpp.

Member Typedef Documentation

expression_node_ptr

template<typename T>

typedef expression_node_t* exprtk::parser< T >::scope_element_manager::expression_node_ptr

Definition at line 22749 of file exprtk.hpp.

parser_t

template<typename T>

typedef parser<T> exprtk::parser< T >::scope_element_manager::parser_t

Definition at line 22751 of file exprtk.hpp.

variable_node_ptr

template<typename T>

typedef variable_node_t* exprtk::parser< T >::scope_element_manager::variable_node_ptr

Definition at line 22750 of file exprtk.hpp.

Constructor & Destructor Documentation

scope_element_manager() [1/2]

template<typename T>

exprtk::parser< T >::scope_element_manager::scope_element_manager ( parser< T > & p )

inlineexplicit

Definition at line 22753 of file exprtk.hpp.

         : parser_(p)
         , input_param_cnt_(0)
         , total_local_symb_size_bytes_(0)
         {}

References input_param_cnt_, exprtk::parser< T >::parser(), parser_, and total_local_symb_size_bytes_.

Referenced by operator=(), and scope_element_manager().

Here is the call graph for this function:

Here is the caller graph for this function:

scope_element_manager() [2/2]

template<typename T>

exprtk::parser< T >::scope_element_manager::scope_element_manager ( const scope_element_manager & )

private

References exprtk_delete, and scope_element_manager().

Here is the call graph for this function:

Member Function Documentation

add_element()

template<typename T>

bool exprtk::parser< T >::scope_element_manager::add_element ( const scope_element & se )

inline

Definition at line 22820 of file exprtk.hpp.

         {
            for (std::size_t i = 0; i < element_.size(); ++i)
            {
               scope_element& cse = element_[i];
 
               if (
                    details::imatch(cse.name, se.name) &&
                    (cse.depth <= se.depth)            &&
                    (cse.index == se.index)            &&
                    (cse.size  == se.size )            &&
                    (cse.type  == se.type )            &&
                    (cse.active)
                  )
                  return false;
            }
 
            switch (se.type)
            {
               case scope_element::e_variable : total_local_symb_size_bytes_ += sizeof(T);
                                                break;
 
               case scope_element::e_literal  : total_local_symb_size_bytes_ += sizeof(T);
                                                break;
 
               case scope_element::e_vector   : total_local_symb_size_bytes_ += sizeof(T) * se.size;
                                                break;
 
               default                        : break;
            }
 
            element_.push_back(se);
            std::sort(element_.begin(),element_.end());
 
            return true;
         }

References exprtk::parser< T >::scope_element::active, exprtk::parser< T >::scope_element::depth, exprtk::parser< T >::scope_element::e_literal, exprtk::parser< T >::scope_element::e_variable, exprtk::parser< T >::scope_element::e_vector, element_, exprtk::details::imatch(), exprtk::parser< T >::scope_element::index, exprtk::parser< T >::scope_element::name, exprtk::parser< T >::scope_element::size, total_local_symb_size_bytes_, and exprtk::parser< T >::scope_element::type.

Here is the call graph for this function:

cleanup()

template<typename T>

void exprtk::parser< T >::scope_element_manager::cleanup ( )

inline

Definition at line 22910 of file exprtk.hpp.

         {
            for (std::size_t i = 0; i < element_.size(); ++i)
            {
               free_element(element_[i]);
            }
 
            element_.clear();
 
            input_param_cnt_             = 0;
            total_local_symb_size_bytes_ = 0;
         }

References element_, free_element(), input_param_cnt_, and total_local_symb_size_bytes_.

Here is the call graph for this function:

deactivate()

template<typename T>

void exprtk::parser< T >::scope_element_manager::deactivate ( const std::size_t & scope_depth )

inline

Definition at line 22857 of file exprtk.hpp.

         {
            exprtk_debug(("deactivate() - Scope depth: %d\n",
                          static_cast<int>(parser_.state_.scope_depth)));
 
            for (std::size_t i = 0; i < element_.size(); ++i)
            {
               scope_element& se = element_[i];
 
               if (se.active && (se.depth >= scope_depth))
               {
                  exprtk_debug(("deactivate() - element[%02d] '%s'\n",
                                static_cast<int>(i),
                                se.name.c_str()));
 
                  se.active = false;
               }
            }
         }

References exprtk::parser< T >::scope_element::active, exprtk::parser< T >::scope_element::depth, element_, exprtk_debug, exprtk::parser< T >::scope_element::name, and parser_.

empty()

template<typename T>

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

inline

Definition at line 22764 of file exprtk.hpp.

         {
            return element_.empty();
         }

References element_.

free_element()

template<typename T>

void exprtk::parser< T >::scope_element_manager::free_element ( scope_element & se )

inline

Definition at line 22877 of file exprtk.hpp.

         {
            exprtk_debug(("free_element() - se[%s]\n", se.name.c_str()));
 
            switch (se.type)
            {
               case scope_element::e_literal    : delete reinterpret_cast<T*>(se.data);
                                                  delete se.var_node;
                                                  break;
 
               case scope_element::e_variable   : delete reinterpret_cast<T*>(se.data);
                                                  delete se.var_node;
                                                  break;
 
               case scope_element::e_vector     : delete[] reinterpret_cast<T*>(se.data);
                                                  delete se.vec_node;
                                                  break;
 
               case scope_element::e_vecelem    : delete se.var_node;
                                                  break;
 
               #ifndef exprtk_disable_string_capabilities
               case scope_element::e_string     : delete reinterpret_cast<std::string*>(se.data);
                                                  delete se.str_node;
                                                  break;
               #endif
 
               default                          : return;
            }
 
            se.clear();
         }

References exprtk::parser< T >::scope_element::clear(), exprtk::parser< T >::scope_element::data, exprtk::parser< T >::scope_element::e_literal, exprtk::parser< T >::scope_element::e_string, exprtk::parser< T >::scope_element::e_variable, exprtk::parser< T >::scope_element::e_vecelem, exprtk::parser< T >::scope_element::e_vector, exprtk_debug, exprtk::parser< T >::scope_element::name, exprtk::parser< T >::scope_element::str_node, exprtk::parser< T >::scope_element::type, exprtk::parser< T >::scope_element::var_node, and exprtk::parser< T >::scope_element::vec_node.

Referenced by cleanup().

Here is the call graph for this function:

Here is the caller graph for this function:

get_active_element()

template<typename T>

scope_element & exprtk::parser< T >::scope_element_manager::get_active_element ( const std::string & var_name, const std::size_t index = std::numeric_limits<std::size_t>::max() )

inline

Definition at line 22798 of file exprtk.hpp.

         {
            const std::size_t current_depth = parser_.state_.scope_depth;
 
            for (std::size_t i = 0; i < element_.size(); ++i)
            {
               scope_element& se = element_[i];
 
               if (se.depth > current_depth)
                  continue;
               else if (
                         details::imatch(se.name, var_name) &&
                         (se.index == index)                &&
                         (se.active)
                       )
                  return se;
            }
 
            return null_element_;
         }

References exprtk::parser< T >::scope_element::active, exprtk::parser< T >::scope_element::depth, element_, exprtk::details::imatch(), exprtk::parser< T >::scope_element::index, exprtk::parser< T >::scope_element::name, null_element_, and parser_.

Here is the call graph for this function:

get_element() [1/2]

template<typename T>

scope_element & exprtk::parser< T >::scope_element_manager::get_element ( const std::size_t & index )

inline

Definition at line 22769 of file exprtk.hpp.

         {
            if (index < element_.size())
               return element_[index];
            else
               return null_element_;
         }

References element_, and null_element_.

get_element() [2/2]

template<typename T>

scope_element & exprtk::parser< T >::scope_element_manager::get_element ( const std::string & var_name, const std::size_t index = std::numeric_limits<std::size_t>::max() )

inline

Definition at line 22777 of file exprtk.hpp.

         {
            const std::size_t current_depth = parser_.state_.scope_depth;
 
            for (std::size_t i = 0; i < element_.size(); ++i)
            {
               scope_element& se = element_[i];
 
               if (se.depth > current_depth)
                  continue;
               else if (
                         details::imatch(se.name, var_name) &&
                         (se.index == index)
                       )
                  return se;
            }
 
            return null_element_;
         }

References exprtk::parser< T >::scope_element::depth, element_, exprtk::details::imatch(), exprtk::parser< T >::scope_element::index, exprtk::parser< T >::scope_element::name, null_element_, and parser_.

Here is the call graph for this function:

get_variable()

template<typename T>

expression_node_ptr exprtk::parser< T >::scope_element_manager::get_variable ( const T & v )

inline

Definition at line 22933 of file exprtk.hpp.

         {
            for (std::size_t i = 0; i < element_.size(); ++i)
            {
               scope_element& se = element_[i];
 
               if (
                    se.active   &&
                    se.var_node &&
                    details::is_variable_node(se.var_node)
                  )
               {
                  variable_node_ptr vn = reinterpret_cast<variable_node_ptr>(se.var_node);
 
                  if (&(vn->ref()) == (&v))
                  {
                     return se.var_node;
                  }
               }
            }
 
            return expression_node_ptr(0);
         }

References exprtk::parser< T >::scope_element::active, element_, exprtk::details::is_variable_node(), exprtk::details::variable_node< T >::ref(), and exprtk::parser< T >::scope_element::var_node.

Here is the call graph for this function:

get_vector_name()

template<typename T>

std::string exprtk::parser< T >::scope_element_manager::get_vector_name ( const T * data )

inline

Definition at line 22957 of file exprtk.hpp.

         {
            for (std::size_t i = 0; i < element_.size(); ++i)
            {
               scope_element& se = element_[i];
 
               if (
                    se.active   &&
                    se.vec_node &&
                    (se.vec_node->data() == data)
                  )
               {
                  return se.name;
               }
            }
 
            return "neo-vector";
         }

References exprtk::parser< T >::scope_element::active, exprtk::details::vector_holder< Type >::data(), element_, exprtk::parser< T >::scope_element::name, and exprtk::parser< T >::scope_element::vec_node.

Here is the call graph for this function:

next_ip_index()

template<typename T>

std::size_t exprtk::parser< T >::scope_element_manager::next_ip_index ( )

inline

Definition at line 22928 of file exprtk.hpp.

         {
            return ++input_param_cnt_;
         }

References input_param_cnt_.

operator=()

template<typename T>

scope_element_manager & exprtk::parser< T >::scope_element_manager::operator= ( const scope_element_manager & )

private

References exprtk_delete, and scope_element_manager().

Here is the call graph for this function:

size()

template<typename T>

std::size_t exprtk::parser< T >::scope_element_manager::size ( ) const

inline

Definition at line 22759 of file exprtk.hpp.

         {
            return element_.size();
         }

References element_.

total_local_symb_size_bytes()

template<typename T>

std::size_t exprtk::parser< T >::scope_element_manager::total_local_symb_size_bytes ( ) const

inline

Definition at line 22923 of file exprtk.hpp.

         {
            return total_local_symb_size_bytes_;
         }

References total_local_symb_size_bytes_.

Member Data Documentation

element_

template<typename T>

std::vector<scope_element> exprtk::parser< T >::scope_element_manager::element_

private

Definition at line 22982 of file exprtk.hpp.

Referenced by add_element(), cleanup(), deactivate(), empty(), get_active_element(), get_element(), get_element(), get_variable(), get_vector_name(), and size().

input_param_cnt_

template<typename T>

std::size_t exprtk::parser< T >::scope_element_manager::input_param_cnt_

private

Definition at line 22984 of file exprtk.hpp.

Referenced by cleanup(), next_ip_index(), and scope_element_manager().

null_element_

template<typename T>

scope_element exprtk::parser< T >::scope_element_manager::null_element_

private

Definition at line 22983 of file exprtk.hpp.

Referenced by get_active_element(), get_element(), and get_element().

parser_

template<typename T>

parser_t& exprtk::parser< T >::scope_element_manager::parser_

private

Definition at line 22981 of file exprtk.hpp.

Referenced by deactivate(), get_active_element(), get_element(), and scope_element_manager().

total_local_symb_size_bytes_

template<typename T>

std::size_t exprtk::parser< T >::scope_element_manager::total_local_symb_size_bytes_

private

Definition at line 22985 of file exprtk.hpp.

Referenced by add_element(), cleanup(), scope_element_manager(), and total_local_symb_size_bytes().

---

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

• exprtk/exprtk.hpp