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

Go to the documentation of this file.

#ifndef IPC_OBJECT_H
#define IPC_OBJECT_H

//      servant.h
//
//      header file for the IPC library
//
//      Sergei Kolos, June 2003
//
//      description:
//        IPCObject - base class for the servants passed by reference
//        IPCNamedObject - base class for the servants published
//                         in the IPCPartition
#include <string>
#include <sstream>
#include <iostream>

#include <owl/time.h>
#include <owl/semaphore.h>

#include <ipc/objectadapter.h>
#include <ipc/partition.h>
#include <ipc/servant.h>

template <class T>
class IPCObjectBase :   public virtual T,
                        public virtual PortableServer::RefCountServantBase
{  
  public:
      
    virtual ~IPCObjectBase ( ) {
        ERS_ASSERT_MSG( !active_,
                        "the IPCObjectBase destructor is called, but the corresponding servant is still active\n" <<
                        "to fix the problem you have to respect the following rules:\n" <<
                        "    1. Always allocate your IPC based objects in the heap using the new operator\n" <<
                        "    2. Always use the _destroy() method instead of the delete operator" )
        if ( sem_ ) {
            sem_ -> post();
        }
    }
        
    void _destroy( bool wait_for_completion = false )
    {
        if ( active_ ) {
            adapter_.remove( this );
            active_ = false;
        }
        
        if ( wait_for_completion ) {
            OWLSemaphore * semaphore = sem_;
            _remove_ref();
            semaphore -> wait();
            delete semaphore;
        }
        else {
            delete sem_;
            sem_ = 0;
            _remove_ref();
        }
    }
    
  protected:
     IPCObjectBase ( bool threaded )
      : adapter_( this, threaded ),
        active_( false )
    { sem_ = new OWLSemaphore(); }
    
    IPCObjectBase ( const IPCObjectBase * s ) 
      : adapter_( s->adapter_ ),
        active_( false )
    { sem_ = new OWLSemaphore(); }

   
    PortableServer::POA_ptr _default_POA() {
        activate();
        return adapter_;
    }
    
    void activate() {
        if ( !active_ ) {
            adapter_.add( this, oid() );
            active_ = true;
        }
    }
    
    virtual const std::string & oid() const = 0;
    
  private:      
    // Disable copying
    IPCObjectBase ( const IPCObjectBase & );
    IPCObjectBase & operator=( const IPCObjectBase & );
    
    IPCObjectAdapter    adapter_;
    bool                active_;
    OWLSemaphore *      sem_;
};

template <class T>
class IPCObjectOperations : public IPCObjectBase<T>
{
    std::string name_;
    const std::string & oid() const { return name_; }
    
  protected:
    IPCObjectOperations( bool threaded )
      : IPCObjectBase<T>( threaded ) {
        std::ostringstream out;
        out << this;
        name_ = out.str();
    }
    
    IPCObjectOperations( const IPCObjectOperations * op )
      : IPCObjectBase<T>( op ) {
        std::ostringstream out;
        out << this;
        name_ = out.str();
    }
};

template <class T, class TP = ipc::multi_thread>
class IPCObject : public IPCObjectOperations<T>
{  
  public:
      
    virtual ~IPCObject ( ) { ; }
                        
  protected:
    IPCObject ( ) : IPCObjectOperations<T>( TP::threaded() )
    { ; }
    
  private:    
    // Disable copying
    IPCObject ( const IPCObject & );
    IPCObject & operator=( const IPCObject & );
};


template <class T>
class IPCObject<T,ipc::single_thread> : public IPCObjectOperations<T>
{  
  public:
      
    virtual ~IPCObject ( ) { ; }
                        
  protected:
  
    IPCObject ( )
      : IPCObjectOperations<T>( ipc::single_thread::threaded() )
    { ; }
    
    IPCObject ( const IPCObject * object )
      : IPCObjectOperations<T>( object )
    { ; }
    
  private:    
    // Disable copying
    IPCObject ( const IPCObject & );
    IPCObject & operator=( const IPCObject & );
};

template <class T>
class IPCNamedObjectOperations : public IPCObjectBase<T>,
                                 public virtual IPCServant
{
    const std::string & oid() const { return name_; }
    
    IPCPartition        partition_;
    std::string         name_;

  protected:
    IPCNamedObjectOperations (  const IPCPartition & partition,
                                const std::string & name,
                                bool threaded )
      : IPCObjectBase<T>( threaded ),
        partition_( partition ),
        name_( name )
    { ; }

    IPCNamedObjectOperations (  const IPCPartition & partition,
                                const std::string & name,
                                const IPCNamedObjectOperations * op )
      : IPCObjectBase<T>( op ),
        partition_( partition ),
        name_( name )
    { ; }

  public:
    const std::string  & name      ( ) const { return name_; }
    
    const IPCPartition & partition ( ) const { return partition_; }
        
    void publish ( ) throw ( daq::ipc::InvalidPartition, daq::ipc::InvalidObjectName ) {
        ipc::servant_var ref = _this();
        partition().publish( name(), ipc::util::getTypeName( this ), ref );
    }
    
    void withdraw ( ) throw ( daq::ipc::InvalidPartition, daq::ipc::ObjectNotFound, daq::ipc::InvalidObjectName ) {
        partition().withdraw( name(), ipc::util::getTypeName( this ) );
    }
};

template <class T, class TP = ipc::multi_thread>
class IPCNamedObject : public IPCNamedObjectOperations<T>
{
  public:
        
    virtual ~IPCNamedObject ( ) { ; }
  protected:

    IPCNamedObject (    const std::string & name )
      : IPCNamedObjectOperations<T>( IPCPartition(), name, TP::threaded() )
    { ; }
    
    IPCNamedObject (    const IPCPartition & partition, 
                        const std::string & name )
      : IPCNamedObjectOperations<T>( partition, name, TP::threaded() )
    { ; }

  private:
    // Disable copying
    IPCNamedObject ( const IPCNamedObject & );
    IPCNamedObject & operator= ( const IPCNamedObject & );
};

template <class T>
class IPCNamedObject<T,ipc::single_thread> : public IPCNamedObjectOperations<T>
{
  public:
        
    virtual ~IPCNamedObject ( ) { ; }

  protected:

    IPCNamedObject (    const std::string & name )
      : IPCNamedObjectOperations<T>( IPCPartition(), name, ipc::single_thread::threaded() )
    { ; }
    
    IPCNamedObject (    const IPCPartition & partition, 
                        const std::string & name )
      : IPCNamedObjectOperations<T>( partition, name, ipc::single_thread::threaded() )
    { ; }

    IPCNamedObject (    const std::string & name,
                        const IPCNamedObject * object )
      : IPCNamedObjectOperations<T>( IPCPartition(), name, object )
    { ; }
    
    IPCNamedObject (    const IPCPartition & partition, 
                        const std::string & name, 
                        const IPCNamedObject * object )
      : IPCNamedObjectOperations<T>( partition, name, object )
    { ; }
    
  private:
    // Disable copying
    IPCNamedObject ( const IPCNamedObject & );
    IPCNamedObject & operator= ( const IPCNamedObject & );
};

#endif // IPC_OBJECT_H

---