/afs/cern.ch/user/k/kolos/working/online/ipc/ipc/policy.h

Go to the documentation of this file.

#ifndef IPC_POLICY_H
#define IPC_POLICY_H

//      policy.h
//
//      header file for the IPC library
//
//      Sergei Kolos, September 2003
//
//      description:

#include <string>

#include <ipc/cache.h>
#include <ipc/singleton.h>

namespace ipc
{    
    typedef CORBA::Object_ptr (*Fun1)(const std::string&);
    typedef CORBA::Object_ptr (*Fun3)(const std::string&,const std::string&,const std::string&);
        
    
    template <class T, template < class > class VP>
    struct use_cache
    {
        template <Fun1 fun>
        static
        typename T::_ptr_type resolve( const std::string & name )
        {
            CORBA::Object_var obj = IPCSingleton<IPCCache>::instance()->find( name );
            typename T::_var_type result = VP<T>::validate( obj );
            if ( CORBA::is_nil( result ) )
            {
                obj = fun( name );
                result = VP<T>::validate( obj );
                if ( !CORBA::is_nil( result ) )
                {
                    IPCSingleton<IPCCache>::instance()->insert( name, result );
                }
            }
            return T::_duplicate( result );
        }
        
        template <Fun3 fun>
        static
        typename T::_ptr_type resolve( const std::string & n1, const std::string & n2, const std::string & n3 )
        {
            CORBA::Object_var obj = IPCSingleton<IPCCache>::instance()->find( n1, n2, n3 );
            typename T::_var_type result = VP<T>::validate( obj );
            if ( CORBA::is_nil( result ) )
            {
                obj = fun( n1, n2, n3 );
                result = VP<T>::validate( obj );
                if ( !CORBA::is_nil( result ) )
                {
                    IPCSingleton<IPCCache>::instance()->insert( n1, n2, n3, result );
                }
            }
            return T::_duplicate( result );
        }
    };
        
    template <class T, template < class > class VP>
    struct no_cache
    {
        template <Fun1 fun>
        static
        typename T::_ptr_type resolve( const std::string & name )
        {
            CORBA::Object_var obj = fun( name );
            return VP<T>::validate( obj );
        }
        
        template <Fun3 fun>
        static
        typename T::_ptr_type resolve( const std::string & n1, const std::string & n2, const std::string & n3 )
        {
            CORBA::Object_var obj = fun( n1, n2, n3 );
            return VP<T>::validate( obj );
        }
    };
    
    template <class T>
    struct unchecked_narrow
    {
        static
        typename T::_ptr_type 
        validate( CORBA::Object_ptr obj ) { return T::_unchecked_narrow(obj); }
    };
    
    template <class T>
    struct narrow
    {
        static
        typename T::_ptr_type 
        validate( CORBA::Object_ptr obj )
        {
            try {
                return T::_narrow(obj);
            }
            catch(...) { return T::_nil(); }
        }
    };
    
    template <class T>
    struct non_existent
    {
        static
        typename T::_ptr_type 
        validate( CORBA::Object_ptr obj )
        {
            typename T::_var_type result = T::_nil();
            try {
                result = T::_narrow(obj);
                if ( CORBA::is_nil(result) || result -> _non_existent() )
                    return T::_nil(); 
            }
            catch(...) { return T::_nil(); }
            return T::_duplicate( result );
        }
    };
    
    struct single_thread
    {
        static bool     threaded( ) { return false; }
    };

    struct multi_thread
    {
        static bool     threaded( ) { return true; }
    };
}

#endif

---