exprtk_groups_examples.cpp File Reference

#include <algorithm>
#include <cassert>
#include <chrono>
#include <cstdio>
#include <iterator>
#include <map>
#include <set>
#include <string>
#include "exprtk.hpp"

Include dependency graph for exprtk_groups_examples.cpp:

Go to the source code of this file.

Classes
struct	groups_impl::groups_collection< T >
class	groups_impl::create< T >
class	groups_impl::add< T >
class	groups_impl::contains< T >
class	groups_impl::size< T >
class	groups_impl::get< T >
class	groups_impl::erase< T >

Namespaces
namespace	groups_impl

Functions
template<typename SetType , typename T >
SetType *	groups_impl::make_set_handle (T v)
template<typename T >
void	groups_example ()
int	main ()

Function Documentation

groups_example()

template<typename T >

void groups_example

(

)

Definition at line 343 of file exprtk_groups_examples.cpp.

{
   using symbol_table_t = exprtk::symbol_table<T>;
   using expression_t   = exprtk::expression<T>;
   using parser_t       = exprtk::parser<T>;
 
   using strset_t = std::set<std::string>;
 
   strset_t girl_names;
   strset_t boy_names;
 
   girl_names.insert("jane");
   girl_names.insert("jill");
 
   boy_names.insert("jack");
   boy_names.insert("jim" );
   boy_names.insert("john");
 
   groups_impl::groups_collection<std::string> names_groups;
 
   names_groups.add_group("girls", girl_names);
   names_groups.add_group("boys",  boy_names );
 
   assert(names_groups.contains("girls"));
   assert(names_groups.contains("boys" ));
 
   groups_impl::create  <T> group_create  (names_groups);
   groups_impl::add     <T> group_add     (names_groups);
   groups_impl::contains<T> group_contains(names_groups);
   groups_impl::size    <T> group_size    (names_groups);
   groups_impl::get     <T> group_get     (names_groups);
   groups_impl::erase   <T> group_erase   (names_groups);
 
   exprtk::rtl::io::println<T> println;
 
   symbol_table_t symbol_table;
   expression_t   expression;
   parser_t       parser;
 
   symbol_table.add_function("create"  , group_create  );
   symbol_table.add_function("add"     , group_add     );
   symbol_table.add_function("contains", group_contains);
   symbol_table.add_function("size"    , group_size    );
   symbol_table.add_function("get"     , group_get     );
   symbol_table.add_function("erase"   , group_erase   );
   symbol_table.add_function("println" , println       );
 
   expression.register_symbol_table(symbol_table);
 
   const std::string program =
      " /* Load the groups from symbol table */         "
      " var girls := create('girls');                   "
      " var boys  := create('boys' );                   "
      "                                                 "
      " if (not(girls))                                 "
      " {                                               "
      "    println('failed to create girls set!');      "
      "    return [];                                   "
      " };                                              "
      "                                                 "
      " if (not(boys))                                  "
      " {                                               "
      "    println('failed to create boys set!');       "
      "    return [];                                   "
      " };                                              "
      "                                                 "
      " var name := 'john';                             "
      "                                                 "
      " if (contains(girls, name))                      "
      " {                                               "
      "    println(name, ' in girls set');              "
      " }                                               "
      " else                                            "
      " {                                               "
      "    println(name, ' NOT in girls set');          "
      " };                                              "
      "                                                 "
      " if (contains(boys, name))                       "
      " {                                               "
      "    println(name, ' in boys set');               "
      " }                                               "
      " else                                            "
      " {                                               "
      "    println(name, ' NOT in boys set');           "
      " };                                              "
      "                                                 "
      " /* Create a group from scratch */               "
      " var pets := create('pets');                     "
      "                                                 "
      " add(pets, 'buddy');                             "
      " add(pets, 'fluffy', 'snowy');                   "
      " add(pets, 'ziggy', 'monty', 'teddy');           "
      "                                                 "
      " if (contains(pets, name))                       "
      " {                                               "
      "    println(name, ' in pets set');               "
      " }                                               "
      " else                                            "
      " {                                               "
      "    println(name, ' NOT in pets set');           "
      " };                                              "
      "                                                 "
      " if (contains(pets, name, 'fluffy'))             "
      " {                                               "
      "    println(name, ' or fluffy in pets set');     "
      " }                                               "
      " else                                            "
      " {                                               "
      "    println(name, ' or fluffy NOT in pets set'); "
      " };                                              "
      "                                                 "
      " println('List of \\'pets\\':');                 "
      "                                                 "
      " for (var i := 0; i < size(pets); i += 1)        "
      " {                                               "
      "    println('[', i ,']: ', get(pets,i));         "
      " };                                              "
      "                                                 "
      " if (erase(pets, 'fluffy', 'teddy') != 2)        "
      " {                                               "
      "    println('Failed to erase fluffy and teddy'); "
      "    return [];                                   "
      " };                                              "
      "                                                 "
      " println('List of \\'pets\\':');                 "
      "                                                 "
      " for (var i := 0; i < size(pets); i += 1)        "
      " {                                               "
      "    println('[', i ,']: ', get(pets,i));         "
      " };                                              "
      "                                                 ";
 
   if (!parser.compile(program, expression))
   {
      printf("Error: %s\tExpression: %s\n",
             parser.error().c_str(),
             program.c_str());
      return;
   }
 
   expression.value();
 
   // Benchmark
   //{
   //   constexpr auto rounds = 100000;
   //
   //   const auto begin = std::chrono::system_clock::now();
   //   {
   //      for (std::size_t i = 0; i < rounds; ++i)
   //      {
   //         expression.value();
   //      }
   //   }
   //   const auto end = std::chrono::system_clock::now();
   //
   //   const auto total_time_ms = std::chrono::duration_cast<std::chrono::milliseconds>(end - begin).count();
   //
   //   printf("[*] total time: %5.4fsec rate: %8.4feval/sec\n",
   //          total_time_ms / 1000.0,
   //          (1000.0 * rounds) / total_time_ms);
   //}
}

References groups_impl::groups_collection< T >::add_group(), and groups_impl::groups_collection< T >::contains().

Here is the call graph for this function:

main()

int main

(

)

Definition at line 506 of file exprtk_groups_examples.cpp.

{
   groups_example<double>();
   return 0;
}