DelegateMixin.hh

Go to the documentation of this file.

/*
 * DelegateMixin.hh
 *
 * Copyright (c) 2003 The University of Utah and the Flux Group.
 * All rights reserved.
 *
 * This file is licensed under the terms of the GNU Public License.  
 * See the file "license.terms" for restrictions on redistribution 
 * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
 */

/**
 * @file DelegateMixin.hh
 *
 * Header file for the DelegateMixin class.
 */

#ifndef _delegate_mixin_hh
#define _delegate_mixin_hh

#include "DelegateS.h"

/**
 * Base class for objects that wish to act as a delegate.
 *
 * @param T The main object type.
 * @param T_var The object's _var type.
 */
template <class T, class T_var> class DelegateMixin :
    public virtual POA_BrokerDelegates::Delegate
{

public:

    /**
     * Construct a DelegateMixin with the default values.
     */
    DelegateMixin(void)
    {
    };

    /**
     * Deconstruct a DelegateMixin.
     */
    virtual ~DelegateMixin(void)
    {
    };

    /** @copydoc BrokerDelegates::Delegate::SetDelegateAttribute */
    virtual void SetDelegateAttribute(const char *id,
                                      const CORBA::Any &value)
        throw (CORBA::SystemException)
    {
        if( id == NULL )
        {
            throw CORBA::BAD_PARAM();
        }
        else if( strcasecmp(id, "remote-object") == 0 )
        {
            CORBA::Object_var obj;

            if( value >>= CORBA::Any::to_object(obj) )
            {
                this->dm_RemoteObject = T::_narrow(obj.in());
            }
            else
            {
                throw CORBA::BAD_PARAM();
            }
        }
        else
        {
            throw CORBA::BAD_PARAM();
        }
    };

    /** @copydoc BrokerDelegates::Delegate::GetDelegateAttribute */
    virtual CORBA::Any_ptr GetDelegateAttribute(const char *id)
        throw (CORBA::SystemException)
    {
        CORBA::Any_var retval = new CORBA::Any();

        if( id == NULL )
        {
            throw CORBA::BAD_PARAM();
        }
        else if( strcasecmp(id, "remote-object") == 0 )
        {
            *retval <<= this->dm_RemoteObject;
        }
        else
        {
            throw CORBA::BAD_PARAM();
        }
        return( retval._retn() );
    };

    /* XXX BEGIN HACK MODE */
    virtual void SetDelegateAttributeObject(const char *name,
                                            const CORBA::Object_ptr value)
        throw (CORBA::SystemException)
    {
        if( name == NULL )
        {
            throw CORBA::BAD_PARAM();
        }
        else if( strcasecmp(name, "remote-object") == 0 )
        {
            if( CORBA::is_nil(value) )
            {
                this->dm_RemoteObject = T::_nil();
            }
            else
            {
                T_var tmp = T::_narrow(value);

                if( CORBA::is_nil(tmp.in()) )
                {
                    throw CORBA::BAD_PARAM();
                }
                else
                {
                    this->dm_RemoteObject = tmp;
                }
            }
        }
        else
        {
            throw CORBA::BAD_PARAM();
        }
    };

    virtual CORBA::Object_ptr GetDelegateAttributeObject(const char *name)
        throw (CORBA::SystemException)
    {
        CORBA::Object_var retval;

        if( name == NULL )
        {
            throw CORBA::BAD_PARAM();
        }
        else if( strcasecmp(name, "remote-object") == 0 )
        {
            retval = T::_duplicate(this->dm_RemoteObject);
        }
        else
        {
            throw CORBA::BAD_PARAM();
        }
        return( retval._retn() );
    };
    /* XXX END HACK MODE */

protected:

    /**
     * Reference to the remote object that operations will be delegated to.
     */
    T_var dm_RemoteObject;
    
};

#endif

---