schedule Namespace Reference

Hide all the global stuff in this namespace. More...

Classes
struct	add_step
	Semantic action for parser. More...
struct	add_time
	Semantic action for parser. More...
struct	next_settings
	Semantic action for parser. More...
class	Schedule
	Wrap up the parsing process and the operation of a schedule in a single class. More...
struct	schedule_grammar
struct	set_step
	Semantic action for parser. More...
struct	set_value
	Semantic action for parser. More...

Enumerations
enum class	schedule_step {   reorder , all_start , pos_neg_start , conjecture_start ,   restrict_start , no_regularity , no_lemmata , all_lemmata ,   all_reductions , all_extensions , all_backtrack , lemmata_backtrack ,   reduction_backtrack , extension_backtrack , explore_left_trees , hard_prune ,   complete }
	Possible kinds of schedule step. More...

Functions
string	to_string (const schedule_step &s)
ostream &	operator<< (ostream &out, const Schedule &s)

Variables
unsigned int	value = 0
unsigned int	current_time = 0
string	step
vector< pair< schedule_step, unsigned int > >	current_settings
vector< vector< pair< schedule_step, unsigned int > > >	new_schedule
vector< unsigned int >	new_times
qi::rule< Iter, string()>	schedule_word
qi::rule< Iter, string()>	schedule_word_param

Detailed Description

Hide all the global stuff in this namespace.

It's easiest to implement a parser using the relevant boost libraries if you use globals to store things as you parse. Hiding them in a namespace makes the use of globals a bit less reprehensible.

Enumeration Type Documentation

schedule_step

enum class schedule::schedule_step

strong

Possible kinds of schedule step.

Definition at line 62 of file Schedule.hpp.

                         {
  reorder,
  all_start,
  pos_neg_start,
  conjecture_start,
  restrict_start,
  no_regularity,
  no_lemmata,
  all_lemmata,
  all_reductions,
  all_extensions,
  all_backtrack,
  lemmata_backtrack,
  reduction_backtrack,
  extension_backtrack,
  explore_left_trees,
  hard_prune,
  complete
};

Function Documentation

operator<<()

ostream & schedule::operator<<	(	ostream &	out,
		const Schedule &	s
	)

Definition at line 333 of file Schedule.cpp.

                                                      {
    for (size_t i = 0; i < s.schedule.size(); i++) {
        out << s.step_to_string(i) << endl;
    }
    return out;
 }

to_string()

string schedule::to_string

(

const schedule_step &

s

)

Definition at line 30 of file Schedule.cpp.

                                         {
    switch (s) {
        case schedule_step::reorder:
            return string("--reorder");
            break;
        case schedule_step::all_start:
            return string("--all-start");
            break;
        case schedule_step::pos_neg_start:
            return string("--pos-neg-start");
            break;
        case schedule_step::conjecture_start:
            return string("--conjecture-start");
            break;
        case schedule_step::restrict_start:
            return string("--restrict-start");
            break;
        case schedule_step::no_regularity:
            return string("--no-regularity");
            break;
        case schedule_step::no_lemmata:
            return string("--no-lemmata");
            break;
        case schedule_step::all_lemmata:
            return string("--all-lemmata");
            break;
        case schedule_step::all_reductions:
            return string("--all-reductions");
            break;
        case schedule_step::all_extensions:
            return string("--all-extensions");
            break;
        case schedule_step::all_backtrack:
            return string("--all-backtrack");
            break;
        case schedule_step::lemmata_backtrack:
            return string("--lemmata-backtrack");
            break;
        case schedule_step::reduction_backtrack:
            return string("--reduction-backtrack");
            break;
        case schedule_step::extension_backtrack:
            return string("--extension-backtrack");
            break;
        case schedule_step::explore_left_trees:
            return string("--explore-left-trees");
            break;
        case schedule_step::hard_prune:
            return string("--hard-prune");
            break;
        case schedule_step::complete:
            return string("--complete");
            break;
        default:
            break;
    }
    return string("");
}

Variable Documentation

current_settings

vector<pair<schedule_step, unsigned int> > schedule::current_settings

Definition at line 94 of file Schedule.cpp.

current_time

unsigned int schedule::current_time = 0

Definition at line 92 of file Schedule.cpp.

new_schedule

vector<vector<pair<schedule_step, unsigned int> > > schedule::new_schedule

Definition at line 95 of file Schedule.cpp.

new_times

vector<unsigned int> schedule::new_times

Definition at line 96 of file Schedule.cpp.

schedule_word

qi::rule<Iter, string()> schedule::schedule_word

Initial value:

=
    ascii::string("--all-start")
    | ascii::string("--pos-neg-start")
    | ascii::string("--conjecture-start")
    | ascii::string("--restrict-start")
    | ascii::string("--no-regularity")
    | ascii::string("--no-lemmata")
    | ascii::string("--all-lemmata")
    | ascii::string("--all-reductions")
    | ascii::string("--all-extensions")
    | ascii::string("--all-backtrack")
    | ascii::string("--lemmata-backtrack")
    | ascii::string("--reduction-backtrack")
    | ascii::string("--extension-backtrack")
    | ascii::string("--explore-left-trees")
    | ascii::string("--hard-prune")

Definition at line 144 of file Schedule.cpp.

schedule_word_param

qi::rule<Iter, string()> schedule::schedule_word_param

Initial value:

=
      ascii::string("--complete")
      | ascii::string("--reorder")

Definition at line 161 of file Schedule.cpp.

step

string schedule::step

Definition at line 93 of file Schedule.cpp.

value

unsigned int schedule::value = 0

Definition at line 91 of file Schedule.cpp.