Question

class FooInterface {
  virtual void toggle() = 0;
};

template <class TYPE, class CONFIG>
class Foo : public FooInterface {
  virtual void toggle();

  TYPE value_;
};

template <>
void Foo<bool, class CONFIG>::toggle() {
  if (CONFIG::canToggle())
    value_ = !value_;
}

struct MyConfig {
  static bool canToggle() {
    return false;
  }
};

int main() {
  Foo<bool, MyConfig> foo;
}

That’s an accurate approximation of what I’m dealing with. I basically want to have a specialized method for dealing with a TYPE, while keeping the CONFIG generic. So, for example, I might have a dozen different Foo::toggle() methods with specialized code handling specific TYPEs, but what’s used from CONFIG will be consistent across all of those methods.

The problem is the previous code doesn’t compile, along with several different combinations, and I’d appreciate some help finding a different solution or some workaround to make the current one work.

Edit: I should note that the previous code works without the CONFIG template parameter.

Answer 1

dispatch

template<class CONFIG, class C>
void toggle_impl(type<bool>, C &c) {
  if (CONFIG::canToggle())
    c.value_ = !c.value_;
}

template <class TYPE, class CONFIG>
class Foo : public FooInterface {
  virtual void toggle() {
      toggle_impl<CONFIG>(type<TYPE>(), *this);
  }
  TYPE value_;
};