gls_animation_observer.h

Go to the documentation of this file.

#ifndef INCLUDED_GLS_ANIMATION_OBSERVER_H
#define INCLUDED_GLS_ANIMATION_OBSERVER_H

#include "gls_keyframe.h"

namespace disti
{
    class GlsAnimationObserverBase
    {
    public:
        typedef stdortr1::shared_ptr<GlsAnimationObserverBase> Ptr; 
        typedef Detail::ID                                     ID;  

        GlsAnimationObserverBase() {}

        virtual ~GlsAnimationObserverBase() {}

        virtual void OnStarted( ID ) {}

        virtual void OnUpdated( ID ) {}

        virtual void OnCompleted( ID ) {}

        virtual void OnCanceled( ID ) {}
        
    private:
        GlsAnimationObserverBase( const GlsAnimationObserverBase& ); // = delete
        void operator=(           const GlsAnimationObserverBase& ); // = delete
    };

    class GlsAnimationObserver : public GlsAnimationObserverBase
    {
    public:
        template<class OnStartedCallback, class OnUpdatedCallback, class OnCompletedCallback, class OnCanceledCallback>
        GlsAnimationObserver( 
            const OnStartedCallback&   onStarted, 
            const OnUpdatedCallback&   onUpdated, 
            const OnCompletedCallback& onCompleted, 
            const OnCanceledCallback&  onCanceled ) 
            : _onStarted(   MakeCallback( onStarted   ) )
            , _onUpdated(   MakeCallback( onUpdated   ) )
            , _onCompleted( MakeCallback( onCompleted ) )
            , _onCanceled(  MakeCallback( onCanceled ) )
        {}

        virtual void OnStarted( ID id ) // override
        {
            if( _onStarted )
            {
                (*_onStarted)( id );
            }
        }

        virtual void OnUpdated( ID id ) // override
        {
            if( _onUpdated )
            {
                (*_onUpdated)( id );
            }
        }

        virtual void OnCompleted( ID id ) // override
        {
            if( _onCompleted )
            {
                (*_onCompleted)( id );
            }
        }

        virtual void OnCanceled( ID id ) // override
        {
            if( _onCanceled )
            {
                (*_onCanceled)( id );
            }
        }
    private:
        // Callback types to enable delayed type declaration.
        // Compare the bit about shared_ptr's deleter in http://www.artima.com/cppsource/top_cpp_aha_moments.html
        struct CallbackBase
        {
            typedef stdortr1::shared_ptr<CallbackBase> Ptr;
            virtual ~CallbackBase() {}
            virtual void operator()( ID ) = 0;
        };

        template<class Fn>
        struct Callback : CallbackBase
        {
            explicit Callback( const Fn& fn ) : _fn( fn ) {}
            virtual void operator()( ID id ) // override
            {
                _fn( id );
            }
        private:
            const Fn _fn;
        };

        // Classes to do compile-time checking of whether an object is valid.
        // See http://en.wikibooks.org/wiki/More_C++_Idioms/Member_Detector
        template<typename T, typename RESULT=bool>
        class HasPolicyBool
        {
            template <typename U, RESULT (U::*)()> struct Check;
            template <typename U> static char func(Check<U, &U::operator bool> *);
            template <typename U> static int func(...);
          public:
            typedef HasPolicyBool type;
            enum { value = sizeof(func<T>(0)) == sizeof(char) };
        };

        template<typename T, typename RESULT=void*>
        class HasPolicyVoid
        {
            template <typename U, RESULT (U::*)()> struct Check;
            template <typename U> static char func(Check<U, &U::operator void*> *);
            template <typename U> static int func(...);
          public:
            typedef HasPolicyVoid type;
            enum { value = sizeof(func<T>(0)) == sizeof(char) };
        };    

        // Check for validity of the object so that we don't create a callback object if it's invalid
        template<class Fn> static bool IsValid( Fn fn, typename Detail::enable_if<  HasPolicyBool<Fn>::value &&  HasPolicyVoid<Fn>::value >::type* = 0 ) { return static_cast<bool>(fn);          } // Check for things that can be tested by conversion to bool or void*
        template<class Fn> static bool IsValid( Fn fn, typename Detail::enable_if< !HasPolicyBool<Fn>::value &&  HasPolicyVoid<Fn>::value >::type* = 0 ) { return static_cast<void*>(fn) != NULL; } // Check for things that can be tested by conversion to bool or void*
        template<class Fn> static bool IsValid( Fn fn, typename Detail::enable_if<  HasPolicyBool<Fn>::value && !HasPolicyVoid<Fn>::value >::type* = 0 ) { return static_cast<bool>(fn);          } // Check for things that can be tested by conversion to bool or void*
        template<class Fn> static bool IsValid( Fn fn, typename Detail::enable_if< !HasPolicyBool<Fn>::value && !HasPolicyVoid<Fn>::value >::type* = 0 ) { return true; } // We can't tell if it's valid (e.g., an arbitrary functor), so just assume it is.
        static bool IsValid( void(*fn)(ID) ) { return fn != 0; } // Handle the case of stand-alone function pointers

        // Create valid callbacks, or return a null pointer if incoming object is invalid
        // (within our ability to check it).
        template<class Fn>
        static CallbackBase::Ptr MakeCallback( const Fn& fn )
        {
            return CallbackBase::Ptr( IsValid(fn) ? new Callback<Fn>( fn ) : 0 );
        }

        // Member data
        const CallbackBase::Ptr _onStarted;
        const CallbackBase::Ptr _onUpdated;
        const CallbackBase::Ptr _onCompleted;
        const CallbackBase::Ptr _onCanceled;
    };

    template<class Fn>
    GlsAnimationObserverBase::Ptr CreateOnStartedCallback( const Fn& fn )
    {
        void(*dummy)( GlsAnimationObserverBase::ID ) = 0;
        return GlsAnimationObserverBase::Ptr( new GlsAnimationObserver( fn, dummy, dummy, dummy ) );
    }

    template<class Fn>
    GlsAnimationObserverBase::Ptr CreateOnUpdatedCallback( const Fn& fn )
    {
        void(*dummy)( GlsAnimationObserverBase::ID ) = 0;
        return GlsAnimationObserverBase::Ptr( new GlsAnimationObserver( dummy, fn, dummy, dummy ) );
    }

    template<class Fn>
    GlsAnimationObserverBase::Ptr CreateOnCompletedCallback( const Fn& fn )
    {
        void(*dummy)( GlsAnimationObserverBase::ID ) = 0;
        return GlsAnimationObserverBase::Ptr( new GlsAnimationObserver( dummy, dummy, fn, dummy ) );
    }
    
    template<class Fn>
    GlsAnimationObserverBase::Ptr CreateOnCanceledCallback( const Fn& fn )
    {
        void(*dummy)( GlsAnimationObserverBase::ID ) = 0;
        return GlsAnimationObserverBase::Ptr( new GlsAnimationObserver( dummy, dummy, dummy, fn ) );
    }
}

#endif