I am using Boost::Statechart for the first time, throwing in the bin a history of hand-coded and other class-based implementations of my own design, to realize a rather simple machine consisting of four events (start/stop/suspend/resume) and four states (stopped/running/stopped-suspended/running-suspended). The machine is effectively a timer and wraps another internal timer class that can be stopped/started and suspended/resumed. This is all the machine does. The internal timer class can get/set its interval and can also get/set a delegate, that is called (if set) when the timer fires. These internal timer management interfaces are "passed through" to the state machine interface, such that application/test code is as follows: ...(TimerDelegate & inDelegate, float inInterval) { Timer theTimer; theTimer.initiate(); BOOST_ASSERT(!theTimer.IsSuspended()); BOOST_ASSERT(!theTimer.IsRunning()); DisplayState(theTimer); theTimer.SetDelegate(inDelegate); theTimer.SetInterval(inInterval); cout << "The delegate is " << theTimer.GetDelegate() << endl; cout << "The interval is " << theTimer.GetInterval() << endl; BOOST_ASSERT(!theTimer.IsSuspended()); BOOST_ASSERT(!theTimer.IsRunning()); DisplayState(theTimer); theTimer.process_event(Events::Start()); BOOST_ASSERT(!theTimer.IsSuspended()); BOOST_ASSERT(theTimer.IsRunning()); DisplayState(theTimer); The delegate does the real work of the program and receives events that drive the timer machine. Where I have run into a problem is that my machine "pass through" setter methods allowing the delegate to be set or the timer interval to be changed (neither of which materially alter the state of the machine) cannot be called as they are non-const qualified whereas their corresponding getters work fine since they are const qualified. I've worked around this in the short term by qualifying the setters as const and then qualifying the data members as mutable; however, this strikes me as flat-out ugly and wrong. Is there a better way to accomplish this? Am I misusing the template/design pattern? I suppose I could applying a const_cast(); however, that seems just as bad as my existing workaround. class InternalTimer; struct TimerDelegate { virtual void TimerDidFire(const InternalTimer &inTimer) const = 0; }; class InternalTimer { public: InternalTimer(void); : ~InternalTimer(void); TimerDelegate *GetDelegate(void) const; float GetInterval(void) const; void SetDelegate(TimerDelegate *inDelegate); void SetInterval(float inInterval); void Start(void); void Stop(void); private: TimerDelegate * mDelegate; float mInterval; }; struct ITimerManagement { public: virtual TimerDelegate *GetDelegate(void) const = 0; virtual float GetInterval(void) const = 0; virtual void SetDelegate(TimerDelegate * inDelegate) = 0; virtual void SetInterval(float inInterval) = 0; }; struct IRunning { public: virtual bool IsRunning(void) const; protected: IRunning(bool inRunning); private: bool mRunning; }; struct ISuspended { public: virtual bool IsSuspended(void) const; protected: ISuspended(bool inSuspended); private: bool mSuspended; }; struct Active; struct Timer : state_machine< Timer, Active > { public: TimerDelegate * GetDelegate(void) const { return (state_cast< const ITimerManagement & >().GetDelegate()); } float GetInterval(void) const { return (state_cast< const ITimerManagement & >().GetInterval()); } void SetDelegate(TimerDelegate *inDelegate) { state_cast< ITimerManagement & >().SetDelegate(inDelegate); // XXX } void SetInterval(float inInterval) { state_cast< ITimerManagement & >().SetInterval(inInterval); // XXX } bool IsRunning(void) const { return (state_cast< const IRunning & >().IsRunning()); } bool IsSuspended(void) const { return (state_cast< const ISuspended & >().IsSuspended()); } }; struct Timer; struct Stopped; struct Running; struct StoppedSuspended; struct RunningSuspended; struct Active : ITimerManagement, simple_state< Active, Timer, Stopped > { virtual TimerDelegate * GetDelegate(void) const { return (mInternalTimer.GetDelegate()); } virtual float GetInterval(void) const { return (mInternalTimer.GetInterval()); } virtual void SetDelegate(TimerDelegate *inDelegate) { mInternalTimer.SetDelegate(inDelegate); } virtual void SetInterval(float inInterval) { mInternalTimer.SetInterval(inInterval); } void Start(void) { mInternalTimer.Start(); } void Stop(void) { mInternalTimer.Stop(); } private: InternalTimer mInternalTimer; }; struct Running : IRunning, ISuspended, state< Running, Active > { public: typedef mpl::list< transition< Events::Stop, Stopped >, transition< Events::Suspend, RunningSuspended > > reactions; Running(my_context inContext) : my_base(inContext), IRunning(true), ISuspended(false) { context< Active >().Start(); } ~Running(void) { context< Active >().Stop(); } }; Regards, Grant