// This file is generated by omniidl (C++ backend)- omniORB_4_1. Do not edit.
#ifndef __DSC__Engines_hh__
#define __DSC__Engines_hh__

#ifndef __CORBA_H_EXTERNAL_GUARD__
#include <omniORB4/CORBA.h>
#endif

#ifndef  USE_stub_in_nt_dll
# define USE_stub_in_nt_dll_NOT_DEFINED_DSC__Engines
#endif
#ifndef  USE_core_stub_in_nt_dll
# define USE_core_stub_in_nt_dll_NOT_DEFINED_DSC__Engines
#endif
#ifndef  USE_dyn_stub_in_nt_dll
# define USE_dyn_stub_in_nt_dll_NOT_DEFINED_DSC__Engines
#endif



#ifndef __SALOME__Exception_hh_EXTERNAL_GUARD__
#define __SALOME__Exception_hh_EXTERNAL_GUARD__
#include <SALOME_Exception.hh>
#endif
#ifndef __SALOME__GenericObj_hh_EXTERNAL_GUARD__
#define __SALOME__GenericObj_hh_EXTERNAL_GUARD__
#include <SALOME_GenericObj.hh>
#endif
#ifndef __SALOMEDS_hh_EXTERNAL_GUARD__
#define __SALOMEDS_hh_EXTERNAL_GUARD__
#include <SALOMEDS.hh>
#endif
#ifndef __SALOME__PyNode_hh_EXTERNAL_GUARD__
#define __SALOME__PyNode_hh_EXTERNAL_GUARD__
#include <SALOME_PyNode.hh>
#endif
#ifndef __SALOME__Component_hh_EXTERNAL_GUARD__
#define __SALOME__Component_hh_EXTERNAL_GUARD__
#include <SALOME_Component.hh>
#endif
#ifndef __SALOME__Ports_hh_EXTERNAL_GUARD__
#define __SALOME__Ports_hh_EXTERNAL_GUARD__
#include <SALOME_Ports.hh>
#endif



#ifdef USE_stub_in_nt_dll
# ifndef USE_core_stub_in_nt_dll
#  define USE_core_stub_in_nt_dll
# endif
# ifndef USE_dyn_stub_in_nt_dll
#  define USE_dyn_stub_in_nt_dll
# endif
#endif

#ifdef _core_attr
# error "A local CPP macro _core_attr has already been defined."
#else
# ifdef  USE_core_stub_in_nt_dll
#  define _core_attr _OMNIORB_NTDLL_IMPORT
# else
#  define _core_attr
# endif
#endif

#ifdef _dyn_attr
# error "A local CPP macro _dyn_attr has already been defined."
#else
# ifdef  USE_dyn_stub_in_nt_dll
#  define _dyn_attr _OMNIORB_NTDLL_IMPORT
# else
#  define _dyn_attr
# endif
#endif





_CORBA_MODULE Engines

_CORBA_MODULE_BEG

#ifndef __Engines_mDSC__
#define __Engines_mDSC__

  class DSC;
  class _objref_DSC;
  class _impl_DSC;
  
  typedef _objref_DSC* DSC_ptr;
  typedef DSC_ptr DSCRef;

  class DSC_Helper {
  public:
    typedef DSC_ptr _ptr_type;

    static _ptr_type _nil();
    static _CORBA_Boolean is_nil(_ptr_type);
    static void release(_ptr_type);
    static void duplicate(_ptr_type);
    static void marshalObjRef(_ptr_type, cdrStream&);
    static _ptr_type unmarshalObjRef(cdrStream&);
  };

  typedef _CORBA_ObjRef_Var<_objref_DSC, DSC_Helper> DSC_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_DSC,DSC_Helper > DSC_out;

#endif

  // interface DSC
  class DSC {
  public:
    // Declarations for this interface type.
    typedef DSC_ptr _ptr_type;
    typedef DSC_var _var_type;

    static _ptr_type _duplicate(_ptr_type);
    static _ptr_type _narrow(::CORBA::Object_ptr);
    static _ptr_type _unchecked_narrow(::CORBA::Object_ptr);
    
    static _ptr_type _nil();

    static inline void _marshalObjRef(_ptr_type, cdrStream&);

    static inline _ptr_type _unmarshalObjRef(cdrStream& s) {
      omniObjRef* o = omniObjRef::_unMarshal(_PD_repoId,s);
      if (o)
        return (_ptr_type) o->_ptrToObjRef(_PD_repoId);
      else
        return _nil();
    }

    static _core_attr const char* _PD_repoId;

    // Other IDL defined within this scope.
    static _dyn_attr const ::CORBA::TypeCode_ptr _tc_uses_port;

    class uses_port_var;

    class uses_port : public _CORBA_Unbounded_Sequence_ObjRef< Ports::_objref_Port, _CORBA_ObjRef_Element< Ports::_objref_Port, Ports::Port_Helper> , Ports::Port_Helper >  {
    public:
      typedef uses_port_var _var_type;
      inline uses_port() {}
      inline uses_port(const uses_port& _s)
        : _CORBA_Unbounded_Sequence_ObjRef< Ports::_objref_Port, _CORBA_ObjRef_Element< Ports::_objref_Port, Ports::Port_Helper> , Ports::Port_Helper > (_s) {}

      inline uses_port(_CORBA_ULong _max)
        : _CORBA_Unbounded_Sequence_ObjRef< Ports::_objref_Port, _CORBA_ObjRef_Element< Ports::_objref_Port, Ports::Port_Helper> , Ports::Port_Helper > (_max) {}
      inline uses_port(_CORBA_ULong _max, _CORBA_ULong _len, Ports::Port_ptr* _val, _CORBA_Boolean _rel=0)
        : _CORBA_Unbounded_Sequence_ObjRef< Ports::_objref_Port, _CORBA_ObjRef_Element< Ports::_objref_Port, Ports::Port_Helper> , Ports::Port_Helper > (_max, _len, _val, _rel) {}

    

      inline uses_port& operator = (const uses_port& _s) {
        _CORBA_Unbounded_Sequence_ObjRef< Ports::_objref_Port, _CORBA_ObjRef_Element< Ports::_objref_Port, Ports::Port_Helper> , Ports::Port_Helper > ::operator=(_s);
        return *this;
      }
    };

    class uses_port_out;

    class uses_port_var {
    public:
      inline uses_port_var() : _pd_seq(0) {}
      inline uses_port_var(uses_port* _s) : _pd_seq(_s) {}
      inline uses_port_var(const uses_port_var& _s) {
        if( _s._pd_seq )  _pd_seq = new uses_port(*_s._pd_seq);
        else              _pd_seq = 0;
      }
      inline ~uses_port_var() { if( _pd_seq )  delete _pd_seq; }
        
      inline uses_port_var& operator = (uses_port* _s) {
        if( _pd_seq )  delete _pd_seq;
        _pd_seq = _s;
        return *this;
      }
      inline uses_port_var& operator = (const uses_port_var& _s) {
        if( _s._pd_seq ) {
          if( !_pd_seq )  _pd_seq = new uses_port;
          *_pd_seq = *_s._pd_seq;
        } else if( _pd_seq ) {
          delete _pd_seq;
          _pd_seq = 0;
        }
        return *this;
      }
      inline _CORBA_ObjRef_Element< Ports::_objref_Port, Ports::Port_Helper>  operator [] (_CORBA_ULong _s) {
        return (*_pd_seq)[_s];
      }

    

      inline uses_port* operator -> () { return _pd_seq; }
      inline const uses_port* operator -> () const { return _pd_seq; }
#if defined(__GNUG__)
      inline operator uses_port& () const { return *_pd_seq; }
#else
      inline operator const uses_port& () const { return *_pd_seq; }
      inline operator uses_port& () { return *_pd_seq; }
#endif
        
      inline const uses_port& in() const { return *_pd_seq; }
      inline uses_port&       inout()    { return *_pd_seq; }
      inline uses_port*&      out() {
        if( _pd_seq ) { delete _pd_seq; _pd_seq = 0; }
        return _pd_seq;
      }
      inline uses_port* _retn() { uses_port* tmp = _pd_seq; _pd_seq = 0; return tmp; }
        
      friend class uses_port_out;
      
    private:
      uses_port* _pd_seq;
    };

    class uses_port_out {
    public:
      inline uses_port_out(uses_port*& _s) : _data(_s) { _data = 0; }
      inline uses_port_out(uses_port_var& _s)
        : _data(_s._pd_seq) { _s = (uses_port*) 0; }
      inline uses_port_out(const uses_port_out& _s) : _data(_s._data) {}
      inline uses_port_out& operator = (const uses_port_out& _s) {
        _data = _s._data;
        return *this;
      }
      inline uses_port_out& operator = (uses_port* _s) {
        _data = _s;
        return *this;
      }
      inline operator uses_port*&()  { return _data; }
      inline uses_port*& ptr()       { return _data; }
      inline uses_port* operator->() { return _data; }

      inline _CORBA_ObjRef_Element< Ports::_objref_Port, Ports::Port_Helper>  operator [] (_CORBA_ULong _i) {
        return (*_data)[_i];
      }

    

      uses_port*& _data;

    private:
      uses_port_out();
      uses_port_out& operator=(const uses_port_var&);
    };

    enum Message { AddingConnection, RemovingConnection, ApplicationError /*, __max_Message=0xffffffff */ };
    typedef Message& Message_out;

    static _dyn_attr const ::CORBA::TypeCode_ptr _tc_Message;

    class PortNotDefined : public ::CORBA::UserException {
    public:
      
      

      inline PortNotDefined() {
        pd_insertToAnyFn    = insertToAnyFn;
        pd_insertToAnyFnNCP = insertToAnyFnNCP;
      }
      PortNotDefined(const PortNotDefined&);
      
      PortNotDefined& operator=(const PortNotDefined&);
      virtual ~PortNotDefined();
      virtual void _raise() const;
      static PortNotDefined* _downcast(::CORBA::Exception*);
      static const PortNotDefined* _downcast(const ::CORBA::Exception*);
      static inline PortNotDefined* _narrow(::CORBA::Exception* _e) {
        return _downcast(_e);
      }
      
      inline void operator>>=(cdrStream&) const { }
      inline void operator<<=(cdrStream&) { }

      static _core_attr insertExceptionToAny    insertToAnyFn;
      static _core_attr insertExceptionToAnyNCP insertToAnyFnNCP;

      virtual ::CORBA::Exception* _NP_duplicate() const;

      static _core_attr const char* _PD_repoId;
      static _core_attr const char* _PD_typeId;

    private:
      virtual const char* _NP_typeId() const;
      virtual const char* _NP_repoId(int*) const;
      virtual void _NP_marshal(cdrStream&) const;
    };

    static _dyn_attr const ::CORBA::TypeCode_ptr _tc_PortNotDefined;

    class PortAlreadyDefined : public ::CORBA::UserException {
    public:
      
      

      inline PortAlreadyDefined() {
        pd_insertToAnyFn    = insertToAnyFn;
        pd_insertToAnyFnNCP = insertToAnyFnNCP;
      }
      PortAlreadyDefined(const PortAlreadyDefined&);
      
      PortAlreadyDefined& operator=(const PortAlreadyDefined&);
      virtual ~PortAlreadyDefined();
      virtual void _raise() const;
      static PortAlreadyDefined* _downcast(::CORBA::Exception*);
      static const PortAlreadyDefined* _downcast(const ::CORBA::Exception*);
      static inline PortAlreadyDefined* _narrow(::CORBA::Exception* _e) {
        return _downcast(_e);
      }
      
      inline void operator>>=(cdrStream&) const { }
      inline void operator<<=(cdrStream&) { }

      static _core_attr insertExceptionToAny    insertToAnyFn;
      static _core_attr insertExceptionToAnyNCP insertToAnyFnNCP;

      virtual ::CORBA::Exception* _NP_duplicate() const;

      static _core_attr const char* _PD_repoId;
      static _core_attr const char* _PD_typeId;

    private:
      virtual const char* _NP_typeId() const;
      virtual const char* _NP_repoId(int*) const;
      virtual void _NP_marshal(cdrStream&) const;
    };

    static _dyn_attr const ::CORBA::TypeCode_ptr _tc_PortAlreadyDefined;

    class PortNotConnected : public ::CORBA::UserException {
    public:
      
      

      inline PortNotConnected() {
        pd_insertToAnyFn    = insertToAnyFn;
        pd_insertToAnyFnNCP = insertToAnyFnNCP;
      }
      PortNotConnected(const PortNotConnected&);
      
      PortNotConnected& operator=(const PortNotConnected&);
      virtual ~PortNotConnected();
      virtual void _raise() const;
      static PortNotConnected* _downcast(::CORBA::Exception*);
      static const PortNotConnected* _downcast(const ::CORBA::Exception*);
      static inline PortNotConnected* _narrow(::CORBA::Exception* _e) {
        return _downcast(_e);
      }
      
      inline void operator>>=(cdrStream&) const { }
      inline void operator<<=(cdrStream&) { }

      static _core_attr insertExceptionToAny    insertToAnyFn;
      static _core_attr insertExceptionToAnyNCP insertToAnyFnNCP;

      virtual ::CORBA::Exception* _NP_duplicate() const;

      static _core_attr const char* _PD_repoId;
      static _core_attr const char* _PD_typeId;

    private:
      virtual const char* _NP_typeId() const;
      virtual const char* _NP_repoId(int*) const;
      virtual void _NP_marshal(cdrStream&) const;
    };

    static _dyn_attr const ::CORBA::TypeCode_ptr _tc_PortNotConnected;

    class BadPortType : public ::CORBA::UserException {
    public:
      
      ::CORBA::String_member expected;

      ::CORBA::String_member received;

    

      inline BadPortType() {
        pd_insertToAnyFn    = insertToAnyFn;
        pd_insertToAnyFnNCP = insertToAnyFnNCP;
      }
      BadPortType(const BadPortType&);
      BadPortType(const char* i_expected, const char* i_received);
      BadPortType& operator=(const BadPortType&);
      virtual ~BadPortType();
      virtual void _raise() const;
      static BadPortType* _downcast(::CORBA::Exception*);
      static const BadPortType* _downcast(const ::CORBA::Exception*);
      static inline BadPortType* _narrow(::CORBA::Exception* _e) {
        return _downcast(_e);
      }
      
      void operator>>=(cdrStream&) const ;
      void operator<<=(cdrStream&) ;

      static _core_attr insertExceptionToAny    insertToAnyFn;
      static _core_attr insertExceptionToAnyNCP insertToAnyFnNCP;

      virtual ::CORBA::Exception* _NP_duplicate() const;

      static _core_attr const char* _PD_repoId;
      static _core_attr const char* _PD_typeId;

    private:
      virtual const char* _NP_typeId() const;
      virtual const char* _NP_repoId(int*) const;
      virtual void _NP_marshal(cdrStream&) const;
    };

    static _dyn_attr const ::CORBA::TypeCode_ptr _tc_BadPortType;

    class NilPort : public ::CORBA::UserException {
    public:
      
      

      inline NilPort() {
        pd_insertToAnyFn    = insertToAnyFn;
        pd_insertToAnyFnNCP = insertToAnyFnNCP;
      }
      NilPort(const NilPort&);
      
      NilPort& operator=(const NilPort&);
      virtual ~NilPort();
      virtual void _raise() const;
      static NilPort* _downcast(::CORBA::Exception*);
      static const NilPort* _downcast(const ::CORBA::Exception*);
      static inline NilPort* _narrow(::CORBA::Exception* _e) {
        return _downcast(_e);
      }
      
      inline void operator>>=(cdrStream&) const { }
      inline void operator<<=(cdrStream&) { }

      static _core_attr insertExceptionToAny    insertToAnyFn;
      static _core_attr insertExceptionToAnyNCP insertToAnyFnNCP;

      virtual ::CORBA::Exception* _NP_duplicate() const;

      static _core_attr const char* _PD_repoId;
      static _core_attr const char* _PD_typeId;

    private:
      virtual const char* _NP_typeId() const;
      virtual const char* _NP_repoId(int*) const;
      virtual void _NP_marshal(cdrStream&) const;
    };

    static _dyn_attr const ::CORBA::TypeCode_ptr _tc_NilPort;

    class BadPortReference : public ::CORBA::UserException {
    public:
      
      

      inline BadPortReference() {
        pd_insertToAnyFn    = insertToAnyFn;
        pd_insertToAnyFnNCP = insertToAnyFnNCP;
      }
      BadPortReference(const BadPortReference&);
      
      BadPortReference& operator=(const BadPortReference&);
      virtual ~BadPortReference();
      virtual void _raise() const;
      static BadPortReference* _downcast(::CORBA::Exception*);
      static const BadPortReference* _downcast(const ::CORBA::Exception*);
      static inline BadPortReference* _narrow(::CORBA::Exception* _e) {
        return _downcast(_e);
      }
      
      inline void operator>>=(cdrStream&) const { }
      inline void operator<<=(cdrStream&) { }

      static _core_attr insertExceptionToAny    insertToAnyFn;
      static _core_attr insertExceptionToAnyNCP insertToAnyFnNCP;

      virtual ::CORBA::Exception* _NP_duplicate() const;

      static _core_attr const char* _PD_repoId;
      static _core_attr const char* _PD_typeId;

    private:
      virtual const char* _NP_typeId() const;
      virtual const char* _NP_repoId(int*) const;
      virtual void _NP_marshal(cdrStream&) const;
    };

    static _dyn_attr const ::CORBA::TypeCode_ptr _tc_BadPortReference;

    class BadProperty : public ::CORBA::UserException {
    public:
      
      

      inline BadProperty() {
        pd_insertToAnyFn    = insertToAnyFn;
        pd_insertToAnyFnNCP = insertToAnyFnNCP;
      }
      BadProperty(const BadProperty&);
      
      BadProperty& operator=(const BadProperty&);
      virtual ~BadProperty();
      virtual void _raise() const;
      static BadProperty* _downcast(::CORBA::Exception*);
      static const BadProperty* _downcast(const ::CORBA::Exception*);
      static inline BadProperty* _narrow(::CORBA::Exception* _e) {
        return _downcast(_e);
      }
      
      inline void operator>>=(cdrStream&) const { }
      inline void operator<<=(cdrStream&) { }

      static _core_attr insertExceptionToAny    insertToAnyFn;
      static _core_attr insertExceptionToAnyNCP insertToAnyFnNCP;

      virtual ::CORBA::Exception* _NP_duplicate() const;

      static _core_attr const char* _PD_repoId;
      static _core_attr const char* _PD_typeId;

    private:
      virtual const char* _NP_typeId() const;
      virtual const char* _NP_repoId(int*) const;
      virtual void _NP_marshal(cdrStream&) const;
    };

    static _dyn_attr const ::CORBA::TypeCode_ptr _tc_BadProperty;

  
  };

  class _objref_DSC :
    public virtual _objref_Component
  {
  public:
    void add_provides_port(::Ports::Port_ptr ref, const char* provides_port_name, ::Ports::PortProperties_ptr port_prop);
    void add_uses_port(const char* repository_id, const char* uses_port_name, ::Ports::PortProperties_ptr port_prop);
    Ports::Port_ptr get_provides_port(const char* provides_port_name, ::CORBA::Boolean connection_error);
    DSC::uses_port* get_uses_port(const char* uses_port_name);
    void connect_provides_port(const char* provides_port_name);
    void connect_uses_port(const char* uses_port_name, ::Ports::Port_ptr provides_port_ref);
    ::CORBA::Boolean is_connected(const char* port_name);
    void disconnect_provides_port(const char* provides_port_name, ::Engines::DSC::Message message);
    void disconnect_uses_port(const char* uses_port_name, ::Ports::Port_ptr provides_port_ref, ::Engines::DSC::Message message);
    Ports::PortProperties_ptr get_port_properties(const char* port_name);

    inline _objref_DSC()  { _PR_setobj(0); }  // nil
    _objref_DSC(omniIOR*, omniIdentity*);

  protected:
    virtual ~_objref_DSC();

    
  private:
    virtual void* _ptrToObjRef(const char*);

    _objref_DSC(const _objref_DSC&);
    _objref_DSC& operator = (const _objref_DSC&);
    // not implemented

    friend class DSC;
  };

  class _pof_DSC : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_DSC() : _OMNI_NS(proxyObjectFactory)(DSC::_PD_repoId) {}
    virtual ~_pof_DSC();

    virtual omniObjRef* newObjRef(omniIOR*,omniIdentity*);
    virtual _CORBA_Boolean is_a(const char*) const;
  };

  class _impl_DSC :
    public virtual _impl_Component
  {
  public:
    virtual ~_impl_DSC();

    virtual void add_provides_port(::Ports::Port_ptr ref, const char* provides_port_name, ::Ports::PortProperties_ptr port_prop) = 0;
    virtual void add_uses_port(const char* repository_id, const char* uses_port_name, ::Ports::PortProperties_ptr port_prop) = 0;
    virtual Ports::Port_ptr get_provides_port(const char* provides_port_name, ::CORBA::Boolean connection_error) = 0;
    virtual DSC::uses_port* get_uses_port(const char* uses_port_name) = 0;
    virtual void connect_provides_port(const char* provides_port_name) = 0;
    virtual void connect_uses_port(const char* uses_port_name, ::Ports::Port_ptr provides_port_ref) = 0;
    virtual ::CORBA::Boolean is_connected(const char* port_name) = 0;
    virtual void disconnect_provides_port(const char* provides_port_name, ::Engines::DSC::Message message) = 0;
    virtual void disconnect_uses_port(const char* uses_port_name, ::Ports::Port_ptr provides_port_ref, ::Engines::DSC::Message message) = 0;
    virtual Ports::PortProperties_ptr get_port_properties(const char* port_name) = 0;
    
  public:  // Really protected, workaround for xlC
    virtual _CORBA_Boolean _dispatch(omniCallHandle&);

  private:
    virtual void* _ptrToInterface(const char*);
    virtual const char* _mostDerivedRepoId();
    
  };


  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_DSC;

#ifndef __Engines_mConnectionManager__
#define __Engines_mConnectionManager__

  class ConnectionManager;
  class _objref_ConnectionManager;
  class _impl_ConnectionManager;
  
  typedef _objref_ConnectionManager* ConnectionManager_ptr;
  typedef ConnectionManager_ptr ConnectionManagerRef;

  class ConnectionManager_Helper {
  public:
    typedef ConnectionManager_ptr _ptr_type;

    static _ptr_type _nil();
    static _CORBA_Boolean is_nil(_ptr_type);
    static void release(_ptr_type);
    static void duplicate(_ptr_type);
    static void marshalObjRef(_ptr_type, cdrStream&);
    static _ptr_type unmarshalObjRef(cdrStream&);
  };

  typedef _CORBA_ObjRef_Var<_objref_ConnectionManager, ConnectionManager_Helper> ConnectionManager_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_ConnectionManager,ConnectionManager_Helper > ConnectionManager_out;

#endif

  // interface ConnectionManager
  class ConnectionManager {
  public:
    // Declarations for this interface type.
    typedef ConnectionManager_ptr _ptr_type;
    typedef ConnectionManager_var _var_type;

    static _ptr_type _duplicate(_ptr_type);
    static _ptr_type _narrow(::CORBA::Object_ptr);
    static _ptr_type _unchecked_narrow(::CORBA::Object_ptr);
    
    static _ptr_type _nil();

    static inline void _marshalObjRef(_ptr_type, cdrStream&);

    static inline _ptr_type _unmarshalObjRef(cdrStream& s) {
      omniObjRef* o = omniObjRef::_unMarshal(_PD_repoId,s);
      if (o)
        return (_ptr_type) o->_ptrToObjRef(_PD_repoId);
      else
        return _nil();
    }

    static _core_attr const char* _PD_repoId;

    // Other IDL defined within this scope.
    class BadId : public ::CORBA::UserException {
    public:
      
      

      inline BadId() {
        pd_insertToAnyFn    = insertToAnyFn;
        pd_insertToAnyFnNCP = insertToAnyFnNCP;
      }
      BadId(const BadId&);
      
      BadId& operator=(const BadId&);
      virtual ~BadId();
      virtual void _raise() const;
      static BadId* _downcast(::CORBA::Exception*);
      static const BadId* _downcast(const ::CORBA::Exception*);
      static inline BadId* _narrow(::CORBA::Exception* _e) {
        return _downcast(_e);
      }
      
      inline void operator>>=(cdrStream&) const { }
      inline void operator<<=(cdrStream&) { }

      static _core_attr insertExceptionToAny    insertToAnyFn;
      static _core_attr insertExceptionToAnyNCP insertToAnyFnNCP;

      virtual ::CORBA::Exception* _NP_duplicate() const;

      static _core_attr const char* _PD_repoId;
      static _core_attr const char* _PD_typeId;

    private:
      virtual const char* _NP_typeId() const;
      virtual const char* _NP_repoId(int*) const;
      virtual void _NP_marshal(cdrStream&) const;
    };

    static _dyn_attr const ::CORBA::TypeCode_ptr _tc_BadId;

    static _dyn_attr const ::CORBA::TypeCode_ptr _tc_connectionId;

    typedef ::CORBA::Short connectionId;
    typedef ::CORBA::Short_out connectionId_out;

  
  };

  class _objref_ConnectionManager :
    public virtual ::CORBA::Object,
    public virtual omniObjRef
  {
  public:
    ConnectionManager::connectionId connect(::Engines::DSC_ptr uses_component, const char* uses_port_name, ::Engines::DSC_ptr provides_component, const char* provides_port_name);
    void disconnect(::Engines::ConnectionManager::connectionId id, ::Engines::DSC::Message message);
    void ShutdownWithExit();
    ::CORBA::Long getPID();

    inline _objref_ConnectionManager()  { _PR_setobj(0); }  // nil
    _objref_ConnectionManager(omniIOR*, omniIdentity*);

  protected:
    virtual ~_objref_ConnectionManager();

    
  private:
    virtual void* _ptrToObjRef(const char*);

    _objref_ConnectionManager(const _objref_ConnectionManager&);
    _objref_ConnectionManager& operator = (const _objref_ConnectionManager&);
    // not implemented

    friend class ConnectionManager;
  };

  class _pof_ConnectionManager : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_ConnectionManager() : _OMNI_NS(proxyObjectFactory)(ConnectionManager::_PD_repoId) {}
    virtual ~_pof_ConnectionManager();

    virtual omniObjRef* newObjRef(omniIOR*,omniIdentity*);
    virtual _CORBA_Boolean is_a(const char*) const;
  };

  class _impl_ConnectionManager :
    public virtual omniServant
  {
  public:
    virtual ~_impl_ConnectionManager();

    virtual ConnectionManager::connectionId connect(::Engines::DSC_ptr uses_component, const char* uses_port_name, ::Engines::DSC_ptr provides_component, const char* provides_port_name) = 0;
    virtual void disconnect(::Engines::ConnectionManager::connectionId id, ::Engines::DSC::Message message) = 0;
    virtual void ShutdownWithExit() = 0;
    virtual ::CORBA::Long getPID() = 0;
    
  public:  // Really protected, workaround for xlC
    virtual _CORBA_Boolean _dispatch(omniCallHandle&);

  private:
    virtual void* _ptrToInterface(const char*);
    virtual const char* _mostDerivedRepoId();
    
  };


  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_ConnectionManager;

#ifndef __Engines_mSuperv__Component__
#define __Engines_mSuperv__Component__

  class Superv_Component;
  class _objref_Superv_Component;
  class _impl_Superv_Component;
  
  typedef _objref_Superv_Component* Superv_Component_ptr;
  typedef Superv_Component_ptr Superv_ComponentRef;

  class Superv_Component_Helper {
  public:
    typedef Superv_Component_ptr _ptr_type;

    static _ptr_type _nil();
    static _CORBA_Boolean is_nil(_ptr_type);
    static void release(_ptr_type);
    static void duplicate(_ptr_type);
    static void marshalObjRef(_ptr_type, cdrStream&);
    static _ptr_type unmarshalObjRef(cdrStream&);
  };

  typedef _CORBA_ObjRef_Var<_objref_Superv_Component, Superv_Component_Helper> Superv_Component_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_Superv_Component,Superv_Component_Helper > Superv_Component_out;

#endif

  // interface Superv_Component
  class Superv_Component {
  public:
    // Declarations for this interface type.
    typedef Superv_Component_ptr _ptr_type;
    typedef Superv_Component_var _var_type;

    static _ptr_type _duplicate(_ptr_type);
    static _ptr_type _narrow(::CORBA::Object_ptr);
    static _ptr_type _unchecked_narrow(::CORBA::Object_ptr);
    
    static _ptr_type _nil();

    static inline void _marshalObjRef(_ptr_type, cdrStream&);

    static inline _ptr_type _unmarshalObjRef(cdrStream& s) {
      omniObjRef* o = omniObjRef::_unMarshal(_PD_repoId,s);
      if (o)
        return (_ptr_type) o->_ptrToObjRef(_PD_repoId);
      else
        return _nil();
    }

    static _core_attr const char* _PD_repoId;

    // Other IDL defined within this scope.
    
  };

  class _objref_Superv_Component :
    public virtual _objref_DSC
  {
  public:
    ::CORBA::Boolean init_service(const char* service_name);

    inline _objref_Superv_Component()  { _PR_setobj(0); }  // nil
    _objref_Superv_Component(omniIOR*, omniIdentity*);

  protected:
    virtual ~_objref_Superv_Component();

    
  private:
    virtual void* _ptrToObjRef(const char*);

    _objref_Superv_Component(const _objref_Superv_Component&);
    _objref_Superv_Component& operator = (const _objref_Superv_Component&);
    // not implemented

    friend class Superv_Component;
  };

  class _pof_Superv_Component : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_Superv_Component() : _OMNI_NS(proxyObjectFactory)(Superv_Component::_PD_repoId) {}
    virtual ~_pof_Superv_Component();

    virtual omniObjRef* newObjRef(omniIOR*,omniIdentity*);
    virtual _CORBA_Boolean is_a(const char*) const;
  };

  class _impl_Superv_Component :
    public virtual _impl_DSC
  {
  public:
    virtual ~_impl_Superv_Component();

    virtual ::CORBA::Boolean init_service(const char* service_name) = 0;
    
  public:  // Really protected, workaround for xlC
    virtual _CORBA_Boolean _dispatch(omniCallHandle&);

  private:
    virtual void* _ptrToInterface(const char*);
    virtual const char* _mostDerivedRepoId();
    
  };


  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_Superv_Component;

_CORBA_MODULE_END



_CORBA_MODULE POA_Engines
_CORBA_MODULE_BEG

  class DSC :
    public virtual Engines::_impl_DSC,
    public virtual Component
  {
  public:
    virtual ~DSC();

    inline ::Engines::DSC_ptr _this() {
      return (::Engines::DSC_ptr) _do_this(::Engines::DSC::_PD_repoId);
    }
  };

  class ConnectionManager :
    public virtual Engines::_impl_ConnectionManager,
    public virtual ::PortableServer::ServantBase
  {
  public:
    virtual ~ConnectionManager();

    inline ::Engines::ConnectionManager_ptr _this() {
      return (::Engines::ConnectionManager_ptr) _do_this(::Engines::ConnectionManager::_PD_repoId);
    }
  };

  class Superv_Component :
    public virtual Engines::_impl_Superv_Component,
    public virtual DSC
  {
  public:
    virtual ~Superv_Component();

    inline ::Engines::Superv_Component_ptr _this() {
      return (::Engines::Superv_Component_ptr) _do_this(::Engines::Superv_Component::_PD_repoId);
    }
  };

_CORBA_MODULE_END



_CORBA_MODULE OBV_Engines
_CORBA_MODULE_BEG

_CORBA_MODULE_END





#undef _core_attr
#undef _dyn_attr

void operator<<=(::CORBA::Any& _a, const Engines::DSC::uses_port& _s);
void operator<<=(::CORBA::Any& _a, Engines::DSC::uses_port* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, Engines::DSC::uses_port*& _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const Engines::DSC::uses_port*& _sp);

inline void operator >>=(Engines::DSC::Message _e, cdrStream& s) {
  ::operator>>=((::CORBA::ULong)_e, s);
}

inline void operator <<= (Engines::DSC::Message& _e, cdrStream& s) {
  ::CORBA::ULong _0RL_e;
  ::operator<<=(_0RL_e,s);
  if (_0RL_e <= Engines::DSC::ApplicationError) {
    _e = (Engines::DSC::Message) _0RL_e;
  }
  else {
    OMNIORB_THROW(MARSHAL,_OMNI_NS(MARSHAL_InvalidEnumValue),
                  (::CORBA::CompletionStatus)s.completion());
  }
}

void operator<<=(::CORBA::Any& _a, Engines::DSC::Message _s);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, Engines::DSC::Message& _s);

void operator<<=(::CORBA::Any& _a, const Engines::DSC::PortNotDefined& _s);
void operator<<=(::CORBA::Any& _a, const Engines::DSC::PortNotDefined* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const Engines::DSC::PortNotDefined*& _sp);

void operator<<=(::CORBA::Any& _a, const Engines::DSC::PortAlreadyDefined& _s);
void operator<<=(::CORBA::Any& _a, const Engines::DSC::PortAlreadyDefined* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const Engines::DSC::PortAlreadyDefined*& _sp);

void operator<<=(::CORBA::Any& _a, const Engines::DSC::PortNotConnected& _s);
void operator<<=(::CORBA::Any& _a, const Engines::DSC::PortNotConnected* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const Engines::DSC::PortNotConnected*& _sp);

void operator<<=(::CORBA::Any& _a, const Engines::DSC::BadPortType& _s);
void operator<<=(::CORBA::Any& _a, const Engines::DSC::BadPortType* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const Engines::DSC::BadPortType*& _sp);

void operator<<=(::CORBA::Any& _a, const Engines::DSC::NilPort& _s);
void operator<<=(::CORBA::Any& _a, const Engines::DSC::NilPort* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const Engines::DSC::NilPort*& _sp);

void operator<<=(::CORBA::Any& _a, const Engines::DSC::BadPortReference& _s);
void operator<<=(::CORBA::Any& _a, const Engines::DSC::BadPortReference* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const Engines::DSC::BadPortReference*& _sp);

void operator<<=(::CORBA::Any& _a, const Engines::DSC::BadProperty& _s);
void operator<<=(::CORBA::Any& _a, const Engines::DSC::BadProperty* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const Engines::DSC::BadProperty*& _sp);

void operator<<=(::CORBA::Any& _a, Engines::DSC_ptr _s);
void operator<<=(::CORBA::Any& _a, Engines::DSC_ptr* _s);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, Engines::DSC_ptr& _s);

void operator<<=(::CORBA::Any& _a, const Engines::ConnectionManager::BadId& _s);
void operator<<=(::CORBA::Any& _a, const Engines::ConnectionManager::BadId* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const Engines::ConnectionManager::BadId*& _sp);

void operator<<=(::CORBA::Any& _a, Engines::ConnectionManager_ptr _s);
void operator<<=(::CORBA::Any& _a, Engines::ConnectionManager_ptr* _s);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, Engines::ConnectionManager_ptr& _s);

void operator<<=(::CORBA::Any& _a, Engines::Superv_Component_ptr _s);
void operator<<=(::CORBA::Any& _a, Engines::Superv_Component_ptr* _s);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, Engines::Superv_Component_ptr& _s);



inline void
Engines::DSC::_marshalObjRef(::Engines::DSC_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
Engines::ConnectionManager::_marshalObjRef(::Engines::ConnectionManager_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
Engines::Superv_Component::_marshalObjRef(::Engines::Superv_Component_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}




#ifdef   USE_stub_in_nt_dll_NOT_DEFINED_DSC__Engines
# undef  USE_stub_in_nt_dll
# undef  USE_stub_in_nt_dll_NOT_DEFINED_DSC__Engines
#endif
#ifdef   USE_core_stub_in_nt_dll_NOT_DEFINED_DSC__Engines
# undef  USE_core_stub_in_nt_dll
# undef  USE_core_stub_in_nt_dll_NOT_DEFINED_DSC__Engines
#endif
#ifdef   USE_dyn_stub_in_nt_dll_NOT_DEFINED_DSC__Engines
# undef  USE_dyn_stub_in_nt_dll
# undef  USE_dyn_stub_in_nt_dll_NOT_DEFINED_DSC__Engines
#endif

#endif  // __DSC__Engines_hh__

