class1 {
public:
enum Action {stay,run};
}

class2:public class1 {
public:
enum Action {stay,run,jump};
}

struct base
{
    typedef boost::mpl::vector<run, stay> actions;
};

struct child : public base
{
    typedef boost::mpl::push_back<base::actions, jump> actions;
};

class1 {
public:
static const int stay = 0;
static const int run = 1;
};
class2:public class1 {
public:
static const int jump = 2;
};

class class1 {
public:
  enum Action {stay,run};
  static const int LastAction = run;
};

class class2:public class1 {
public:
  enum Action {jump=LastAction+1,sit};
};

K>class1 {
K>public:
K>enum Action {stay,run};
K>}
K>

K>class2:public class1 {
K>public:
K>enum Action {stay,run,jump};
K>}
K>

class base {
  enum EAction { super = 0 };
  static const stay = super+1;
  // etc...
  virtual some_method(EAction act) =0;
};

#include <boost/current_function.hpp>
#include <boost/function.hpp>
#include <boost/bind/apply.hpp>
#include <boost/bind.hpp>
#include <algorithm>
#include <iostream>
#include <vector>

struct car
{
    void start() { std::cout << BOOST_CURRENT_FUNCTION << std::endl; }
    void stop() { std::cout << BOOST_CURRENT_FUNCTION << std::endl; }
};
struct human
{
    void eat() { std::cout << BOOST_CURRENT_FUNCTION << std::endl; }
    void shit() { std::cout << BOOST_CURRENT_FUNCTION << std::endl; }
};
struct tiger
{
    void jump() { std::cout << BOOST_CURRENT_FUNCTION << std::endl; }
    void eat() { std::cout << BOOST_CURRENT_FUNCTION << std::endl; }
};

int main()
{
    car c;
    human h;
    tiger t;

    typedef std::vector<boost::function<void()> > actions;
    actions a;
    a.push_back(boost::bind(&car::start, c));
    a.push_back(boost::bind(&human::eat, h));
    a.push_back(boost::bind(&tiger::jump, t));
    a.push_back(boost::bind(&human::shit, h));
    a.push_back(boost::bind(&car::stop, c));
    a.push_back(boost::bind(&tiger::eat, t));

    std::for_each(a.begin(), a.end(), boost::bind(boost::apply<void>(), _1));
    return 0;
}

#include <iostream>
#include <vector>

namespace Action{template<typename AT> void act(void * obj);};
#define CreateAction(ActionName) \
    namespace Action\
    {\
        struct ActionName { virtual void do_##ActionName() = 0; };\
        template<> void act<ActionName>(void * obj)\
        {((ActionName*)obj)->do_##ActionName();}\
    }
CreateAction(jump);
CreateAction(eat);
CreateAction(shit);
CreateAction(stop);
CreateAction(start);
CreateAction(bark);

struct car : Action::start, Action::stop
{
    void do_start() { std::cout << __FUNCTION__ << std::endl; }
    void do_stop() { std::cout << __FUNCTION__ << std::endl; }
};
struct human : Action::eat, Action::shit
{
    void do_eat() { std::cout << __FUNCTION__ << std::endl; }
    void do_shit() { std::cout << __FUNCTION__ << std::endl; }
};
struct tiger : Action::jump, Action::eat
{
    void do_jump() { std::cout << __FUNCTION__ << std::endl; }
    void do_eat() { std::cout << __FUNCTION__ << std::endl; }
};


int main()
{
    car c;
    human h;
    tiger t;

    typedef std::vector<std::pair<void(*)(void*), void*> > actions;
    actions a;
    a.push_back(std::make_pair(Action::act<Action::start>, &c));
    a.push_back(std::make_pair(Action::act<Action::eat>, &h));
    a.push_back(std::make_pair(Action::act<Action::jump>, &t));
    a.push_back(std::make_pair(Action::act<Action::shit>, &h));
    a.push_back(std::make_pair(Action::act<Action::stop>, &c));
    a.push_back(std::make_pair(Action::act<Action::eat>, &t));
    for (actions::iterator it = a.begin(), end = a.end(); it != end; ++it)
    {
        it->first(it->second);
    }
}

class IAction {
protected:
    virtual ~IAction() {}
public:
    virtual Do( IItem* ) const = 0;
}