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

Go to the documentation of this file.

#ifndef IPC_PARTITION_H
#define IPC_PARTITION_H

//      partition.h
//
//      header file for the IPC library
//
//      Sergei Kolos August 2003
//
//      description:
//          This file contains declarations for the IPCPartition class
//

#include <string>
#include <list>
#include <map>

#include <ipc/ipc.hh>
#include <ipc/util.h>
#include <ipc/policy.h>

template <class T> class IPCNamedObjectOperations;

class IPCPartition
{
    template <class > friend class IPCNamedObjectOperations;
    friend class Partition_impl;

  public:

    IPCPartition ( ) throw ()
      : name_( ipc::partition::default_name )
    { ; }

    IPCPartition ( const char * name ) throw ()
      : name_( name == 0 ? ipc::partition::default_name : name )
    { ; }

    IPCPartition ( const std::string & name ) throw ()
      : name_( name )
    { ; }

    IPCPartition ( const IPCPartition & p ) throw ()
      : name_( p.name_ )
    { ; }

    IPCPartition &
    operator= ( const IPCPartition & p ) throw () {
        if ( this != &p )
            name_ = p.name_;
        return *this;
    }

    const std::string &
    name ( ) const throw()
    { return name_;}

    bool
    isValid ( ) const throw();

    void
    getTypes ( std::list< std::string > & list ) const throw (daq::ipc::InvalidPartition);

    ipc::partition_var getImplementation() const throw(daq::ipc::InvalidPartition);

    template < class T >
    void
    getObjects ( std::map< std::string , typename T::_var_type > & map ) const throw ( daq::ipc::InvalidPartition )
    { getObjects<T, ipc::use_cache, ipc::non_existent >( map ); }

    template <class T>
    bool
    isObjectValid ( const std::string & object_name ) const throw ( daq::ipc::InvalidPartition )
    { return isObjectValid<T,ipc::use_cache,ipc::non_existent >( object_name ); }

    template < class T >
    typename T::_ptr_type
    lookup ( const std::string & object_name ) const
                throw ( daq::ipc::InvalidPartition,
                        daq::ipc::ObjectNotFound,
                        daq::ipc::InvalidObjectName )
    { return lookup<T, ipc::use_cache, ipc::narrow >( object_name ); }

    template < class T, template < class , template < class > class > class RP, template < class > class VP >
    void
    getObjects ( std::map< std::string, typename T::_var_type > & map,
                 const std::string & type_name = ipc::util::getTypeName<T>() ) const throw ( daq::ipc::InvalidPartition )
    {
        CosNaming::BindingList_var      bl;

        ipc::util::list( name_, type_name, bl );

        if ( bl.operator->() == 0 )
            return;

        for ( unsigned int i = 0; i < bl->length(); i++ )
        {
            std::string object_name = (const char *)bl[i].binding_name[0].id;
            
            try
            {
                map[ object_name ] = lookup<T,RP,VP>( object_name, type_name );
            }
            catch( ... )
            {
            }
        }
    }

    template < class T, template < class , template < class > class > class RP, template < class > class VP >
    bool
    isObjectValid (     const std::string & object_name,
                        const std::string & type_name = ipc::util::getTypeName<T>() ) const
                        throw ( daq::ipc::InvalidPartition,
                                daq::ipc::InvalidObjectName )
    {
        try
        {
            typename T::_var_type obj = lookup< T, RP, VP >( object_name, type_name );
            return true;
        }
        catch(daq::ipc::ObjectNotFound)
        {
            return false;
        }
    }

    template < class T, template < class , template < class > class > class RP, template < class > class VP >
    typename T::_ptr_type
    lookup (    const std::string & object_name,
                const std::string & type_name = ipc::util::getTypeName<T>() ) const
                        throw ( daq::ipc::InvalidPartition,
                                daq::ipc::ObjectNotFound,
                                daq::ipc::InvalidObjectName )
    { 
        typename T::_ptr_type object = RP<T, VP>::template resolve<ipc::util::resolve>( name_ , object_name, type_name );
        if ( CORBA::is_nil(object) ) {
            throw daq::ipc::ObjectNotFound( ERS_HERE, name_, type_name, object_name );
        }
        return object;
    }

    static void
    getPartitions ( std::list< IPCPartition > & list ) throw();

    template <template < class , template < class > class > class RP>
    static void
    getPartitions ( std::list< IPCPartition > & list, short = 0 ) throw ()
    {
        CosNaming::BindingList_var      bl;

        ipc::util::list ( ipc::partition::default_name, "", bl );

        if ( bl.operator->() == 0 )
            return;

        for ( unsigned int i = 0; i < bl->length(); i++ ) {
            if ( bl[i].binding_type == CosNaming::ncontext )
                continue;

            try {
                std::string name = (const char *)bl[i].binding_name[0].id;
                ipc::partition_var ip = RP< ipc::partition,
                                            ipc::non_existent >::template resolve<ipc::util::resolvePartition>( name );
                if ( !CORBA::is_nil(ip) ) {
                    list.push_back( IPCPartition( name ) );
                }
            }
            catch( daq::ipc::InvalidPartition & ex )
            {
            }
        }
    }

  private:
    void
    publish  (  const std::string & object_name,
                const std::string & type_name,
                const ipc::servant_ptr obj )
                        const throw ( daq::ipc::InvalidPartition, daq::ipc::InvalidObjectName );

    void
    withdraw (  const std::string & object_name,
                const std::string & type_name )
                        const throw ( daq::ipc::InvalidPartition, daq::ipc::ObjectNotFound, daq::ipc::InvalidObjectName );

  private:
    std::string name_;
};

#endif // IPC_PARTITION_H

---