Russian Qt Forum

C++ (Qt)
void CopyParam( MyClass & dst, const MyClass & src, int id )
{
 switch (id) {
   case ID_ENABLED:
     if (dst.mEnabled != src.mEnabled) {
       SaveUndo(dst);
       dst.mEnabled = src.mEnabled;
       UpdateUI(); 
     }
     break;
 
   case ID_COUNT:
     if (dst.mCount != src.mCount) {
       SaveUndo(dst);
       dst.mCount = src.mCount;
       UpdateUI(); 
     }
     break;
    ...
// и так еще много-много раз
}

C++ (Qt)
template<class T, class M>
void work (const T &dest, M &destMember, const M &sourceMember)
{
  if (destMember != sourceMember) {
    SaveUndo(dest);
    destMember = sourceMember;
    UpbateUI();
  }
}
 
switch(id) {
  case ID_ENABLED:
    work(dst, dst.mEnabled, src.mEnabled);
    break;
.....
}
 

C++ (Qt)
void work (const T &dest, M &destMember, const M &sourceMember, bool updateUI = false, bool action1 = false........)

C++ (Qt)
worj(dst, dst.mCount, src.mCount, false, true, false);

C++ (Qt)
int MyClass::count( void ) const { return count; }
void MyClass::setCount( int cnt ) { count = cnt; }
 

C++ (Qt)
class AbstractStrategy
{
    virtual bool canDo(int id) const = 0;
    virtual void do(MyClass & dst, const MyClass & src) = 0;
}
 

C++ (Qt)
class BoolMethodStrategy : public AbstractStrategy
{
public:
   BoolMethodStrategy(std::function<bool(MyClass*)> getMethod, std::function<void(MyClass*, bool val)> setMethod);
   virtual void copy(MyClass & dst, const MyClass & src) {
      if (getMethod_(&dst) != getMethod_(&src)............
   }
}
 
....................
map[1] = new BoolMethodStrategy(&MyClass::enabled, &MyClass::setEnabled)
 

template <int Id> struct MemberById;
template <> struct MemberById<ID_ENABLED> { static constexpr auto Member = &MyClass::enabled; };

C++ (Qt)
const iint id[] = { ID_ENABLED, ID_COUNT, ... };
for (int i = 0; i = sizeof(id) / sizeof(int); ++i) 
 CopyParam <???>   // но ведь нельзя подставить i
 

C++ (Qt)
struct ID_ENABLED{};
struct ID_COUNT{};
...
 
class switch_visitor : public boost::static_visitor<>
{
public:
    void operator()(ID_ENABLED) const
    {
        // бла-бла-бла
    }
 
    void operator()(ID_COUNT) const
    {
        // бла-бла-бла
    }
 
    // и т.д.
};
 
 
boost::variant<ID_ENABLED, ID_COUNT> id = ID_COUNT();
 
 
boost::apply_visitor(switch_visitor(), id);
 

C++ (Qt)
class Window
{
public:
    enum id_type { ID_ENABLED, ID_COUNT};
 
    Window()
    {
        _map[ID_ENABLED] = &Window::action_enabled;
        _map[ID_COUNT] = &Window::action_count;
    }
 
    void updateUI() { std::cout << "UbdateUI" << std::endl; }
 
    void some_method(id_type id) { _map[id](this); } // <-- Это вместо длинного свитча 
 
private:
    void action_enabled()
    {
        std::cout << "ID_ENABLED" << std::endl;
        updateUI();
    }
 
    void action_count()
    {
        std::cout << "ID_COUNT" << std::endl;
    }
 
    std::map<id_type, std::function<void(Window*)>> _map;
};
 
 
int main()
{
    Window wnd;
 
    wnd.some_method(Window::ID_COUNT);
    wnd.some_method(Window::ID_ENABLED);
 
    return 0;
}
 

C++ (Qt)
typedef int MyClass;
 
class Window
{
public:
    enum id_type { ID_ENABLED, ID_COUNT};
 
    Window()
    {
        _map[ID_ENABLED] = &Window::action_enabled;
        _map[ID_COUNT] = &Window::action_count;
    }
 
    void updateUI() { std::cout << "UbdateUI" << std::endl; }
 
    void some_method(MyClass & dst, const MyClass & src, id_type id) { _map[id](this, dst, src); } // <-- Вариант свитча с копированием структуры 
 
private:
    void action_enabled(MyClass & dst, const MyClass & src)
    {
        std::cout << "ID_ENABLED" << std::endl;
        dst = src;
        updateUI();
    }
 
    void action_count(MyClass & dst, const MyClass & src)
    {
        std::cout << "ID_COUNT" << std::endl;
        dst = src;
    }
 
    std::map<id_type, std::function<void(Window*, MyClass&, const MyClass&)>> _map;
};
 
 
Window wnd;
 
    MyClass src = 1;
    MyClass dst = 2;
 
    wnd.some_method(dst, src, Window::ID_COUNT);
    wnd.some_method(dst, src, Window::ID_ENABLED);
 

C++ (Qt)
bool update = false;
switch (id) {
 case ID_ENABLE:
  ...
  update = true;
  break;
  ....
  ....
  update = true;
} 
 
if (update) {
 ...
}

C++ (Qt)
bool update = false;
_map[id](this, update);
 
if (update) { ... }
 

C++ (Qt)
state s = _map[id](this);
 
if (s.update) { ... }
 
// или
 
state s;
_map[id](this, s);
 
...