---

callback.h

Go to the documentation of this file.

#ifndef __CALLBACK_H_INCLUDED__
#define __CALLBACK_H_INCLUDED__

// $Id$

//**********************************************************************
//                                                                     *
//    Description:   Classes to implement 'Callbacker' style callback  *
//                   notification mechanism.                           *
//                                                                     *
//    Author:        Chris White (whitecf@bcs.org.uk)                  *
//                                                                     *
//    Copyright (C) 2003  Monitor Computing Services Ltd.              *
//                                                                     *
//    This program is free software; you can redistribute it and/or    *
//    modify it under the terms of the GNU General Public License      *
//    as published by the Free Software Foundation; either version 2   *
//    of the License, or any later version.                            *
//                                                                     *
//    This program is distributed in the hope that it will be useful,  *
//    but WITHOUT ANY WARRANTY; without even the implied warranty of   *
//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the    *
//    GNU General Public License for more details.                     *
//                                                                     *
//    You should have received a copy of the GNU General Public        *
//    License (http://www.gnu.org/copyleft/gpl.html) along with this   *
//    program; if not, write to:                                       *
//       The Free Software Foundation Inc.,                            *
//       59 Temple Place - Suite 330,                                  *
//       Boston, MA  02111-1307,                                       *
//       USA.                                                          *
//                                                                     *
//**********************************************************************
//                                                                     *
//    Notes:                                                           *
//                                                                     *
//**********************************************************************



namespace Monitor {
namespace Utility {

class CallbackBase
{
public:
    CallbackBase() {;}

    virtual ~CallbackBase() {;}


    virtual CallbackBase*
    clone() const = 0;

    int
    operator==(const CallbackBase&    other) const { return isEqual(other); }

    virtual int
    isEqual(const CallbackBase&    other) const { return (&other == this); }

    virtual void
    invoke(const void*    invocationData = 0) const = 0;

    virtual int
    set() const = 0;

    virtual int
    isTarget(const void*    testTarget) const = 0;
};



class FuncCallback : public CallbackBase
{
public:
    typedef void (*CallbackType)();


    FuncCallback(CallbackType    newTargetFunction)
        :
        CallbackBase(),
        targetFunction(newTargetFunction)
        {;}

    FuncCallback(const FuncCallback&    other)
        :
        CallbackBase(),
        targetFunction(other.targetFunction)
        {;}

    virtual ~FuncCallback() {;}

    virtual CallbackBase*
    clone() const { return new FuncCallback(*this); }

    int
    operator==(const FuncCallback&    other) const
    {
        return (targetFunction == other.targetFunction);
    }

    virtual int
    isEqual(const CallbackBase&    other) const
    {
        return (*this == dynamic_cast< const FuncCallback& >(other));
    }

    virtual int
    isTarget(const void*) const
    {
        return 0;
    }

    virtual void
    invoke(const void*) const { (*targetFunction)(); }

    virtual int
    set() const { return (0 != targetFunction); }

protected:
    CallbackType    targetFunction;
};



template <class TargetClass>
class ClassCallback : public CallbackBase
{
public:
    ClassCallback(TargetClass&    newTargetObject)
        :
        CallbackBase(),
        targetObject(newTargetObject)
        {;}

    ClassCallback(const ClassCallback&    other)
        :
        CallbackBase(),
        targetObject(other.targetObject)
        {;}

    virtual ~ClassCallback() {;}

    int
    operator==(const ClassCallback&    other) const
    {
        return (&targetObject == &other.targetObject);
    }

    virtual int
    isTarget(const void*    testTarget) const
    {
        return (testTarget == (const void*)&targetObject);
    }

protected:
    TargetClass&    targetObject;
};



template <class TargetClass>
class Callback : public ClassCallback< TargetClass >
{
public:
    typedef void (TargetClass::*CallbackType)();


    Callback(TargetClass&    newTargetObject,
             CallbackType    newTargetFunction)
        :
        ClassCallback< TargetClass >(newTargetObject),
        targetFunction(newTargetFunction)
        {;}

    Callback(const Callback&    other)
        :
        ClassCallback< TargetClass >(other),
        targetFunction(other.targetFunction)
        {;}

    virtual ~Callback() {;}

    virtual CallbackBase*
    clone() const { return new Callback(*this); }

    int
    operator==(const Callback&    other) const
    {
        return ((ClassCallback< TargetClass >::operator==(other)) &&
                (targetFunction == other.targetFunction));
    }

    virtual int
    isEqual(const CallbackBase&    other) const
    {
        return (*this == dynamic_cast< const Callback& >(other));
    }

    virtual void
    invoke(const void*) const { (targetObject.*targetFunction)(); }

    virtual int
    set() const { return (0 != targetFunction); }

protected:
    CallbackType    targetFunction;
};



template <class TargetClass>
class ConstCallback : public Callback< TargetClass >
{
public:
    typedef void (TargetClass::*CallbackType)() const;


    ConstCallback(
        const TargetClass&    newTargetObject,
        CallbackType          newTargetFunction)
        :
        Callback< TargetClass >(
            const_cast< TargetClass& >(newTargetObject),
            reinterpret_cast< Callback< TargetClass >::CallbackType >(
                newTargetFunction))
        {;}

    ConstCallback(const ConstCallback&    other)
        :
        Callback< TargetClass >(other)
        {;}

    virtual ~ConstCallback() {;}

    virtual CallbackBase*
    clone() const { return new ConstCallback(*this); }

    int
    operator==(const ConstCallback&    other) const
    {
        return Callback< TargetClass >::operator==(other);
    }

    virtual void
    invoke(const void*) const
    {
        (targetObject.*reinterpret_cast< CallbackType >(targetFunction))();
    }
};



template <class TargetClass, typename TargetData>
class DataCallback : public Callback< TargetClass >
{
public:
    typedef void (TargetClass::*CallbackType)(TargetData);


    DataCallback(
        TargetClass&         newTargetObject,
        CallbackType         newTargetFunction,
        const TargetData&    newTargetData)
        :
        Callback< TargetClass >(
            newTargetObject,
            reinterpret_cast< Callback< TargetClass >::CallbackType >(
                newTargetFunction)),
        targetData(newTargetData)
        {;}

    DataCallback(const DataCallback&    other)
        :
        Callback< TargetClass >(other),
        targetData(other.targetData)
        {;}

    virtual ~DataCallback() {;}

    virtual CallbackBase*
    clone() const { return new DataCallback(*this); }

    int
    operator==(const DataCallback&    other) const
    {
        return (Callback< TargetClass >::operator==(other) &&
                (targetData == other.targetData));
    }

    virtual int
    isEqual(const CallbackBase&    other) const
    {
        return (*this == dynamic_cast< const DataCallback& >(other));
    }

    virtual void
    invoke(const void*) const
    {
        (targetObject.*reinterpret_cast< CallbackType >(targetFunction))(
            targetData);
    }

protected:
    TargetData      targetData;
};



template <class TargetClass, typename TargetData >
class DataConstCallback : public DataCallback< const TargetClass, TargetData >
{
public:
    typedef DataCallback< const TargetClass, TargetData >    ParentClass;
    typedef void (TargetClass::*CallbackType)(TargetData) const;


    DataConstCallback(
        TargetClass&         newTargetObject,
        CallbackType         newTargetFunction,
        const TargetData&    newTargetData)
        :
        ParentClass(
            const_cast< const TargetClass& >(newTargetObject),
            reinterpret_cast< Callback< TargetClass >::CallbackType >(
                newTargetFunction),
            newTargetData)
        {;}

    DataConstCallback(const ParentClass&    other)
        :
        Callback< const TargetClass >(other)
        {;}

    virtual ~DataConstCallback() {;}

    virtual CallbackBase*
    clone() const { return new DataConstCallback(*this); }

    int
    operator==(const DataConstCallback&    other) const
    {
        return ParentClass::operator==(other);
    }
};



template <class TargetClass, typename TargetInfo >
class InfoCallback : public Callback< TargetClass >
{
public:
    typedef void (TargetClass::*CallbackType)(const TargetInfo*);


    InfoCallback(
        TargetClass&    newTargetObject,
        CallbackType    newTargetFunction)
        :
        Callback< TargetClass >(
            newTargetObject,
            reinterpret_cast< Callback< TargetClass >::CallbackType >(
                newTargetFunction))
        {;}

    InfoCallback(const InfoCallback&    other)
        :
        Callback< TargetClass >(other)
        {;}

    virtual ~InfoCallback() {;}

    virtual CallbackBase*
    clone() const { return new InfoCallback(*this); }

    int
    operator==(const InfoCallback&    other) const
    {
        return Callback< TargetClass >::operator==(other);
    }

    virtual void
    invoke(const void*    targetInfo) const
    {
        (targetObject.*reinterpret_cast< CallbackType >(targetFunction))(
            static_cast< const TargetInfo* >(targetInfo));
    }
};

};  // namespace Utility
};  // namespace Monitor

#endif // __CALLBACK_H_INCLUDED__

---