/* * Author: AZTECCO. 2/2018 * */ /* [challenge] code, eat and sleep - but planned! 💤💤💤💤💻💻🍴🍴🍴 We all know, we cant do all things immediately. We have to plan. Define three functions(code,eat,sleep) with parameter hours. Assign a priority to each function. If you call that functions, they should not be processed immediatly but scheduled. The call of a further function doit() tells the functions to run as they are scheduled: Use your own rule for schedule. Example: Rule: Highest prio first. Prios: code():1 eat():2 sleep():3 call code(1) call sleep(2) call eat(1) call code(2) call eat(2) call doit() Output: code 1 hour code 2 hours eat 1 hour eat 2 hours sleep 2 hours choose your own weapon, your own rule, your own prios Have fun */ /* * Rules: 1) you feel hungry after 7 hours * 2) you feel sleepy after 24 hours * */ #include #include enum Activity_type {code, eat, sleep}; class Activity; // functor, base for(Code,Eat,Sleep) class Code; class Eat; class Sleep; class Scheduler; // singleton void call (Activity_type ,int); void doIt(); int main(){ call(code, 8); call(eat, 4); call(eat,2); call(code,3); call(code,2); call(code,1); call(code,2); call(eat,1); call(code,13); call(eat,2); call(code, 8); call(eat, 4); call(sleep, 8); call(code,12); call(sleep,2); call(code, 8); call(eat, 4); call(sleep, 8); call(code,1); call(sleep,2); call(eat,2); call(code,3); call(code,2); call(code,1); call(code,2); call(eat,1); call(code,13); call(eat,2); call(code, 8); call(eat, 4); call(eat,2); doIt(); std::cout<<"end\n"; return 0; } class Activity { public : virtual void operator ()()=0; Activity_type getType() { return type_; } int getTime() { return timeHours_; } protected : Activity(Activity_type type, int timeHours ): type_(type ), timeHours_(timeHours ) { // only initializer } Activity(Activity& ref ): type_(ref.type_ ), timeHours_(ref.timeHours_ ) { // only initializer } virtual ~Activity() {} const Activity_type type_; const int timeHours_; friend void call(Activity_type x, int timeHours ); friend class Scheduler; }; class Code: public Activity { public : Code(int timeHours ): Activity(code, timeHours ) { // pass to base initializer } ~Code() {std::cout<<"~";} void operator ()() { std::cout<< "Code " << timeHours_ << " hour"; if (timeHours_ > 1 ) std::cout<< 's'; std::cout<< "." "\n"; if (timeHours_>8 ) std::cout<< " @ @" "\n" " @" "\n" " @" "\n" " ______" "\n" " / /" "\n" " / /" "\n" " ======\'\'\'" "\n\n" ; delete this; } }; class Eat: public Activity { public : Eat(int timeHours ): Activity(eat, timeHours ) { // pass to base initializer } ~Eat() {std::cout<<"~";} void operator ()() { std::cout<< "Eat " << timeHours_ << " hour"; if (timeHours_ > 1) std::cout<< 's'; std::cout<< "." "\n"; if (timeHours_ > 3 ) std::cout<< "A cool resturant?" "\n"; if (timeHours_ == 2 ) std::cout<< "Have a pizza! SLURP!" "\n"; if (timeHours_ == 1 ) std::cout<< "Cofee??" "\n"; delete this; } }; class Sleep: public Activity { public : Sleep(int timeHours ): Activity(sleep, timeHours ) { // pass to base initializer } ~Sleep() {std::cout<<"~";} void operator ()() { std::cout<< "Sleep " << timeHours_ << " hour"; if (timeHours_>1) std::cout<< 's'; std::cout<< "." "\n"; delete this; } }; class Scheduler { public : static Scheduler& getInstance() { static Scheduler instance; return instance; } void execute(); private : Scheduler(){} Scheduler(Scheduler const&)= delete; void operator =(Scheduler const&)= delete; ~Scheduler() { for (std::vector::iterator it = activities_.begin(); it != activities_.end(); ++it ) delete *it; } std::vector activities_; friend void call(Activity_type x, int timeHours ); }; void Scheduler::execute() { int eatTimerHours = 0; int sleepTimerHours = 0; bool isSleepActivitiesAvailable = true; bool isEatActivitiesAvailable = true; Activity_type priority = code; std::vector orderedActivities; auto match = [&] (Activity* activity) { if (activity->getType()== priority ) return true;}; bool isMatched = false; for (int i=0; i< activities_.size();/* if match*/ ){ priority = code; if (isSleepActivitiesAvailable ) if (sleepTimerHours > 24 ) priority = sleep; if (isEatActivitiesAvailable ) if (eatTimerHours > 7 ) priority = eat; isMatched = false; for (std::vector::iterator it = activities_.begin(); it != activities_.end(); ++it ){ if (match(*it ) ){ i++; eatTimerHours += (*it)-> getTime(); sleepTimerHours += (*it)-> getTime(); orderedActivities.push_back(*it ); activities_.erase(it ); if (priority == eat ) eatTimerHours = 0; if (priority == sleep) sleepTimerHours = 0; isMatched = true; break; } } if (!isMatched ) { if (priority == code ) sleepTimerHours = eatTimerHours = 100; if (priority == eat ) isEatActivitiesAvailable = false; if (priority == sleep ) isSleepActivitiesAvailable = false; } isMatched =false; } for (std::vector::iterator it = orderedActivities.begin(); it != orderedActivities.end(); ++it ){ (**it)(); } } void call(Activity_type x, int timeHours ) { Activity* elm = 0; switch (x ){ case code : elm = new Code(timeHours ); break ; case eat : elm = new Eat(timeHours ); break ; case sleep : elm = new Sleep(timeHours ); break ; default : std::cout<< "Wrong type\n"; } Scheduler::getInstance().activities_.push_back(elm ); } void doIt() { Scheduler::getInstance().execute(); }