---

action.h

Go to the documentation of this file.

/*
 * Copyright (c) 2001 The AUTHORS 
 *   Romeu Andre' Pieritz, Ph.D.        - romeu_pieritz@hotmail.com
 *   Rafael Mendes, Eng.                – mendes_rafael@yahoo.com
 *   Rodrigo Ferraz de Andrade, Eng.    – rferraz@iname.com 
 * All rights reserved.
 *
 * Permission to use, copy and distribute this software and its
 * documentation for educational and personal use, without fee is hereby granted, 
 * provided that the above copyright notice and the following
 * two paragraphs appear in all copies of this software.
 *
 * IN NO EVENT SHALL THE AUTHORS BE LIABLE TO ANY PARTY FOR
 * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT
 * OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF THE AUTHORS
 * HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * THE AUTHORS SPECIFICALLY DISCLAIMS ANY WARRANTIES,
 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
 * AND FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HERE UNDER IS
 * ON AN "AS IS" BASIS, AND THE AUTHORS HAVE NO OBLIGATION TO
 * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
 *
 * SINMEC Lab. - CFD Sinflow Project - http://www.sinmec.ufsc.br/cfd
 */


// File Define
#ifndef __CSFL_SYS_CORE_ACTION_H__
#define __CSFL_SYS_CORE_ACTION_H__


// Include
#include <csfl/sys/core/sflobject.h>


// Namespace
namespace csfl {


//==============================================================================
// template IMethod
//==============================================================================

class IMethod
{
// ----------------------------------------------------------------------- C & D
public:
        IMethod( void *_receiver = NULL ) :
                receiver( _receiver )
        {}

// -------------------------------------------------------------------- Receiver
public:
        void *receiver;
};

//==============================================================================
// template IMethod1Of
//==============================================================================

template <class H, class T1>
class IMethod1Of : public IMethod
{
public:
        typedef void (H::*Method)( T1 );

// ----------------------------------------------------------------------- C & D
public:
        IMethod1Of( void *_receiver = NULL, Method _method = NULL ) :
                IMethod( _receiver ),
                method( _method )
        {}

// -----------------------------------------------------------------------------
public:
        bool Call( T1 ) const;

// -----------------------------------------------------------------------------
public:
        IMethod1Of<H,T1> & operator = ( const IMethod1Of<H,T1> & );

        inline bool     operator == ( const IMethod1Of<H,T1> &_method ) const
                { return receiver==_method.receiver && method==_method.method; }

// -----------------------------------------------------------------------------
public:
        Method method;
};

//==============================================================================
// template class IActionBaseOf
//==============================================================================

template <class P_Method>
class IActionBaseOf
{
// ----------------------------------------------------------------------- C & D
public:
        IActionBaseOf() :
                method()
        {}

        IActionBaseOf( const P_Method &_method ) :
                method( _method )
        {}

// ---------------------------------------------------------------------- Method
public:
        IActionBaseOf<P_Method> & Set( const P_Method & );

        bool IsAssigned() const
                { return method.receiver != 0 && method.method != 0; }

public:
        void Clear()
                { method.receiver = 0; method.method = NULL; } 

public: // Attributes
        P_Method method;

// --------------------------------------------------------------------- Compare
public:
        bool operator ==( const IActionBaseOf<P_Method> &_action ) const
                { return method == _action.method; }
        bool operator ==( const P_Method &_method ) const
                { return method == _method; }
};

// IMethod1Of ==================================================================

template <class H, class T1>
bool IMethod1Of<H,T1>::Call( T1 _arg1 ) const
{
        bool result( receiver && method );
        if (result)
                (((H *)receiver)->*method)( _arg1 );
        return result;
}

template <class H, class T1>
IMethod1Of<H,T1> & IMethod1Of<H,T1>::operator = (
        const IMethod1Of<H,T1> & _method )
{
        receiver = _method.receiver;
        method = _method.method;
        return *this;
}

template <class C, class R, class T1>
inline IMethod1Of<ISFLObject,T1> ExecuteMethod( void (C::*method)(T1), R *receiver )
{
        IMethod1Of<ISFLObject,T1> result;
        C *cReceiver = receiver;
        result.receiver = cReceiver;
        memcpy( &result.method, &method, sizeof result.method );
        return result;
}

//==============================================================================
// template class IAction1Of<Handler>
//==============================================================================

template <class H, class T1>
class IAction1Of :
        public IActionBaseOf< IMethod1Of<H,T1> >
{
// ----------------------------------------------------------------------- C & D
public:
        IAction1Of() :
                IActionBaseOf< IMethod1Of<H,T1> >()
        {}

        IAction1Of( const IMethod1Of<H,T1> &_method ) :
                IActionBaseOf< IMethod1Of<H,T1> >( _method )
        {}

// --------------------------------------------------------------------- Methods
public:
        bool Call( T1 _arg1 ) const
                { return method.Call( _arg1 ); }

// -------------------------------------------------------------------- Operator
public:
        IActionBaseOf< IMethod1Of<H,T1> > & operator =(
                const IMethod1Of<H,T1> &_method )
                { return Set( _method ); }
};


// Implementations =============================================================

template <class P_Method>
IActionBaseOf<P_Method> & IActionBaseOf<P_Method>::Set(
        const P_Method &_method )
{
        method = _method;
        return *this;
}



typedef IAction1Of<ISFLObject, ISFLObject *> IAction;


} // csfl namespace

#endif // __CSFL_SYS_CORE_ACTION_H__

 

CFD Project | Documents | Downloads | Contact us | Use Terms
© SINMEC/EMC/UFSC, 2001.	All rights reserved.	Last Update: Jan. 18, 2002	Webmaster