Callable.h

Go to the documentation of this file.

/*

Copyright (C) 2005-2007 by Peter Dimov.

This file is part of Calitko (http://www.calitko.org).

Calitko 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
(at your option) any later version.

Calitko 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
along with Calitko; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

*/

#ifndef UTILS__CALLABLE_H
#define UTILS__CALLABLE_H

#include "Imports.h"
#include "AbstractValue.h"

namespace Utils {


template <typename T = void()>
class Callable;


template <typename R>
class Callable <R ()>
{
    struct CallableImpl
    {
        virtual                         ~CallableImpl() {}
        virtual auto_ptr <CallableImpl> copy() const = 0;
        virtual bool                    isEqualTo (const CallableImpl &) = 0;
        virtual R                       doCall() = 0;
    };

    struct NullCallableImpl : public CallableImpl
    {
        NullCallableImpl() {}
        ~NullCallableImpl() {}

        auto_ptr <CallableImpl> copy() const
        { return auto_ptr <CallableImpl> (new NullCallableImpl ()); }

        bool isEqualTo (const CallableImpl &) { return true; }
        R doCall () { return R(); }
    };

    typedef R (*Function)();
    struct FunctionCallableImpl : public CallableImpl
    {
        Function function;

        FunctionCallableImpl (Function f) : function (f) {}
        ~FunctionCallableImpl() {}

        auto_ptr <CallableImpl> copy() const
        { return auto_ptr <CallableImpl> (new FunctionCallableImpl (*this)); }

        bool isEqualTo (const CallableImpl &other_)
        {
            const FunctionCallableImpl &other =
                dynamic_cast <const FunctionCallableImpl &> (other_);
            return other.function == other.function;
        }

        R doCall() { return function(); }
    };

    template <typename Class>
    struct MemberFunctionCallableImpl : public CallableImpl
    {
        typedef R (Class::*MemberFunction) ();

        Class           &object;
        MemberFunction  function;

        MemberFunctionCallableImpl() {}
        MemberFunctionCallableImpl (Class &o, MemberFunction f)
        : object (o), function (f) {}
        ~MemberFunctionCallableImpl() {}

        auto_ptr <CallableImpl> copy() const
        { return auto_ptr <CallableImpl>
                                    (new MemberFunctionCallableImpl (*this)); }

        bool isEqualTo (const CallableImpl &other_)
        {
            const MemberFunctionCallableImpl &other =
                dynamic_cast <const MemberFunctionCallableImpl &> (other_);
            return &other.object == &other.object
                    && other.function == other.function;
        }

        R doCall() { return (object.*function)(); }
    };

    template <typename Class>
    struct ConstMemberFunctionCallableImpl : public CallableImpl
    {
        typedef R (Class::*ConstMemberFunction) () const;

        const Class             &object;
        ConstMemberFunction     function;

        ConstMemberFunctionCallableImpl() {}
        ConstMemberFunctionCallableImpl (const Class &o, ConstMemberFunction f)
        : object (o), function (f) {}
        ~ConstMemberFunctionCallableImpl() {}

        auto_ptr <CallableImpl> copy() const
        { return auto_ptr <CallableImpl>
                                (new ConstMemberFunctionCallableImpl (*this)); }

        bool isEqualTo (const CallableImpl &other_)
        {
            const ConstMemberFunctionCallableImpl &other =
                dynamic_cast <const ConstMemberFunctionCallableImpl &> (other_);
            return &other.object == &other.object
                    && other.function == other.function;
        }

        R doCall() { return (object.*function)(); }
    };

public:
    typedef R       ReturnType;

    Callable() : impl () {}

    Callable (const Callable &other) : impl (other.impl) {}

    Callable (Function f) : impl (FunctionCallableImpl (f)) {}

    template <typename Class>
    Callable (Class &o, R (Class::*f) ())
    : impl (MemberFunctionCallableImpl <Class> (o, f)) {}

    template <typename Class>
    Callable (Class *o, R (Class::*f) ())
    : impl (MemberFunctionCallableImpl <Class> (*o, f)) {}

    template <typename Class>
    Callable (const Class &o, R (Class::*f) () const)
    : impl (ConstMemberFunctionCallableImpl <Class> (o, f)) {}

    template <typename Class>
    Callable (const Class *o, R (Class::*f) () const)
    : impl (ConstMemberFunctionCallableImpl <Class> (*o, f)) {}

    R operator()() { return impl->doCall(); }

    bool operator== (const Callable &other) const { return impl == other.impl; }

    bool operator!= (const Callable &other) const { return impl != other.impl; }

private:
    AbstractValue <CallableImpl, NullCallableImpl> impl;
};

template <typename R, typename P1>
class Callable <R (P1)>
{
    struct CallableImpl
    {
        virtual                         ~CallableImpl() {}
        virtual auto_ptr <CallableImpl> copy() const = 0;
        virtual bool                    isEqualTo (const CallableImpl &) = 0;
        virtual R                       doCall(P1) = 0;
    };

    struct NullCallableImpl : public CallableImpl
    {
        NullCallableImpl() {}
        ~NullCallableImpl() {}

        auto_ptr <CallableImpl> copy() const
        { return auto_ptr <CallableImpl> (new NullCallableImpl ()); }

        bool isEqualTo (const CallableImpl &) { return true; }
        R doCall (P1 a1) { return R(a1); }
    };

    typedef R (*Function)(P1);
    struct FunctionCallableImpl : public CallableImpl
    {
        Function function;

        FunctionCallableImpl (Function f) : function (f) {}
        ~FunctionCallableImpl() {}

        auto_ptr <CallableImpl> copy() const
        { return auto_ptr <CallableImpl> (new FunctionCallableImpl (*this)); }

        bool isEqualTo (const CallableImpl &other_)
        {
            const FunctionCallableImpl &other =
                dynamic_cast <const FunctionCallableImpl &> (other_);
            return other.function == other.function;
        }

        R doCall(P1 a1) { return function(a1); }
    };

    template <typename Class>
    struct MemberFunctionCallableImpl : public CallableImpl
    {
        typedef R (Class::*MemberFunction) (P1);

        Class           &object;
        MemberFunction  function;

        MemberFunctionCallableImpl() {}
        MemberFunctionCallableImpl (Class &o, MemberFunction f)
        : object (o), function (f) {}
        ~MemberFunctionCallableImpl() {}

        auto_ptr <CallableImpl> copy() const
        { return auto_ptr <CallableImpl>
                                    (new MemberFunctionCallableImpl (*this)); }

        bool isEqualTo (const CallableImpl &other_)
        {
            const MemberFunctionCallableImpl &other =
                dynamic_cast <const MemberFunctionCallableImpl &> (other_);
            return &other.object == &other.object
                    && other.function == other.function;
        }

        R doCall(P1 a1) { return (object.*function)(a1); }
    };

    template <typename Class>
    struct ConstMemberFunctionCallableImpl : public CallableImpl
    {
        typedef R (Class::*ConstMemberFunction) (P1) const;

        const Class             &object;
        ConstMemberFunction     function;

        ConstMemberFunctionCallableImpl() {}
        ConstMemberFunctionCallableImpl (const Class &o, ConstMemberFunction f)
        : object (o), function (f) {}
        ~ConstMemberFunctionCallableImpl() {}

        auto_ptr <CallableImpl> copy() const
        { return auto_ptr <CallableImpl>
                                (new ConstMemberFunctionCallableImpl (*this)); }

        bool isEqualTo (const CallableImpl &other_)
        {
            const ConstMemberFunctionCallableImpl &other =
                dynamic_cast <const ConstMemberFunctionCallableImpl &> (other_);
            return &other.object == &other.object
                    && other.function == other.function;
        }

        R doCall(P1 a1) { return (object.*function)(a1); }
    };

public:
    typedef R       ReturnType;
    typedef P1      ParameterType1;

    Callable() : impl () {}

    Callable (const Callable &other) : impl (other.impl) {}

    Callable (Function f) : impl (FunctionCallableImpl (f)) {}

    template <typename Class>
    Callable (Class &o, R (Class::*f) (P1))
    : impl (MemberFunctionCallableImpl <Class> (o, f)) {}

    template <typename Class>
    Callable (Class *o, R (Class::*f) (P1))
    : impl (MemberFunctionCallableImpl <Class> (*o, f)) {}

    template <typename Class>
    Callable (const Class &o, R (Class::*f) (P1) const)
    : impl (ConstMemberFunctionCallableImpl <Class> (o, f)) {}

    template <typename Class>
    Callable (const Class *o, R (Class::*f) (P1) const)
    : impl (ConstMemberFunctionCallableImpl <Class> (*o, f)) {}

    R operator()(P1 a1) { return impl->doCall(a1); }

    bool operator== (const Callable &other) const { return impl == other.impl; }

    bool operator!= (const Callable &other) const { return impl != other.impl; }

private:
    AbstractValue <CallableImpl, NullCallableImpl> impl;
};

template <typename R, typename P1, typename P2>
class Callable <R (P1, P2)>
{
    struct CallableImpl
    {
        virtual                         ~CallableImpl() {}
        virtual auto_ptr <CallableImpl> copy() const = 0;
        virtual bool                    isEqualTo (const CallableImpl &) = 0;
        virtual R                       doCall(P1, P2) = 0;
    };

    struct NullCallableImpl : public CallableImpl
    {
        NullCallableImpl() {}
        ~NullCallableImpl() {}

        auto_ptr <CallableImpl> copy() const
        { return auto_ptr <CallableImpl> (new NullCallableImpl ()); }

        bool isEqualTo (const CallableImpl &) { return true; }
        R doCall (P1 a1, P2 a2) { return R(a1, a2); }
    };

    typedef R (*Function)(P1, P2);
    struct FunctionCallableImpl : public CallableImpl
    {
        Function function;

        FunctionCallableImpl (Function f) : function (f) {}
        ~FunctionCallableImpl() {}

        auto_ptr <CallableImpl> copy() const
        { return auto_ptr <CallableImpl> (new FunctionCallableImpl (*this)); }

        bool isEqualTo (const CallableImpl &other_)
        {
            const FunctionCallableImpl &other =
                dynamic_cast <const FunctionCallableImpl &> (other_);
            return other.function == other.function;
        }

        R doCall(P1 a1, P2 a2) { return function(a1, a2); }
    };

    template <typename Class>
    struct MemberFunctionCallableImpl : public CallableImpl
    {
        typedef R (Class::*MemberFunction) (P1, P2);

        Class           &object;
        MemberFunction  function;

        MemberFunctionCallableImpl() {}
        MemberFunctionCallableImpl (Class &o, MemberFunction f)
        : object (o), function (f) {}
        ~MemberFunctionCallableImpl() {}

        auto_ptr <CallableImpl> copy() const
        { return auto_ptr <CallableImpl>
                                    (new MemberFunctionCallableImpl (*this)); }

        bool isEqualTo (const CallableImpl &other_)
        {
            const MemberFunctionCallableImpl &other =
                dynamic_cast <const MemberFunctionCallableImpl &> (other_);
            return &other.object == &other.object
                    && other.function == other.function;
        }

        R doCall(P1 a1, P2 a2) { return (object.*function)(a1, a2); }
    };

    template <typename Class>
    struct ConstMemberFunctionCallableImpl : public CallableImpl
    {
        typedef R (Class::*ConstMemberFunction) (P1, P2) const;

        const Class             &object;
        ConstMemberFunction     function;

        ConstMemberFunctionCallableImpl() {}
        ConstMemberFunctionCallableImpl (const Class &o, ConstMemberFunction f)
        : object (o), function (f) {}
        ~ConstMemberFunctionCallableImpl() {}

        auto_ptr <CallableImpl> copy() const
        { return auto_ptr <CallableImpl>
                                (new ConstMemberFunctionCallableImpl (*this)); }

        bool isEqualTo (const CallableImpl &other_)
        {
            const ConstMemberFunctionCallableImpl &other =
                dynamic_cast <const ConstMemberFunctionCallableImpl &> (other_);
            return &other.object == &other.object
                    && other.function == other.function;
        }

        R doCall(P1 a1, P2 a2) { return (object.*function)(a1, a2); }
    };

public:
    typedef R       ReturnType;
    typedef P1      ParameterType1;
    typedef P2      ParameterType2;

    Callable() : impl () {}

    Callable (const Callable &other) : impl (other.impl) {}

    Callable (Function f) : impl (FunctionCallableImpl (f)) {}

    template <typename Class>
    Callable (Class &o, R (Class::*f) (P1, P2))
    : impl (MemberFunctionCallableImpl <Class> (o, f)) {}

    template <typename Class>
    Callable (Class *o, R (Class::*f) (P1, P2))
    : impl (MemberFunctionCallableImpl <Class> (*o, f)) {}

    template <typename Class>
    Callable (const Class &o, R (Class::*f) (P1, P2) const)
    : impl (ConstMemberFunctionCallableImpl <Class> (o, f)) {}

    template <typename Class>
    Callable (const Class *o, R (Class::*f) (P1, P2) const)
    : impl (ConstMemberFunctionCallableImpl <Class> (*o, f)) {}

    R operator()(P1 a1, P2 a2) { return impl->doCall(a1, a2); }

    bool operator== (const Callable &other) const { return impl == other.impl; }

    bool operator!= (const Callable &other) const { return impl != other.impl; }

private:
    AbstractValue <CallableImpl, NullCallableImpl> impl;
};

template <typename R, typename P1, typename P2, typename P3>
class Callable <R (P1, P2, P3)>
{
    struct CallableImpl
    {
        virtual                         ~CallableImpl() {}
        virtual auto_ptr <CallableImpl> copy() const = 0;
        virtual bool                    isEqualTo (const CallableImpl &) = 0;
        virtual R                       doCall(P1, P2, P3) = 0;
    };

    struct NullCallableImpl : public CallableImpl
    {
        NullCallableImpl() {}
        ~NullCallableImpl() {}

        auto_ptr <CallableImpl> copy() const
        { return auto_ptr <CallableImpl> (new NullCallableImpl ()); }

        bool isEqualTo (const CallableImpl &) { return true; }
        R doCall (P1 a1, P2 a2, P3 a3) { return R(a1, a2, a3); }
    };

    typedef R (*Function)(P1, P2, P3);
    struct FunctionCallableImpl : public CallableImpl
    {
        Function function;

        FunctionCallableImpl (Function f) : function (f) {}
        ~FunctionCallableImpl() {}

        auto_ptr <CallableImpl> copy() const
        { return auto_ptr <CallableImpl> (new FunctionCallableImpl (*this)); }

        bool isEqualTo (const CallableImpl &other_)
        {
            const FunctionCallableImpl &other =
                dynamic_cast <const FunctionCallableImpl &> (other_);
            return other.function == other.function;
        }

        R doCall(P1 a1, P2 a2, P3 a3) { return function(a1, a2, a3); }
    };

    template <typename Class>
    struct MemberFunctionCallableImpl : public CallableImpl
    {
        typedef R (Class::*MemberFunction) (P1, P2, P3);

        Class           &object;
        MemberFunction  function;

        MemberFunctionCallableImpl() {}
        MemberFunctionCallableImpl (Class &o, MemberFunction f)
        : object (o), function (f) {}
        ~MemberFunctionCallableImpl() {}

        auto_ptr <CallableImpl> copy() const
        { return auto_ptr <CallableImpl>
                                    (new MemberFunctionCallableImpl (*this)); }

        bool isEqualTo (const CallableImpl &other_)
        {
            const MemberFunctionCallableImpl &other =
                dynamic_cast <const MemberFunctionCallableImpl &> (other_);
            return &other.object == &other.object
                    && other.function == other.function;
        }

        R doCall(P1 a1, P2 a2, P3 a3) { return (object.*function)(a1, a2, a3); }
    };

    template <typename Class>
    struct ConstMemberFunctionCallableImpl : public CallableImpl
    {
        typedef R (Class::*ConstMemberFunction) (P1, P2, P3) const;

        const Class             &object;
        ConstMemberFunction     function;

        ConstMemberFunctionCallableImpl() {}
        ConstMemberFunctionCallableImpl (const Class &o, ConstMemberFunction f)
        : object (o), function (f) {}
        ~ConstMemberFunctionCallableImpl() {}

        auto_ptr <CallableImpl> copy() const
        { return auto_ptr <CallableImpl>
                                (new ConstMemberFunctionCallableImpl (*this)); }

        bool isEqualTo (const CallableImpl &other_)
        {
            const ConstMemberFunctionCallableImpl &other =
                dynamic_cast <const ConstMemberFunctionCallableImpl &> (other_);
            return &other.object == &other.object
                    && other.function == other.function;
        }

        R doCall(P1 a1, P2 a2, P3 a3) { return (object.*function)(a1, a2, a3); }
    };

public:
    typedef R       ReturnType;
    typedef P1      ParameterType1;
    typedef P2      ParameterType2;
    typedef P3      ParameterType3;

    Callable() : impl () {}

    Callable (const Callable &other) : impl (other.impl) {}

    Callable (Function f) : impl (FunctionCallableImpl (f)) {}

    template <typename Class>
    Callable (Class &o, R (Class::*f) (P1, P2, P3))
    : impl (MemberFunctionCallableImpl <Class> (o, f)) {}

    template <typename Class>
    Callable (Class *o, R (Class::*f) (P1, P2, P3))
    : impl (MemberFunctionCallableImpl <Class> (*o, f)) {}

    template <typename Class>
    Callable (const Class &o, R (Class::*f) (P1, P2, P3) const)
    : impl (ConstMemberFunctionCallableImpl <Class> (o, f)) {}

    template <typename Class>
    Callable (const Class *o, R (Class::*f) (P1, P2, P3) const)
    : impl (ConstMemberFunctionCallableImpl <Class> (*o, f)) {}

    R operator()(P1 a1, P2 a2, P3 a3) { return impl->doCall(a1, a2, a3); }

    bool operator== (const Callable &other) const { return impl == other.impl; }

    bool operator!= (const Callable &other) const { return impl != other.impl; }

private:
    AbstractValue <CallableImpl, NullCallableImpl> impl;
};

template <typename R, typename P1, typename P2, typename P3, typename P4>
class Callable <R (P1, P2, P3, P4)>
{
    struct CallableImpl
    {
        virtual                         ~CallableImpl() {}
        virtual auto_ptr <CallableImpl> copy() const = 0;
        virtual bool                    isEqualTo (const CallableImpl &) = 0;
        virtual R                       doCall(P1, P2, P3, P4) = 0;
    };

    struct NullCallableImpl : public CallableImpl
    {
        NullCallableImpl() {}
        ~NullCallableImpl() {}

        auto_ptr <CallableImpl> copy() const
        { return auto_ptr <CallableImpl> (new NullCallableImpl ()); }

        bool isEqualTo (const CallableImpl &) { return true; }
        R doCall (P1 a1, P2 a2, P3 a3, P4 a4) { return R(a1, a2, a3, a4); }
    };

    typedef R (*Function)(P1, P2, P3, P4);
    struct FunctionCallableImpl : public CallableImpl
    {
        Function function;

        FunctionCallableImpl (Function f) : function (f) {}
        ~FunctionCallableImpl() {}

        auto_ptr <CallableImpl> copy() const
        { return auto_ptr <CallableImpl> (new FunctionCallableImpl (*this)); }

        bool isEqualTo (const CallableImpl &other_)
        {
            const FunctionCallableImpl &other =
                dynamic_cast <const FunctionCallableImpl &> (other_);
            return other.function == other.function;
        }

        R doCall(P1 a1, P2 a2, P3 a3, P4 a4) { return function(a1, a2, a3, a4); }
    };

    template <typename Class>
    struct MemberFunctionCallableImpl : public CallableImpl
    {
        typedef R (Class::*MemberFunction) (P1, P2, P3, P4);

        Class           &object;
        MemberFunction  function;

        MemberFunctionCallableImpl() {}
        MemberFunctionCallableImpl (Class &o, MemberFunction f)
        : object (o), function (f) {}
        ~MemberFunctionCallableImpl() {}

        auto_ptr <CallableImpl> copy() const
        { return auto_ptr <CallableImpl>
                                    (new MemberFunctionCallableImpl (*this)); }

        bool isEqualTo (const CallableImpl &other_)
        {
            const MemberFunctionCallableImpl &other =
                dynamic_cast <const MemberFunctionCallableImpl &> (other_);
            return &other.object == &other.object
                    && other.function == other.function;
        }

        R doCall(P1 a1, P2 a2, P3 a3, P4 a4) { return (object.*function)(a1, a2, a3, a4); }
    };

    template <typename Class>
    struct ConstMemberFunctionCallableImpl : public CallableImpl
    {
        typedef R (Class::*ConstMemberFunction) (P1, P2, P3, P4) const;

        const Class             &object;
        ConstMemberFunction     function;

        ConstMemberFunctionCallableImpl() {}
        ConstMemberFunctionCallableImpl (const Class &o, ConstMemberFunction f)
        : object (o), function (f) {}
        ~ConstMemberFunctionCallableImpl() {}

        auto_ptr <CallableImpl> copy() const
        { return auto_ptr <CallableImpl>
                                (new ConstMemberFunctionCallableImpl (*this)); }

        bool isEqualTo (const CallableImpl &other_)
        {
            const ConstMemberFunctionCallableImpl &other =
                dynamic_cast <const ConstMemberFunctionCallableImpl &> (other_);
            return &other.object == &other.object
                    && other.function == other.function;
        }

        R doCall(P1 a1, P2 a2, P3 a3, P4 a4) { return (object.*function)(a1, a2, a3, a4); }
    };

public:
    typedef R       ReturnType;
    typedef P1      ParameterType1;
    typedef P2      ParameterType2;
    typedef P3      ParameterType3;
    typedef P4      ParameterType4;

    Callable() : impl () {}

    Callable (const Callable &other) : impl (other.impl) {}

    Callable (Function f) : impl (FunctionCallableImpl (f)) {}

    template <typename Class>
    Callable (Class &o, R (Class::*f) (P1, P2, P3, P4))
    : impl (MemberFunctionCallableImpl <Class> (o, f)) {}

    template <typename Class>
    Callable (Class *o, R (Class::*f) (P1, P2, P3, P4))
    : impl (MemberFunctionCallableImpl <Class> (*o, f)) {}

    template <typename Class>
    Callable (const Class &o, R (Class::*f) (P1, P2, P3, P4) const)
    : impl (ConstMemberFunctionCallableImpl <Class> (o, f)) {}

    template <typename Class>
    Callable (const Class *o, R (Class::*f) (P1, P2, P3, P4) const)
    : impl (ConstMemberFunctionCallableImpl <Class> (*o, f)) {}

    R operator()(P1 a1, P2 a2, P3 a3, P4 a4) { return impl->doCall(a1, a2, a3, a4); }

    bool operator== (const Callable &other) const { return impl == other.impl; }

    bool operator!= (const Callable &other) const { return impl != other.impl; }

private:
    AbstractValue <CallableImpl, NullCallableImpl> impl;
};

template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5>
class Callable <R (P1, P2, P3, P4, P5)>
{
    struct CallableImpl
    {
        virtual                         ~CallableImpl() {}
        virtual auto_ptr <CallableImpl> copy() const = 0;
        virtual bool                    isEqualTo (const CallableImpl &) = 0;
        virtual R                       doCall(P1, P2, P3, P4, P5) = 0;
    };

    struct NullCallableImpl : public CallableImpl
    {
        NullCallableImpl() {}
        ~NullCallableImpl() {}

        auto_ptr <CallableImpl> copy() const
        { return auto_ptr <CallableImpl> (new NullCallableImpl ()); }

        bool isEqualTo (const CallableImpl &) { return true; }
        R doCall (P1 a1, P2 a2, P3 a3, P4 a4, P5 a5) { return R(a1, a2, a3, a4, a5); }
    };

    typedef R (*Function)(P1, P2, P3, P4, P5);
    struct FunctionCallableImpl : public CallableImpl
    {
        Function function;

        FunctionCallableImpl (Function f) : function (f) {}
        ~FunctionCallableImpl() {}

        auto_ptr <CallableImpl> copy() const
        { return auto_ptr <CallableImpl> (new FunctionCallableImpl (*this)); }

        bool isEqualTo (const CallableImpl &other_)
        {
            const FunctionCallableImpl &other =
                dynamic_cast <const FunctionCallableImpl &> (other_);
            return other.function == other.function;
        }

        R doCall(P1 a1, P2 a2, P3 a3, P4 a4, P5 a5) { return function(a1, a2, a3, a4, a5); }
    };

    template <typename Class>
    struct MemberFunctionCallableImpl : public CallableImpl
    {
        typedef R (Class::*MemberFunction) (P1, P2, P3, P4, P5);

        Class           &object;
        MemberFunction  function;

        MemberFunctionCallableImpl() {}
        MemberFunctionCallableImpl (Class &o, MemberFunction f)
        : object (o), function (f) {}
        ~MemberFunctionCallableImpl() {}

        auto_ptr <CallableImpl> copy() const
        { return auto_ptr <CallableImpl>
                                    (new MemberFunctionCallableImpl (*this)); }

        bool isEqualTo (const CallableImpl &other_)
        {
            const MemberFunctionCallableImpl &other =
                dynamic_cast <const MemberFunctionCallableImpl &> (other_);
            return &other.object == &other.object
                    && other.function == other.function;
        }

        R doCall(P1 a1, P2 a2, P3 a3, P4 a4, P5 a5) { return (object.*function)(a1, a2, a3, a4, a5); }
    };

    template <typename Class>
    struct ConstMemberFunctionCallableImpl : public CallableImpl
    {
        typedef R (Class::*ConstMemberFunction) (P1, P2, P3, P4, P5) const;

        const Class             &object;
        ConstMemberFunction     function;

        ConstMemberFunctionCallableImpl() {}
        ConstMemberFunctionCallableImpl (const Class &o, ConstMemberFunction f)
        : object (o), function (f) {}
        ~ConstMemberFunctionCallableImpl() {}

        auto_ptr <CallableImpl> copy() const
        { return auto_ptr <CallableImpl>
                                (new ConstMemberFunctionCallableImpl (*this)); }

        bool isEqualTo (const CallableImpl &other_)
        {
            const ConstMemberFunctionCallableImpl &other =
                dynamic_cast <const ConstMemberFunctionCallableImpl &> (other_);
            return &other.object == &other.object
                    && other.function == other.function;
        }

        R doCall(P1 a1, P2 a2, P3 a3, P4 a4, P5 a5) { return (object.*function)(a1, a2, a3, a4, a5); }
    };

public:
    typedef R       ReturnType;
    typedef P1      ParameterType1;
    typedef P2      ParameterType2;
    typedef P3      ParameterType3;
    typedef P4      ParameterType4;
    typedef P5      ParameterType5;

    Callable() : impl () {}

    Callable (const Callable &other) : impl (other.impl) {}

    Callable (Function f) : impl (FunctionCallableImpl (f)) {}

    template <typename Class>
    Callable (Class &o, R (Class::*f) (P1, P2, P3, P4, P5))
    : impl (MemberFunctionCallableImpl <Class> (o, f)) {}

    template <typename Class>
    Callable (Class *o, R (Class::*f) (P1, P2, P3, P4, P5))
    : impl (MemberFunctionCallableImpl <Class> (*o, f)) {}

    template <typename Class>
    Callable (const Class &o, R (Class::*f) (P1, P2, P3, P4, P5) const)
    : impl (ConstMemberFunctionCallableImpl <Class> (o, f)) {}

    template <typename Class>
    Callable (const Class *o, R (Class::*f) (P1, P2, P3, P4, P5) const)
    : impl (ConstMemberFunctionCallableImpl <Class> (*o, f)) {}

    R operator()(P1 a1, P2 a2, P3 a3, P4 a4, P5 a5) { return impl->doCall(a1, a2, a3, a4, a5); }

    bool operator== (const Callable &other) const { return impl == other.impl; }

    bool operator!= (const Callable &other) const { return impl != other.impl; }

private:
    AbstractValue <CallableImpl, NullCallableImpl> impl;
};

template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6>
class Callable <R (P1, P2, P3, P4, P5, P6)>
{
    struct CallableImpl
    {
        virtual                         ~CallableImpl() {}
        virtual auto_ptr <CallableImpl> copy() const = 0;
        virtual bool                    isEqualTo (const CallableImpl &) = 0;
        virtual R                       doCall(P1, P2, P3, P4, P5, P6) = 0;
    };

    struct NullCallableImpl : public CallableImpl
    {
        NullCallableImpl() {}
        ~NullCallableImpl() {}

        auto_ptr <CallableImpl> copy() const
        { return auto_ptr <CallableImpl> (new NullCallableImpl ()); }

        bool isEqualTo (const CallableImpl &) { return true; }
        R doCall (P1 a1, P2 a2, P3 a3, P4 a4, P5 a5, P6 a6) { return R(a1, a2, a3, a4, a5, a6); }
    };

    typedef R (*Function)(P1, P2, P3, P4, P5, P6);
    struct FunctionCallableImpl : public CallableImpl
    {
        Function function;

        FunctionCallableImpl (Function f) : function (f) {}
        ~FunctionCallableImpl() {}

        auto_ptr <CallableImpl> copy() const
        { return auto_ptr <CallableImpl> (new FunctionCallableImpl (*this)); }

        bool isEqualTo (const CallableImpl &other_)
        {
            const FunctionCallableImpl &other =
                dynamic_cast <const FunctionCallableImpl &> (other_);
            return other.function == other.function;
        }

        R doCall(P1 a1, P2 a2, P3 a3, P4 a4, P5 a5, P6 a6) { return function(a1, a2, a3, a4, a5, a6); }
    };

    template <typename Class>
    struct MemberFunctionCallableImpl : public CallableImpl
    {
        typedef R (Class::*MemberFunction) (P1, P2, P3, P4, P5, P6);

        Class           &object;
        MemberFunction  function;

        MemberFunctionCallableImpl() {}
        MemberFunctionCallableImpl (Class &o, MemberFunction f)
        : object (o), function (f) {}
        ~MemberFunctionCallableImpl() {}

        auto_ptr <CallableImpl> copy() const
        { return auto_ptr <CallableImpl>
                                    (new MemberFunctionCallableImpl (*this)); }

        bool isEqualTo (const CallableImpl &other_)
        {
            const MemberFunctionCallableImpl &other =
                dynamic_cast <const MemberFunctionCallableImpl &> (other_);
            return &other.object == &other.object
                    && other.function == other.function;
        }

        R doCall(P1 a1, P2 a2, P3 a3, P4 a4, P5 a5, P6 a6) { return (object.*function)(a1, a2, a3, a4, a5, a6); }
    };

    template <typename Class>
    struct ConstMemberFunctionCallableImpl : public CallableImpl
    {
        typedef R (Class::*ConstMemberFunction) (P1, P2, P3, P4, P5, P6) const;

        const Class             &object;
        ConstMemberFunction     function;

        ConstMemberFunctionCallableImpl() {}
        ConstMemberFunctionCallableImpl (const Class &o, ConstMemberFunction f)
        : object (o), function (f) {}
        ~ConstMemberFunctionCallableImpl() {}

        auto_ptr <CallableImpl> copy() const
        { return auto_ptr <CallableImpl>
                                (new ConstMemberFunctionCallableImpl (*this)); }

        bool isEqualTo (const CallableImpl &other_)
        {
            const ConstMemberFunctionCallableImpl &other =
                dynamic_cast <const ConstMemberFunctionCallableImpl &> (other_);
            return &other.object == &other.object
                    && other.function == other.function;
        }

        R doCall(P1 a1, P2 a2, P3 a3, P4 a4, P5 a5, P6 a6) { return (object.*function)(a1, a2, a3, a4, a5, a6); }
    };

public:
    typedef R       ReturnType;
    typedef P1      ParameterType1;
    typedef P2      ParameterType2;
    typedef P3      ParameterType3;
    typedef P4      ParameterType4;
    typedef P5      ParameterType5;
    typedef P6      ParameterType6;

    Callable() : impl () {}

    Callable (const Callable &other) : impl (other.impl) {}

    Callable (Function f) : impl (FunctionCallableImpl (f)) {}

    template <typename Class>
    Callable (Class &o, R (Class::*f) (P1, P2, P3, P4, P5, P6))
    : impl (MemberFunctionCallableImpl <Class> (o, f)) {}

    template <typename Class>
    Callable (Class *o, R (Class::*f) (P1, P2, P3, P4, P5, P6))
    : impl (MemberFunctionCallableImpl <Class> (*o, f)) {}

    template <typename Class>
    Callable (const Class &o, R (Class::*f) (P1, P2, P3, P4, P5, P6) const)
    : impl (ConstMemberFunctionCallableImpl <Class> (o, f)) {}

    template <typename Class>
    Callable (const Class *o, R (Class::*f) (P1, P2, P3, P4, P5, P6) const)
    : impl (ConstMemberFunctionCallableImpl <Class> (*o, f)) {}

    R operator()(P1 a1, P2 a2, P3 a3, P4 a4, P5 a5, P6 a6) { return impl->doCall(a1, a2, a3, a4, a5, a6); }

    bool operator== (const Callable &other) const { return impl == other.impl; }

    bool operator!= (const Callable &other) const { return impl != other.impl; }

private:
    AbstractValue <CallableImpl, NullCallableImpl> impl;
};

template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7>
class Callable <R (P1, P2, P3, P4, P5, P6, P7)>
{
    struct CallableImpl
    {
        virtual                         ~CallableImpl() {}
        virtual auto_ptr <CallableImpl> copy() const = 0;
        virtual bool                    isEqualTo (const CallableImpl &) = 0;
        virtual R                       doCall(P1, P2, P3, P4, P5, P6, P7) = 0;
    };

    struct NullCallableImpl : public CallableImpl
    {
        NullCallableImpl() {}
        ~NullCallableImpl() {}

        auto_ptr <CallableImpl> copy() const
        { return auto_ptr <CallableImpl> (new NullCallableImpl ()); }

        bool isEqualTo (const CallableImpl &) { return true; }
        R doCall (P1 a1, P2 a2, P3 a3, P4 a4, P5 a5, P6 a6, P7 a7) { return R(a1, a2, a3, a4, a5, a6, a7); }
    };

    typedef R (*Function)(P1, P2, P3, P4, P5, P6, P7);
    struct FunctionCallableImpl : public CallableImpl
    {
        Function function;

        FunctionCallableImpl (Function f) : function (f) {}
        ~FunctionCallableImpl() {}

        auto_ptr <CallableImpl> copy() const
        { return auto_ptr <CallableImpl> (new FunctionCallableImpl (*this)); }

        bool isEqualTo (const CallableImpl &other_)
        {
            const FunctionCallableImpl &other =
                dynamic_cast <const FunctionCallableImpl &> (other_);
            return other.function == other.function;
        }

        R doCall(P1 a1, P2 a2, P3 a3, P4 a4, P5 a5, P6 a6, P7 a7) { return function(a1, a2, a3, a4, a5, a6, a7); }
    };

    template <typename Class>
    struct MemberFunctionCallableImpl : public CallableImpl
    {
        typedef R (Class::*MemberFunction) (P1, P2, P3, P4, P5, P6, P7);

        Class           &object;
        MemberFunction  function;

        MemberFunctionCallableImpl() {}
        MemberFunctionCallableImpl (Class &o, MemberFunction f)
        : object (o), function (f) {}
        ~MemberFunctionCallableImpl() {}

        auto_ptr <CallableImpl> copy() const
        { return auto_ptr <CallableImpl>
                                    (new MemberFunctionCallableImpl (*this)); }

        bool isEqualTo (const CallableImpl &other_)
        {
            const MemberFunctionCallableImpl &other =
                dynamic_cast <const MemberFunctionCallableImpl &> (other_);
            return &other.object == &other.object
                    && other.function == other.function;
        }

        R doCall(P1 a1, P2 a2, P3 a3, P4 a4, P5 a5, P6 a6, P7 a7) { return (object.*function)(a1, a2, a3, a4, a5, a6, a7); }
    };

    template <typename Class>
    struct ConstMemberFunctionCallableImpl : public CallableImpl
    {
        typedef R (Class::*ConstMemberFunction) (P1, P2, P3, P4, P5, P6, P7) const;

        const Class             &object;
        ConstMemberFunction     function;

        ConstMemberFunctionCallableImpl() {}
        ConstMemberFunctionCallableImpl (const Class &o, ConstMemberFunction f)
        : object (o), function (f) {}
        ~ConstMemberFunctionCallableImpl() {}

        auto_ptr <CallableImpl> copy() const
        { return auto_ptr <CallableImpl>
                                (new ConstMemberFunctionCallableImpl (*this)); }

        bool isEqualTo (const CallableImpl &other_)
        {
            const ConstMemberFunctionCallableImpl &other =
                dynamic_cast <const ConstMemberFunctionCallableImpl &> (other_);
            return &other.object == &other.object
                    && other.function == other.function;
        }

        R doCall(P1 a1, P2 a2, P3 a3, P4 a4, P5 a5, P6 a6, P7 a7) { return (object.*function)(a1, a2, a3, a4, a5, a6, a7); }
    };

public:
    typedef R       ReturnType;
    typedef P1      ParameterType1;
    typedef P2      ParameterType2;
    typedef P3      ParameterType3;
    typedef P4      ParameterType4;
    typedef P5      ParameterType5;
    typedef P6      ParameterType6;
    typedef P7      ParameterType7;

    Callable() : impl () {}

    Callable (const Callable &other) : impl (other.impl) {}

    Callable (Function f) : impl (FunctionCallableImpl (f)) {}

    template <typename Class>
    Callable (Class &o, R (Class::*f) (P1, P2, P3, P4, P5, P6, P7))
    : impl (MemberFunctionCallableImpl <Class> (o, f)) {}

    template <typename Class>
    Callable (Class *o, R (Class::*f) (P1, P2, P3, P4, P5, P6, P7))
    : impl (MemberFunctionCallableImpl <Class> (*o, f)) {}

    template <typename Class>
    Callable (const Class &o, R (Class::*f) (P1, P2, P3, P4, P5, P6, P7) const)
    : impl (ConstMemberFunctionCallableImpl <Class> (o, f)) {}

    template <typename Class>
    Callable (const Class *o, R (Class::*f) (P1, P2, P3, P4, P5, P6, P7) const)
    : impl (ConstMemberFunctionCallableImpl <Class> (*o, f)) {}

    R operator()(P1 a1, P2 a2, P3 a3, P4 a4, P5 a5, P6 a6, P7 a7) { return impl->doCall(a1, a2, a3, a4, a5, a6, a7); }

    bool operator== (const Callable &other) const { return impl == other.impl; }

    bool operator!= (const Callable &other) const { return impl != other.impl; }

private:
    AbstractValue <CallableImpl, NullCallableImpl> impl;
};

template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8>
class Callable <R (P1, P2, P3, P4, P5, P6, P7, P8)>
{
    struct CallableImpl
    {
        virtual                         ~CallableImpl() {}
        virtual auto_ptr <CallableImpl> copy() const = 0;
        virtual bool                    isEqualTo (const CallableImpl &) = 0;
        virtual R                       doCall(P1, P2, P3, P4, P5, P6, P7, P8) = 0;
    };

    struct NullCallableImpl : public CallableImpl
    {
        NullCallableImpl() {}
        ~NullCallableImpl() {}

        auto_ptr <CallableImpl> copy() const
        { return auto_ptr <CallableImpl> (new NullCallableImpl ()); }

        bool isEqualTo (const CallableImpl &) { return true; }
        R doCall (P1 a1, P2 a2, P3 a3, P4 a4, P5 a5, P6 a6, P7 a7, P8 a8) { return R(a1, a2, a3, a4, a5, a6, a7, a8); }
    };

    typedef R (*Function)(P1, P2, P3, P4, P5, P6, P7, P8);
    struct FunctionCallableImpl : public CallableImpl
    {
        Function function;

        FunctionCallableImpl (Function f) : function (f) {}
        ~FunctionCallableImpl() {}

        auto_ptr <CallableImpl> copy() const
        { return auto_ptr <CallableImpl> (new FunctionCallableImpl (*this)); }

        bool isEqualTo (const CallableImpl &other_)
        {
            const FunctionCallableImpl &other =
                dynamic_cast <const FunctionCallableImpl &> (other_);
            return other.function == other.function;
        }

        R doCall(P1 a1, P2 a2, P3 a3, P4 a4, P5 a5, P6 a6, P7 a7, P8 a8) { return function(a1, a2, a3, a4, a5, a6, a7, a8); }
    };

    template <typename Class>
    struct MemberFunctionCallableImpl : public CallableImpl
    {
        typedef R (Class::*MemberFunction) (P1, P2, P3, P4, P5, P6, P7, P8);

        Class           &object;
        MemberFunction  function;

        MemberFunctionCallableImpl() {}
        MemberFunctionCallableImpl (Class &o, MemberFunction f)
        : object (o), function (f) {}
        ~MemberFunctionCallableImpl() {}

        auto_ptr <CallableImpl> copy() const
        { return auto_ptr <CallableImpl>
                                    (new MemberFunctionCallableImpl (*this)); }

        bool isEqualTo (const CallableImpl &other_)
        {
            const MemberFunctionCallableImpl &other =
                dynamic_cast <const MemberFunctionCallableImpl &> (other_);
            return &other.object == &other.object
                    && other.function == other.function;
        }

        R doCall(P1 a1, P2 a2, P3 a3, P4 a4, P5 a5, P6 a6, P7 a7, P8 a8) { return (object.*function)(a1, a2, a3, a4, a5, a6, a7, a8); }
    };

    template <typename Class>
    struct ConstMemberFunctionCallableImpl : public CallableImpl
    {
        typedef R (Class::*ConstMemberFunction) (P1, P2, P3, P4, P5, P6, P7, P8) const;

        const Class             &object;
        ConstMemberFunction     function;

        ConstMemberFunctionCallableImpl() {}
        ConstMemberFunctionCallableImpl (const Class &o, ConstMemberFunction f)
        : object (o), function (f) {}
        ~ConstMemberFunctionCallableImpl() {}

        auto_ptr <CallableImpl> copy() const
        { return auto_ptr <CallableImpl>
                                (new ConstMemberFunctionCallableImpl (*this)); }

        bool isEqualTo (const CallableImpl &other_)
        {
            const ConstMemberFunctionCallableImpl &other =
                dynamic_cast <const ConstMemberFunctionCallableImpl &> (other_);
            return &other.object == &other.object
                    && other.function == other.function;
        }

        R doCall(P1 a1, P2 a2, P3 a3, P4 a4, P5 a5, P6 a6, P7 a7, P8 a8) { return (object.*function)(a1, a2, a3, a4, a5, a6, a7, a8); }
    };

public:
    typedef R       ReturnType;
    typedef P1      ParameterType1;
    typedef P2      ParameterType2;
    typedef P3      ParameterType3;
    typedef P4      ParameterType4;
    typedef P5      ParameterType5;
    typedef P6      ParameterType6;
    typedef P7      ParameterType7;
    typedef P8      ParameterType8;

    Callable() : impl () {}

    Callable (const Callable &other) : impl (other.impl) {}

    Callable (Function f) : impl (FunctionCallableImpl (f)) {}

    template <typename Class>
    Callable (Class &o, R (Class::*f) (P1, P2, P3, P4, P5, P6, P7, P8))
    : impl (MemberFunctionCallableImpl <Class> (o, f)) {}

    template <typename Class>
    Callable (Class *o, R (Class::*f) (P1, P2, P3, P4, P5, P6, P7, P8))
    : impl (MemberFunctionCallableImpl <Class> (*o, f)) {}

    template <typename Class>
    Callable (const Class &o, R (Class::*f) (P1, P2, P3, P4, P5, P6, P7, P8) const)
    : impl (ConstMemberFunctionCallableImpl <Class> (o, f)) {}

    template <typename Class>
    Callable (const Class *o, R (Class::*f) (P1, P2, P3, P4, P5, P6, P7, P8) const)
    : impl (ConstMemberFunctionCallableImpl <Class> (*o, f)) {}

    R operator()(P1 a1, P2 a2, P3 a3, P4 a4, P5 a5, P6 a6, P7 a7, P8 a8) { return impl->doCall(a1, a2, a3, a4, a5, a6, a7, a8); }

    bool operator== (const Callable &other) const { return impl == other.impl; }

    bool operator!= (const Callable &other) const { return impl != other.impl; }

private:
    AbstractValue <CallableImpl, NullCallableImpl> impl;
};

template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9>
class Callable <R (P1, P2, P3, P4, P5, P6, P7, P8, P9)>
{
    struct CallableImpl
    {
        virtual                         ~CallableImpl() {}
        virtual auto_ptr <CallableImpl> copy() const = 0;
        virtual bool                    isEqualTo (const CallableImpl &) = 0;
        virtual R                       doCall(P1, P2, P3, P4, P5, P6, P7, P8, P9) = 0;
    };

    struct NullCallableImpl : public CallableImpl
    {
        NullCallableImpl() {}
        ~NullCallableImpl() {}

        auto_ptr <CallableImpl> copy() const
        { return auto_ptr <CallableImpl> (new NullCallableImpl ()); }

        bool isEqualTo (const CallableImpl &) { return true; }
        R doCall (P1 a1, P2 a2, P3 a3, P4 a4, P5 a5, P6 a6, P7 a7, P8 a8, P9 a9) { return R(a1, a2, a3, a4, a5, a6, a7, a8, a9); }
    };

    typedef R (*Function)(P1, P2, P3, P4, P5, P6, P7, P8, P9);
    struct FunctionCallableImpl : public CallableImpl
    {
        Function function;

        FunctionCallableImpl (Function f) : function (f) {}
        ~FunctionCallableImpl() {}

        auto_ptr <CallableImpl> copy() const
        { return auto_ptr <CallableImpl> (new FunctionCallableImpl (*this)); }

        bool isEqualTo (const CallableImpl &other_)
        {
            const FunctionCallableImpl &other =
                dynamic_cast <const FunctionCallableImpl &> (other_);
            return other.function == other.function;
        }

        R doCall(P1 a1, P2 a2, P3 a3, P4 a4, P5 a5, P6 a6, P7 a7, P8 a8, P9 a9) { return function(a1, a2, a3, a4, a5, a6, a7, a8, a9); }
    };

    template <typename Class>
    struct MemberFunctionCallableImpl : public CallableImpl
    {
        typedef R (Class::*MemberFunction) (P1, P2, P3, P4, P5, P6, P7, P8, P9);

        Class           &object;
        MemberFunction  function;

        MemberFunctionCallableImpl() {}
        MemberFunctionCallableImpl (Class &o, MemberFunction f)
        : object (o), function (f) {}
        ~MemberFunctionCallableImpl() {}

        auto_ptr <CallableImpl> copy() const
        { return auto_ptr <CallableImpl>
                                    (new MemberFunctionCallableImpl (*this)); }

        bool isEqualTo (const CallableImpl &other_)
        {
            const MemberFunctionCallableImpl &other =
                dynamic_cast <const MemberFunctionCallableImpl &> (other_);
            return &other.object == &other.object
                    && other.function == other.function;
        }

        R doCall(P1 a1, P2 a2, P3 a3, P4 a4, P5 a5, P6 a6, P7 a7, P8 a8, P9 a9) { return (object.*function)(a1, a2, a3, a4, a5, a6, a7, a8, a9); }
    };

    template <typename Class>
    struct ConstMemberFunctionCallableImpl : public CallableImpl
    {
        typedef R (Class::*ConstMemberFunction) (P1, P2, P3, P4, P5, P6, P7, P8, P9) const;

        const Class             &object;
        ConstMemberFunction     function;

        ConstMemberFunctionCallableImpl() {}
        ConstMemberFunctionCallableImpl (const Class &o, ConstMemberFunction f)
        : object (o), function (f) {}
        ~ConstMemberFunctionCallableImpl() {}

        auto_ptr <CallableImpl> copy() const
        { return auto_ptr <CallableImpl>
                                (new ConstMemberFunctionCallableImpl (*this)); }

        bool isEqualTo (const CallableImpl &other_)
        {
            const ConstMemberFunctionCallableImpl &other =
                dynamic_cast <const ConstMemberFunctionCallableImpl &> (other_);
            return &other.object == &other.object
                    && other.function == other.function;
        }

        R doCall(P1 a1, P2 a2, P3 a3, P4 a4, P5 a5, P6 a6, P7 a7, P8 a8, P9 a9) { return (object.*function)(a1, a2, a3, a4, a5, a6, a7, a8, a9); }
    };

public:
    typedef R       ReturnType;
    typedef P1      ParameterType1;
    typedef P2      ParameterType2;
    typedef P3      ParameterType3;
    typedef P4      ParameterType4;
    typedef P5      ParameterType5;
    typedef P6      ParameterType6;
    typedef P7      ParameterType7;
    typedef P8      ParameterType8;
    typedef P9      ParameterType9;

    Callable() : impl () {}

    Callable (const Callable &other) : impl (other.impl) {}

    Callable (Function f) : impl (FunctionCallableImpl (f)) {}

    template <typename Class>
    Callable (Class &o, R (Class::*f) (P1, P2, P3, P4, P5, P6, P7, P8, P9))
    : impl (MemberFunctionCallableImpl <Class> (o, f)) {}

    template <typename Class>
    Callable (Class *o, R (Class::*f) (P1, P2, P3, P4, P5, P6, P7, P8, P9))
    : impl (MemberFunctionCallableImpl <Class> (*o, f)) {}

    template <typename Class>
    Callable (const Class &o, R (Class::*f) (P1, P2, P3, P4, P5, P6, P7, P8, P9) const)
    : impl (ConstMemberFunctionCallableImpl <Class> (o, f)) {}

    template <typename Class>
    Callable (const Class *o, R (Class::*f) (P1, P2, P3, P4, P5, P6, P7, P8, P9) const)
    : impl (ConstMemberFunctionCallableImpl <Class> (*o, f)) {}

    R operator()(P1 a1, P2 a2, P3 a3, P4 a4, P5 a5, P6 a6, P7 a7, P8 a8, P9 a9) { return impl->doCall(a1, a2, a3, a4, a5, a6, a7, a8, a9); }

    bool operator== (const Callable &other) const { return impl == other.impl; }

    bool operator!= (const Callable &other) const { return impl != other.impl; }

private:
    AbstractValue <CallableImpl, NullCallableImpl> impl;
};


} // namespace Utils

#endif // UTILS__CALLABLE_H

Copyright © 2006 Peter Dimov.
Powered by Doxygen.