salome-kernel-dev 6.5.0-7ubuntu2 / usr / include / salome / Calcium_Ports.hh

// This file is generated by omniidl (C++ backend)- omniORB_4_1. Do not edit.
#ifndef __Calcium__Ports_hh__
#define __Calcium__Ports_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_Calcium__Ports
#endif
#ifndef  USE_core_stub_in_nt_dll
# define USE_core_stub_in_nt_dll_NOT_DEFINED_Calcium__Ports
#endif
#ifndef  USE_dyn_stub_in_nt_dll
# define USE_dyn_stub_in_nt_dll_NOT_DEFINED_Calcium__Ports
#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 Ports

_CORBA_MODULE_BEG

  _CORBA_MODULE Calcium_Ports

  _CORBA_MODULE_BEG

    _CORBA_MODULE_VARINT const ::CORBA::Long UNLIMITED_STORAGE_LEVEL _init_in_decl_( = -70 );

    enum DependencyType { UNDEFINED_DEPENDENCY, TIME_DEPENDENCY, ITERATION_DEPENDENCY /*, __max_DependencyType=0xffffffff */ };
    typedef DependencyType& DependencyType_out;

    _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_DependencyType;

    enum DateCalSchem { TI_SCHEM, TF_SCHEM, ALPHA_SCHEM /*, __max_DateCalSchem=0xffffffff */ };
    typedef DateCalSchem& DateCalSchem_out;

    _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_DateCalSchem;

    enum InterpolationSchem { L0_SCHEM, L1_SCHEM /*, __max_InterpolationSchem=0xffffffff */ };
    typedef InterpolationSchem& InterpolationSchem_out;

    _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_InterpolationSchem;

    enum ExtrapolationSchem { UNDEFINED_EXTRA_SCHEM, E0_SCHEM, E1_SCHEM /*, __max_ExtrapolationSchem=0xffffffff */ };
    typedef ExtrapolationSchem& ExtrapolationSchem_out;

    _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_ExtrapolationSchem;

    _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_DisconnectDirective;

    typedef ::CORBA::Boolean DisconnectDirective;
    typedef ::CORBA::Boolean_out DisconnectDirective_out;

    _CORBA_MODULE_VARINT const ::CORBA::Boolean stop _init_in_decl_( = 0 );

    _CORBA_MODULE_VARINT const ::CORBA::Boolean cont _init_in_decl_( = 1 );

#ifndef __Ports_mCalcium__Ports_mCalcium__Port__
#define __Ports_mCalcium__Ports_mCalcium__Port__

    class Calcium_Port;
    class _objref_Calcium_Port;
    class _impl_Calcium_Port;
    
    typedef _objref_Calcium_Port* Calcium_Port_ptr;
    typedef Calcium_Port_ptr Calcium_PortRef;

    class Calcium_Port_Helper {
    public:
      typedef Calcium_Port_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_Calcium_Port, Calcium_Port_Helper> Calcium_Port_var;
    typedef _CORBA_ObjRef_OUT_arg<_objref_Calcium_Port,Calcium_Port_Helper > Calcium_Port_out;

#endif

    // interface Calcium_Port
    class Calcium_Port {
    public:
      // Declarations for this interface type.
      typedef Calcium_Port_ptr _ptr_type;
      typedef Calcium_Port_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_Calcium_Port :
      public virtual _objref_Data_Port,
      public virtual _objref_PortProperties
    {
    public:
      void disconnect(::Ports::Calcium_Ports::DisconnectDirective mode);

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

    protected:
      virtual ~_objref_Calcium_Port();

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

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

      friend class Calcium_Port;
    };

    class _pof_Calcium_Port : public _OMNI_NS(proxyObjectFactory) {
    public:
      inline _pof_Calcium_Port() : _OMNI_NS(proxyObjectFactory)(Calcium_Port::_PD_repoId) {}
      virtual ~_pof_Calcium_Port();

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

    class _impl_Calcium_Port :
      public virtual _impl_Data_Port,
      public virtual _impl_PortProperties
    {
    public:
      virtual ~_impl_Calcium_Port();

      virtual void disconnect(::Ports::Calcium_Ports::DisconnectDirective mode) = 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_Calcium_Port;

    _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_seq_long;

    class seq_long_var;

    class seq_long : public _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::Long, 4, 4 >  {
    public:
      typedef seq_long_var _var_type;
      inline seq_long() {}
      inline seq_long(const seq_long& _s)
        : _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::Long, 4, 4 > (_s) {}

      inline seq_long(_CORBA_ULong _max)
        : _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::Long, 4, 4 > (_max) {}
      inline seq_long(_CORBA_ULong _max, _CORBA_ULong _len, ::CORBA::Long* _val, _CORBA_Boolean _rel=0)
        : _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::Long, 4, 4 > (_max, _len, _val, _rel) {}

    

      inline seq_long& operator = (const seq_long& _s) {
        _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::Long, 4, 4 > ::operator=(_s);
        return *this;
      }
    };

    class seq_long_out;

    class seq_long_var {
    public:
      inline seq_long_var() : _pd_seq(0) {}
      inline seq_long_var(seq_long* _s) : _pd_seq(_s) {}
      inline seq_long_var(const seq_long_var& _s) {
        if( _s._pd_seq )  _pd_seq = new seq_long(*_s._pd_seq);
        else              _pd_seq = 0;
      }
      inline ~seq_long_var() { if( _pd_seq )  delete _pd_seq; }
        
      inline seq_long_var& operator = (seq_long* _s) {
        if( _pd_seq )  delete _pd_seq;
        _pd_seq = _s;
        return *this;
      }
      inline seq_long_var& operator = (const seq_long_var& _s) {
        if( _s._pd_seq ) {
          if( !_pd_seq )  _pd_seq = new seq_long;
          *_pd_seq = *_s._pd_seq;
        } else if( _pd_seq ) {
          delete _pd_seq;
          _pd_seq = 0;
        }
        return *this;
      }
      inline ::CORBA::Long& operator [] (_CORBA_ULong _s) {
        return (*_pd_seq)[_s];
      }

    

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

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

      inline ::CORBA::Long& operator [] (_CORBA_ULong _i) {
        return (*_data)[_i];
      }

    

      seq_long*& _data;

    private:
      seq_long_out();
      seq_long_out& operator=(const seq_long_var&);
    };

    _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_seq_long_long;

    class seq_long_long_var;

    class seq_long_long : public _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::LongLong, 8, 8 >  {
    public:
      typedef seq_long_long_var _var_type;
      inline seq_long_long() {}
      inline seq_long_long(const seq_long_long& _s)
        : _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::LongLong, 8, 8 > (_s) {}

      inline seq_long_long(_CORBA_ULong _max)
        : _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::LongLong, 8, 8 > (_max) {}
      inline seq_long_long(_CORBA_ULong _max, _CORBA_ULong _len, ::CORBA::LongLong* _val, _CORBA_Boolean _rel=0)
        : _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::LongLong, 8, 8 > (_max, _len, _val, _rel) {}

    

      inline seq_long_long& operator = (const seq_long_long& _s) {
        _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::LongLong, 8, 8 > ::operator=(_s);
        return *this;
      }
    };

    class seq_long_long_out;

    class seq_long_long_var {
    public:
      inline seq_long_long_var() : _pd_seq(0) {}
      inline seq_long_long_var(seq_long_long* _s) : _pd_seq(_s) {}
      inline seq_long_long_var(const seq_long_long_var& _s) {
        if( _s._pd_seq )  _pd_seq = new seq_long_long(*_s._pd_seq);
        else              _pd_seq = 0;
      }
      inline ~seq_long_long_var() { if( _pd_seq )  delete _pd_seq; }
        
      inline seq_long_long_var& operator = (seq_long_long* _s) {
        if( _pd_seq )  delete _pd_seq;
        _pd_seq = _s;
        return *this;
      }
      inline seq_long_long_var& operator = (const seq_long_long_var& _s) {
        if( _s._pd_seq ) {
          if( !_pd_seq )  _pd_seq = new seq_long_long;
          *_pd_seq = *_s._pd_seq;
        } else if( _pd_seq ) {
          delete _pd_seq;
          _pd_seq = 0;
        }
        return *this;
      }
      inline ::CORBA::LongLong& operator [] (_CORBA_ULong _s) {
        return (*_pd_seq)[_s];
      }

    

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

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

      inline ::CORBA::LongLong& operator [] (_CORBA_ULong _i) {
        return (*_data)[_i];
      }

    

      seq_long_long*& _data;

    private:
      seq_long_long_out();
      seq_long_long_out& operator=(const seq_long_long_var&);
    };

    _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_seq_integer;

    class seq_integer_var;

    class seq_integer : public _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::Long, 4, 4 >  {
    public:
      typedef seq_integer_var _var_type;
      inline seq_integer() {}
      inline seq_integer(const seq_integer& _s)
        : _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::Long, 4, 4 > (_s) {}

      inline seq_integer(_CORBA_ULong _max)
        : _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::Long, 4, 4 > (_max) {}
      inline seq_integer(_CORBA_ULong _max, _CORBA_ULong _len, ::CORBA::Long* _val, _CORBA_Boolean _rel=0)
        : _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::Long, 4, 4 > (_max, _len, _val, _rel) {}

    

      inline seq_integer& operator = (const seq_integer& _s) {
        _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::Long, 4, 4 > ::operator=(_s);
        return *this;
      }
    };

    class seq_integer_out;

    class seq_integer_var {
    public:
      inline seq_integer_var() : _pd_seq(0) {}
      inline seq_integer_var(seq_integer* _s) : _pd_seq(_s) {}
      inline seq_integer_var(const seq_integer_var& _s) {
        if( _s._pd_seq )  _pd_seq = new seq_integer(*_s._pd_seq);
        else              _pd_seq = 0;
      }
      inline ~seq_integer_var() { if( _pd_seq )  delete _pd_seq; }
        
      inline seq_integer_var& operator = (seq_integer* _s) {
        if( _pd_seq )  delete _pd_seq;
        _pd_seq = _s;
        return *this;
      }
      inline seq_integer_var& operator = (const seq_integer_var& _s) {
        if( _s._pd_seq ) {
          if( !_pd_seq )  _pd_seq = new seq_integer;
          *_pd_seq = *_s._pd_seq;
        } else if( _pd_seq ) {
          delete _pd_seq;
          _pd_seq = 0;
        }
        return *this;
      }
      inline ::CORBA::Long& operator [] (_CORBA_ULong _s) {
        return (*_pd_seq)[_s];
      }

    

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

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

      inline ::CORBA::Long& operator [] (_CORBA_ULong _i) {
        return (*_data)[_i];
      }

    

      seq_integer*& _data;

    private:
      seq_integer_out();
      seq_integer_out& operator=(const seq_integer_var&);
    };

    _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_seq_float;

    class seq_float_var;

    class seq_float : public _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::Float, 4, 4 >  {
    public:
      typedef seq_float_var _var_type;
      inline seq_float() {}
      inline seq_float(const seq_float& _s)
        : _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::Float, 4, 4 > (_s) {}

      inline seq_float(_CORBA_ULong _max)
        : _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::Float, 4, 4 > (_max) {}
      inline seq_float(_CORBA_ULong _max, _CORBA_ULong _len, ::CORBA::Float* _val, _CORBA_Boolean _rel=0)
        : _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::Float, 4, 4 > (_max, _len, _val, _rel) {}

    

      inline seq_float& operator = (const seq_float& _s) {
        _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::Float, 4, 4 > ::operator=(_s);
        return *this;
      }
    };

    class seq_float_out;

    class seq_float_var {
    public:
      inline seq_float_var() : _pd_seq(0) {}
      inline seq_float_var(seq_float* _s) : _pd_seq(_s) {}
      inline seq_float_var(const seq_float_var& _s) {
        if( _s._pd_seq )  _pd_seq = new seq_float(*_s._pd_seq);
        else              _pd_seq = 0;
      }
      inline ~seq_float_var() { if( _pd_seq )  delete _pd_seq; }
        
      inline seq_float_var& operator = (seq_float* _s) {
        if( _pd_seq )  delete _pd_seq;
        _pd_seq = _s;
        return *this;
      }
      inline seq_float_var& operator = (const seq_float_var& _s) {
        if( _s._pd_seq ) {
          if( !_pd_seq )  _pd_seq = new seq_float;
          *_pd_seq = *_s._pd_seq;
        } else if( _pd_seq ) {
          delete _pd_seq;
          _pd_seq = 0;
        }
        return *this;
      }
      inline ::CORBA::Float& operator [] (_CORBA_ULong _s) {
        return (*_pd_seq)[_s];
      }

    

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

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

      inline ::CORBA::Float& operator [] (_CORBA_ULong _i) {
        return (*_data)[_i];
      }

    

      seq_float*& _data;

    private:
      seq_float_out();
      seq_float_out& operator=(const seq_float_var&);
    };

    _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_seq_double;

    class seq_double_var;

    class seq_double : public _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::Double, 8, 8 >  {
    public:
      typedef seq_double_var _var_type;
      inline seq_double() {}
      inline seq_double(const seq_double& _s)
        : _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::Double, 8, 8 > (_s) {}

      inline seq_double(_CORBA_ULong _max)
        : _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::Double, 8, 8 > (_max) {}
      inline seq_double(_CORBA_ULong _max, _CORBA_ULong _len, ::CORBA::Double* _val, _CORBA_Boolean _rel=0)
        : _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::Double, 8, 8 > (_max, _len, _val, _rel) {}

    

      inline seq_double& operator = (const seq_double& _s) {
        _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::Double, 8, 8 > ::operator=(_s);
        return *this;
      }
    };

    class seq_double_out;

    class seq_double_var {
    public:
      inline seq_double_var() : _pd_seq(0) {}
      inline seq_double_var(seq_double* _s) : _pd_seq(_s) {}
      inline seq_double_var(const seq_double_var& _s) {
        if( _s._pd_seq )  _pd_seq = new seq_double(*_s._pd_seq);
        else              _pd_seq = 0;
      }
      inline ~seq_double_var() { if( _pd_seq )  delete _pd_seq; }
        
      inline seq_double_var& operator = (seq_double* _s) {
        if( _pd_seq )  delete _pd_seq;
        _pd_seq = _s;
        return *this;
      }
      inline seq_double_var& operator = (const seq_double_var& _s) {
        if( _s._pd_seq ) {
          if( !_pd_seq )  _pd_seq = new seq_double;
          *_pd_seq = *_s._pd_seq;
        } else if( _pd_seq ) {
          delete _pd_seq;
          _pd_seq = 0;
        }
        return *this;
      }
      inline ::CORBA::Double& operator [] (_CORBA_ULong _s) {
        return (*_pd_seq)[_s];
      }

    

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

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

      inline ::CORBA::Double& operator [] (_CORBA_ULong _i) {
        return (*_data)[_i];
      }

    

      seq_double*& _data;

    private:
      seq_double_out();
      seq_double_out& operator=(const seq_double_var&);
    };

    _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_seq_string;

    class seq_string_var;

    class seq_string : public _CORBA_Unbounded_Sequence_String {
    public:
      typedef seq_string_var _var_type;
      inline seq_string() {}
      inline seq_string(const seq_string& _s)
        : _CORBA_Unbounded_Sequence_String(_s) {}

      inline seq_string(_CORBA_ULong _max)
        : _CORBA_Unbounded_Sequence_String(_max) {}
      inline seq_string(_CORBA_ULong _max, _CORBA_ULong _len, char** _val, _CORBA_Boolean _rel=0)
        : _CORBA_Unbounded_Sequence_String(_max, _len, _val, _rel) {}

    

      inline seq_string& operator = (const seq_string& _s) {
        _CORBA_Unbounded_Sequence_String::operator=(_s);
        return *this;
      }
    };

    class seq_string_out;

    class seq_string_var {
    public:
      inline seq_string_var() : _pd_seq(0) {}
      inline seq_string_var(seq_string* _s) : _pd_seq(_s) {}
      inline seq_string_var(const seq_string_var& _s) {
        if( _s._pd_seq )  _pd_seq = new seq_string(*_s._pd_seq);
        else              _pd_seq = 0;
      }
      inline ~seq_string_var() { if( _pd_seq )  delete _pd_seq; }
        
      inline seq_string_var& operator = (seq_string* _s) {
        if( _pd_seq )  delete _pd_seq;
        _pd_seq = _s;
        return *this;
      }
      inline seq_string_var& operator = (const seq_string_var& _s) {
        if( _s._pd_seq ) {
          if( !_pd_seq )  _pd_seq = new seq_string;
          *_pd_seq = *_s._pd_seq;
        } else if( _pd_seq ) {
          delete _pd_seq;
          _pd_seq = 0;
        }
        return *this;
      }
      inline _CORBA_String_element operator [] (_CORBA_ULong _s) {
        return (*_pd_seq)[_s];
      }

    

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

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

      inline _CORBA_String_element operator [] (_CORBA_ULong _i) {
        return (*_data)[_i];
      }

    

      seq_string*& _data;

    private:
      seq_string_out();
      seq_string_out& operator=(const seq_string_var&);
    };

    _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_seq_boolean;

    class seq_boolean_var;

    class seq_boolean : public _CORBA_Unbounded_Sequence_Boolean {
    public:
      typedef seq_boolean_var _var_type;
      inline seq_boolean() {}
      inline seq_boolean(const seq_boolean& _s)
        : _CORBA_Unbounded_Sequence_Boolean(_s) {}

      inline seq_boolean(_CORBA_ULong _max)
        : _CORBA_Unbounded_Sequence_Boolean(_max) {}
      inline seq_boolean(_CORBA_ULong _max, _CORBA_ULong _len, ::CORBA::Boolean* _val, _CORBA_Boolean _rel=0)
        : _CORBA_Unbounded_Sequence_Boolean(_max, _len, _val, _rel) {}

    

      inline seq_boolean& operator = (const seq_boolean& _s) {
        _CORBA_Unbounded_Sequence_Boolean::operator=(_s);
        return *this;
      }
    };

    class seq_boolean_out;

    class seq_boolean_var {
    public:
      inline seq_boolean_var() : _pd_seq(0) {}
      inline seq_boolean_var(seq_boolean* _s) : _pd_seq(_s) {}
      inline seq_boolean_var(const seq_boolean_var& _s) {
        if( _s._pd_seq )  _pd_seq = new seq_boolean(*_s._pd_seq);
        else              _pd_seq = 0;
      }
      inline ~seq_boolean_var() { if( _pd_seq )  delete _pd_seq; }
        
      inline seq_boolean_var& operator = (seq_boolean* _s) {
        if( _pd_seq )  delete _pd_seq;
        _pd_seq = _s;
        return *this;
      }
      inline seq_boolean_var& operator = (const seq_boolean_var& _s) {
        if( _s._pd_seq ) {
          if( !_pd_seq )  _pd_seq = new seq_boolean;
          *_pd_seq = *_s._pd_seq;
        } else if( _pd_seq ) {
          delete _pd_seq;
          _pd_seq = 0;
        }
        return *this;
      }
      inline ::CORBA::Boolean& operator [] (_CORBA_ULong _s) {
        return (*_pd_seq)[_s];
      }

    

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

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

      inline ::CORBA::Boolean& operator [] (_CORBA_ULong _i) {
        return (*_data)[_i];
      }

    

      seq_boolean*& _data;

    private:
      seq_boolean_out();
      seq_boolean_out& operator=(const seq_boolean_var&);
    };

    _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_seq_complex;

    typedef seq_float seq_complex;
    typedef seq_float_var seq_complex_var;
    typedef seq_float_out seq_complex_out;

#ifndef __Ports_mCalcium__Ports_mCalcium__Integer__Port__
#define __Ports_mCalcium__Ports_mCalcium__Integer__Port__

    class Calcium_Integer_Port;
    class _objref_Calcium_Integer_Port;
    class _impl_Calcium_Integer_Port;
    
    typedef _objref_Calcium_Integer_Port* Calcium_Integer_Port_ptr;
    typedef Calcium_Integer_Port_ptr Calcium_Integer_PortRef;

    class Calcium_Integer_Port_Helper {
    public:
      typedef Calcium_Integer_Port_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_Calcium_Integer_Port, Calcium_Integer_Port_Helper> Calcium_Integer_Port_var;
    typedef _CORBA_ObjRef_OUT_arg<_objref_Calcium_Integer_Port,Calcium_Integer_Port_Helper > Calcium_Integer_Port_out;

#endif

    // interface Calcium_Integer_Port
    class Calcium_Integer_Port {
    public:
      // Declarations for this interface type.
      typedef Calcium_Integer_Port_ptr _ptr_type;
      typedef Calcium_Integer_Port_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_Calcium_Integer_Port :
      public virtual _objref_Calcium_Port
    {
    public:
      void put(const ::Ports::Calcium_Ports::seq_integer& data, ::CORBA::Double time, ::CORBA::Long tag);

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

    protected:
      virtual ~_objref_Calcium_Integer_Port();

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

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

      friend class Calcium_Integer_Port;
    };

    class _pof_Calcium_Integer_Port : public _OMNI_NS(proxyObjectFactory) {
    public:
      inline _pof_Calcium_Integer_Port() : _OMNI_NS(proxyObjectFactory)(Calcium_Integer_Port::_PD_repoId) {}
      virtual ~_pof_Calcium_Integer_Port();

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

    class _impl_Calcium_Integer_Port :
      public virtual _impl_Calcium_Port
    {
    public:
      virtual ~_impl_Calcium_Integer_Port();

      virtual void put(const ::Ports::Calcium_Ports::seq_integer& data, ::CORBA::Double time, ::CORBA::Long tag) = 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_Calcium_Integer_Port;

#ifndef __Ports_mCalcium__Ports_mCalcium__Intc__Port__
#define __Ports_mCalcium__Ports_mCalcium__Intc__Port__

    class Calcium_Intc_Port;
    class _objref_Calcium_Intc_Port;
    class _impl_Calcium_Intc_Port;
    
    typedef _objref_Calcium_Intc_Port* Calcium_Intc_Port_ptr;
    typedef Calcium_Intc_Port_ptr Calcium_Intc_PortRef;

    class Calcium_Intc_Port_Helper {
    public:
      typedef Calcium_Intc_Port_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_Calcium_Intc_Port, Calcium_Intc_Port_Helper> Calcium_Intc_Port_var;
    typedef _CORBA_ObjRef_OUT_arg<_objref_Calcium_Intc_Port,Calcium_Intc_Port_Helper > Calcium_Intc_Port_out;

#endif

    // interface Calcium_Intc_Port
    class Calcium_Intc_Port {
    public:
      // Declarations for this interface type.
      typedef Calcium_Intc_Port_ptr _ptr_type;
      typedef Calcium_Intc_Port_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_Calcium_Intc_Port :
      public virtual _objref_Calcium_Port
    {
    public:
      void put(const ::Ports::Calcium_Ports::seq_long& data, ::CORBA::Double time, ::CORBA::Long tag);

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

    protected:
      virtual ~_objref_Calcium_Intc_Port();

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

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

      friend class Calcium_Intc_Port;
    };

    class _pof_Calcium_Intc_Port : public _OMNI_NS(proxyObjectFactory) {
    public:
      inline _pof_Calcium_Intc_Port() : _OMNI_NS(proxyObjectFactory)(Calcium_Intc_Port::_PD_repoId) {}
      virtual ~_pof_Calcium_Intc_Port();

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

    class _impl_Calcium_Intc_Port :
      public virtual _impl_Calcium_Port
    {
    public:
      virtual ~_impl_Calcium_Intc_Port();

      virtual void put(const ::Ports::Calcium_Ports::seq_long& data, ::CORBA::Double time, ::CORBA::Long tag) = 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_Calcium_Intc_Port;

#ifndef __Ports_mCalcium__Ports_mCalcium__Long__Port__
#define __Ports_mCalcium__Ports_mCalcium__Long__Port__

    class Calcium_Long_Port;
    class _objref_Calcium_Long_Port;
    class _impl_Calcium_Long_Port;
    
    typedef _objref_Calcium_Long_Port* Calcium_Long_Port_ptr;
    typedef Calcium_Long_Port_ptr Calcium_Long_PortRef;

    class Calcium_Long_Port_Helper {
    public:
      typedef Calcium_Long_Port_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_Calcium_Long_Port, Calcium_Long_Port_Helper> Calcium_Long_Port_var;
    typedef _CORBA_ObjRef_OUT_arg<_objref_Calcium_Long_Port,Calcium_Long_Port_Helper > Calcium_Long_Port_out;

#endif

    // interface Calcium_Long_Port
    class Calcium_Long_Port {
    public:
      // Declarations for this interface type.
      typedef Calcium_Long_Port_ptr _ptr_type;
      typedef Calcium_Long_Port_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_Calcium_Long_Port :
      public virtual _objref_Calcium_Port
    {
    public:
      void put(const ::Ports::Calcium_Ports::seq_long_long& data, ::CORBA::Double time, ::CORBA::Long tag);

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

    protected:
      virtual ~_objref_Calcium_Long_Port();

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

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

      friend class Calcium_Long_Port;
    };

    class _pof_Calcium_Long_Port : public _OMNI_NS(proxyObjectFactory) {
    public:
      inline _pof_Calcium_Long_Port() : _OMNI_NS(proxyObjectFactory)(Calcium_Long_Port::_PD_repoId) {}
      virtual ~_pof_Calcium_Long_Port();

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

    class _impl_Calcium_Long_Port :
      public virtual _impl_Calcium_Port
    {
    public:
      virtual ~_impl_Calcium_Long_Port();

      virtual void put(const ::Ports::Calcium_Ports::seq_long_long& data, ::CORBA::Double time, ::CORBA::Long tag) = 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_Calcium_Long_Port;

#ifndef __Ports_mCalcium__Ports_mCalcium__Real__Port__
#define __Ports_mCalcium__Ports_mCalcium__Real__Port__

    class Calcium_Real_Port;
    class _objref_Calcium_Real_Port;
    class _impl_Calcium_Real_Port;
    
    typedef _objref_Calcium_Real_Port* Calcium_Real_Port_ptr;
    typedef Calcium_Real_Port_ptr Calcium_Real_PortRef;

    class Calcium_Real_Port_Helper {
    public:
      typedef Calcium_Real_Port_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_Calcium_Real_Port, Calcium_Real_Port_Helper> Calcium_Real_Port_var;
    typedef _CORBA_ObjRef_OUT_arg<_objref_Calcium_Real_Port,Calcium_Real_Port_Helper > Calcium_Real_Port_out;

#endif

    // interface Calcium_Real_Port
    class Calcium_Real_Port {
    public:
      // Declarations for this interface type.
      typedef Calcium_Real_Port_ptr _ptr_type;
      typedef Calcium_Real_Port_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_Calcium_Real_Port :
      public virtual _objref_Calcium_Port
    {
    public:
      void put(const ::Ports::Calcium_Ports::seq_float& data, ::CORBA::Double time, ::CORBA::Long tag);

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

    protected:
      virtual ~_objref_Calcium_Real_Port();

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

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

      friend class Calcium_Real_Port;
    };

    class _pof_Calcium_Real_Port : public _OMNI_NS(proxyObjectFactory) {
    public:
      inline _pof_Calcium_Real_Port() : _OMNI_NS(proxyObjectFactory)(Calcium_Real_Port::_PD_repoId) {}
      virtual ~_pof_Calcium_Real_Port();

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

    class _impl_Calcium_Real_Port :
      public virtual _impl_Calcium_Port
    {
    public:
      virtual ~_impl_Calcium_Real_Port();

      virtual void put(const ::Ports::Calcium_Ports::seq_float& data, ::CORBA::Double time, ::CORBA::Long tag) = 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_Calcium_Real_Port;

#ifndef __Ports_mCalcium__Ports_mCalcium__Double__Port__
#define __Ports_mCalcium__Ports_mCalcium__Double__Port__

    class Calcium_Double_Port;
    class _objref_Calcium_Double_Port;
    class _impl_Calcium_Double_Port;
    
    typedef _objref_Calcium_Double_Port* Calcium_Double_Port_ptr;
    typedef Calcium_Double_Port_ptr Calcium_Double_PortRef;

    class Calcium_Double_Port_Helper {
    public:
      typedef Calcium_Double_Port_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_Calcium_Double_Port, Calcium_Double_Port_Helper> Calcium_Double_Port_var;
    typedef _CORBA_ObjRef_OUT_arg<_objref_Calcium_Double_Port,Calcium_Double_Port_Helper > Calcium_Double_Port_out;

#endif

    // interface Calcium_Double_Port
    class Calcium_Double_Port {
    public:
      // Declarations for this interface type.
      typedef Calcium_Double_Port_ptr _ptr_type;
      typedef Calcium_Double_Port_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_Calcium_Double_Port :
      public virtual _objref_Calcium_Port
    {
    public:
      void put(const ::Ports::Calcium_Ports::seq_double& data, ::CORBA::Double time, ::CORBA::Long tag);

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

    protected:
      virtual ~_objref_Calcium_Double_Port();

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

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

      friend class Calcium_Double_Port;
    };

    class _pof_Calcium_Double_Port : public _OMNI_NS(proxyObjectFactory) {
    public:
      inline _pof_Calcium_Double_Port() : _OMNI_NS(proxyObjectFactory)(Calcium_Double_Port::_PD_repoId) {}
      virtual ~_pof_Calcium_Double_Port();

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

    class _impl_Calcium_Double_Port :
      public virtual _impl_Calcium_Port
    {
    public:
      virtual ~_impl_Calcium_Double_Port();

      virtual void put(const ::Ports::Calcium_Ports::seq_double& data, ::CORBA::Double time, ::CORBA::Long tag) = 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_Calcium_Double_Port;

#ifndef __Ports_mCalcium__Ports_mCalcium__String__Port__
#define __Ports_mCalcium__Ports_mCalcium__String__Port__

    class Calcium_String_Port;
    class _objref_Calcium_String_Port;
    class _impl_Calcium_String_Port;
    
    typedef _objref_Calcium_String_Port* Calcium_String_Port_ptr;
    typedef Calcium_String_Port_ptr Calcium_String_PortRef;

    class Calcium_String_Port_Helper {
    public:
      typedef Calcium_String_Port_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_Calcium_String_Port, Calcium_String_Port_Helper> Calcium_String_Port_var;
    typedef _CORBA_ObjRef_OUT_arg<_objref_Calcium_String_Port,Calcium_String_Port_Helper > Calcium_String_Port_out;

#endif

    // interface Calcium_String_Port
    class Calcium_String_Port {
    public:
      // Declarations for this interface type.
      typedef Calcium_String_Port_ptr _ptr_type;
      typedef Calcium_String_Port_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_Calcium_String_Port :
      public virtual _objref_Calcium_Port
    {
    public:
      void put(const ::Ports::Calcium_Ports::seq_string& data, ::CORBA::Double time, ::CORBA::Long tag);

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

    protected:
      virtual ~_objref_Calcium_String_Port();

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

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

      friend class Calcium_String_Port;
    };

    class _pof_Calcium_String_Port : public _OMNI_NS(proxyObjectFactory) {
    public:
      inline _pof_Calcium_String_Port() : _OMNI_NS(proxyObjectFactory)(Calcium_String_Port::_PD_repoId) {}
      virtual ~_pof_Calcium_String_Port();

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

    class _impl_Calcium_String_Port :
      public virtual _impl_Calcium_Port
    {
    public:
      virtual ~_impl_Calcium_String_Port();

      virtual void put(const ::Ports::Calcium_Ports::seq_string& data, ::CORBA::Double time, ::CORBA::Long tag) = 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_Calcium_String_Port;

#ifndef __Ports_mCalcium__Ports_mCalcium__Logical__Port__
#define __Ports_mCalcium__Ports_mCalcium__Logical__Port__

    class Calcium_Logical_Port;
    class _objref_Calcium_Logical_Port;
    class _impl_Calcium_Logical_Port;
    
    typedef _objref_Calcium_Logical_Port* Calcium_Logical_Port_ptr;
    typedef Calcium_Logical_Port_ptr Calcium_Logical_PortRef;

    class Calcium_Logical_Port_Helper {
    public:
      typedef Calcium_Logical_Port_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_Calcium_Logical_Port, Calcium_Logical_Port_Helper> Calcium_Logical_Port_var;
    typedef _CORBA_ObjRef_OUT_arg<_objref_Calcium_Logical_Port,Calcium_Logical_Port_Helper > Calcium_Logical_Port_out;

#endif

    // interface Calcium_Logical_Port
    class Calcium_Logical_Port {
    public:
      // Declarations for this interface type.
      typedef Calcium_Logical_Port_ptr _ptr_type;
      typedef Calcium_Logical_Port_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_Calcium_Logical_Port :
      public virtual _objref_Calcium_Port
    {
    public:
      void put(const ::Ports::Calcium_Ports::seq_boolean& data, ::CORBA::Double time, ::CORBA::Long tag);

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

    protected:
      virtual ~_objref_Calcium_Logical_Port();

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

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

      friend class Calcium_Logical_Port;
    };

    class _pof_Calcium_Logical_Port : public _OMNI_NS(proxyObjectFactory) {
    public:
      inline _pof_Calcium_Logical_Port() : _OMNI_NS(proxyObjectFactory)(Calcium_Logical_Port::_PD_repoId) {}
      virtual ~_pof_Calcium_Logical_Port();

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

    class _impl_Calcium_Logical_Port :
      public virtual _impl_Calcium_Port
    {
    public:
      virtual ~_impl_Calcium_Logical_Port();

      virtual void put(const ::Ports::Calcium_Ports::seq_boolean& data, ::CORBA::Double time, ::CORBA::Long tag) = 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_Calcium_Logical_Port;

#ifndef __Ports_mCalcium__Ports_mCalcium__Complex__Port__
#define __Ports_mCalcium__Ports_mCalcium__Complex__Port__

    class Calcium_Complex_Port;
    class _objref_Calcium_Complex_Port;
    class _impl_Calcium_Complex_Port;
    
    typedef _objref_Calcium_Complex_Port* Calcium_Complex_Port_ptr;
    typedef Calcium_Complex_Port_ptr Calcium_Complex_PortRef;

    class Calcium_Complex_Port_Helper {
    public:
      typedef Calcium_Complex_Port_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_Calcium_Complex_Port, Calcium_Complex_Port_Helper> Calcium_Complex_Port_var;
    typedef _CORBA_ObjRef_OUT_arg<_objref_Calcium_Complex_Port,Calcium_Complex_Port_Helper > Calcium_Complex_Port_out;

#endif

    // interface Calcium_Complex_Port
    class Calcium_Complex_Port {
    public:
      // Declarations for this interface type.
      typedef Calcium_Complex_Port_ptr _ptr_type;
      typedef Calcium_Complex_Port_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_Calcium_Complex_Port :
      public virtual _objref_Calcium_Port
    {
    public:
      void put(const ::Ports::Calcium_Ports::seq_complex& data, ::CORBA::Double time, ::CORBA::Long tag);

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

    protected:
      virtual ~_objref_Calcium_Complex_Port();

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

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

      friend class Calcium_Complex_Port;
    };

    class _pof_Calcium_Complex_Port : public _OMNI_NS(proxyObjectFactory) {
    public:
      inline _pof_Calcium_Complex_Port() : _OMNI_NS(proxyObjectFactory)(Calcium_Complex_Port::_PD_repoId) {}
      virtual ~_pof_Calcium_Complex_Port();

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

    class _impl_Calcium_Complex_Port :
      public virtual _impl_Calcium_Port
    {
    public:
      virtual ~_impl_Calcium_Complex_Port();

      virtual void put(const ::Ports::Calcium_Ports::seq_complex& data, ::CORBA::Double time, ::CORBA::Long tag) = 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_Calcium_Complex_Port;

  _CORBA_MODULE_END

_CORBA_MODULE_END



_CORBA_MODULE POA_Ports
_CORBA_MODULE_BEG

  _CORBA_MODULE Calcium_Ports
  _CORBA_MODULE_BEG

    class Calcium_Port :
      public virtual Ports::Calcium_Ports::_impl_Calcium_Port,
      public virtual Data_Port,
        public virtual PortProperties
    {
    public:
      virtual ~Calcium_Port();

      inline ::Ports::Calcium_Ports::Calcium_Port_ptr _this() {
        return (::Ports::Calcium_Ports::Calcium_Port_ptr) _do_this(::Ports::Calcium_Ports::Calcium_Port::_PD_repoId);
      }
    };

    class Calcium_Integer_Port :
      public virtual Ports::Calcium_Ports::_impl_Calcium_Integer_Port,
      public virtual Calcium_Port
    {
    public:
      virtual ~Calcium_Integer_Port();

      inline ::Ports::Calcium_Ports::Calcium_Integer_Port_ptr _this() {
        return (::Ports::Calcium_Ports::Calcium_Integer_Port_ptr) _do_this(::Ports::Calcium_Ports::Calcium_Integer_Port::_PD_repoId);
      }
    };

    class Calcium_Intc_Port :
      public virtual Ports::Calcium_Ports::_impl_Calcium_Intc_Port,
      public virtual Calcium_Port
    {
    public:
      virtual ~Calcium_Intc_Port();

      inline ::Ports::Calcium_Ports::Calcium_Intc_Port_ptr _this() {
        return (::Ports::Calcium_Ports::Calcium_Intc_Port_ptr) _do_this(::Ports::Calcium_Ports::Calcium_Intc_Port::_PD_repoId);
      }
    };

    class Calcium_Long_Port :
      public virtual Ports::Calcium_Ports::_impl_Calcium_Long_Port,
      public virtual Calcium_Port
    {
    public:
      virtual ~Calcium_Long_Port();

      inline ::Ports::Calcium_Ports::Calcium_Long_Port_ptr _this() {
        return (::Ports::Calcium_Ports::Calcium_Long_Port_ptr) _do_this(::Ports::Calcium_Ports::Calcium_Long_Port::_PD_repoId);
      }
    };

    class Calcium_Real_Port :
      public virtual Ports::Calcium_Ports::_impl_Calcium_Real_Port,
      public virtual Calcium_Port
    {
    public:
      virtual ~Calcium_Real_Port();

      inline ::Ports::Calcium_Ports::Calcium_Real_Port_ptr _this() {
        return (::Ports::Calcium_Ports::Calcium_Real_Port_ptr) _do_this(::Ports::Calcium_Ports::Calcium_Real_Port::_PD_repoId);
      }
    };

    class Calcium_Double_Port :
      public virtual Ports::Calcium_Ports::_impl_Calcium_Double_Port,
      public virtual Calcium_Port
    {
    public:
      virtual ~Calcium_Double_Port();

      inline ::Ports::Calcium_Ports::Calcium_Double_Port_ptr _this() {
        return (::Ports::Calcium_Ports::Calcium_Double_Port_ptr) _do_this(::Ports::Calcium_Ports::Calcium_Double_Port::_PD_repoId);
      }
    };

    class Calcium_String_Port :
      public virtual Ports::Calcium_Ports::_impl_Calcium_String_Port,
      public virtual Calcium_Port
    {
    public:
      virtual ~Calcium_String_Port();

      inline ::Ports::Calcium_Ports::Calcium_String_Port_ptr _this() {
        return (::Ports::Calcium_Ports::Calcium_String_Port_ptr) _do_this(::Ports::Calcium_Ports::Calcium_String_Port::_PD_repoId);
      }
    };

    class Calcium_Logical_Port :
      public virtual Ports::Calcium_Ports::_impl_Calcium_Logical_Port,
      public virtual Calcium_Port
    {
    public:
      virtual ~Calcium_Logical_Port();

      inline ::Ports::Calcium_Ports::Calcium_Logical_Port_ptr _this() {
        return (::Ports::Calcium_Ports::Calcium_Logical_Port_ptr) _do_this(::Ports::Calcium_Ports::Calcium_Logical_Port::_PD_repoId);
      }
    };

    class Calcium_Complex_Port :
      public virtual Ports::Calcium_Ports::_impl_Calcium_Complex_Port,
      public virtual Calcium_Port
    {
    public:
      virtual ~Calcium_Complex_Port();

      inline ::Ports::Calcium_Ports::Calcium_Complex_Port_ptr _this() {
        return (::Ports::Calcium_Ports::Calcium_Complex_Port_ptr) _do_this(::Ports::Calcium_Ports::Calcium_Complex_Port::_PD_repoId);
      }
    };

  _CORBA_MODULE_END

_CORBA_MODULE_END



_CORBA_MODULE OBV_Ports
_CORBA_MODULE_BEG

  _CORBA_MODULE Calcium_Ports
  _CORBA_MODULE_BEG

  _CORBA_MODULE_END

_CORBA_MODULE_END





#undef _core_attr
#undef _dyn_attr

inline void operator >>=(Ports::Calcium_Ports::DependencyType _e, cdrStream& s) {
  ::operator>>=((::CORBA::ULong)_e, s);
}

inline void operator <<= (Ports::Calcium_Ports::DependencyType& _e, cdrStream& s) {
  ::CORBA::ULong _0RL_e;
  ::operator<<=(_0RL_e,s);
  if (_0RL_e <= Ports::Calcium_Ports::ITERATION_DEPENDENCY) {
    _e = (Ports::Calcium_Ports::DependencyType) _0RL_e;
  }
  else {
    OMNIORB_THROW(MARSHAL,_OMNI_NS(MARSHAL_InvalidEnumValue),
                  (::CORBA::CompletionStatus)s.completion());
  }
}

void operator<<=(::CORBA::Any& _a, Ports::Calcium_Ports::DependencyType _s);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, Ports::Calcium_Ports::DependencyType& _s);

inline void operator >>=(Ports::Calcium_Ports::DateCalSchem _e, cdrStream& s) {
  ::operator>>=((::CORBA::ULong)_e, s);
}

inline void operator <<= (Ports::Calcium_Ports::DateCalSchem& _e, cdrStream& s) {
  ::CORBA::ULong _0RL_e;
  ::operator<<=(_0RL_e,s);
  if (_0RL_e <= Ports::Calcium_Ports::ALPHA_SCHEM) {
    _e = (Ports::Calcium_Ports::DateCalSchem) _0RL_e;
  }
  else {
    OMNIORB_THROW(MARSHAL,_OMNI_NS(MARSHAL_InvalidEnumValue),
                  (::CORBA::CompletionStatus)s.completion());
  }
}

void operator<<=(::CORBA::Any& _a, Ports::Calcium_Ports::DateCalSchem _s);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, Ports::Calcium_Ports::DateCalSchem& _s);

inline void operator >>=(Ports::Calcium_Ports::InterpolationSchem _e, cdrStream& s) {
  ::operator>>=((::CORBA::ULong)_e, s);
}

inline void operator <<= (Ports::Calcium_Ports::InterpolationSchem& _e, cdrStream& s) {
  ::CORBA::ULong _0RL_e;
  ::operator<<=(_0RL_e,s);
  if (_0RL_e <= Ports::Calcium_Ports::L1_SCHEM) {
    _e = (Ports::Calcium_Ports::InterpolationSchem) _0RL_e;
  }
  else {
    OMNIORB_THROW(MARSHAL,_OMNI_NS(MARSHAL_InvalidEnumValue),
                  (::CORBA::CompletionStatus)s.completion());
  }
}

void operator<<=(::CORBA::Any& _a, Ports::Calcium_Ports::InterpolationSchem _s);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, Ports::Calcium_Ports::InterpolationSchem& _s);

inline void operator >>=(Ports::Calcium_Ports::ExtrapolationSchem _e, cdrStream& s) {
  ::operator>>=((::CORBA::ULong)_e, s);
}

inline void operator <<= (Ports::Calcium_Ports::ExtrapolationSchem& _e, cdrStream& s) {
  ::CORBA::ULong _0RL_e;
  ::operator<<=(_0RL_e,s);
  if (_0RL_e <= Ports::Calcium_Ports::E1_SCHEM) {
    _e = (Ports::Calcium_Ports::ExtrapolationSchem) _0RL_e;
  }
  else {
    OMNIORB_THROW(MARSHAL,_OMNI_NS(MARSHAL_InvalidEnumValue),
                  (::CORBA::CompletionStatus)s.completion());
  }
}

void operator<<=(::CORBA::Any& _a, Ports::Calcium_Ports::ExtrapolationSchem _s);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, Ports::Calcium_Ports::ExtrapolationSchem& _s);

void operator<<=(::CORBA::Any& _a, Ports::Calcium_Ports::Calcium_Port_ptr _s);
void operator<<=(::CORBA::Any& _a, Ports::Calcium_Ports::Calcium_Port_ptr* _s);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, Ports::Calcium_Ports::Calcium_Port_ptr& _s);

void operator<<=(::CORBA::Any& _a, const Ports::Calcium_Ports::seq_long& _s);
void operator<<=(::CORBA::Any& _a, Ports::Calcium_Ports::seq_long* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, Ports::Calcium_Ports::seq_long*& _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const Ports::Calcium_Ports::seq_long*& _sp);

void operator<<=(::CORBA::Any& _a, const Ports::Calcium_Ports::seq_long_long& _s);
void operator<<=(::CORBA::Any& _a, Ports::Calcium_Ports::seq_long_long* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, Ports::Calcium_Ports::seq_long_long*& _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const Ports::Calcium_Ports::seq_long_long*& _sp);

void operator<<=(::CORBA::Any& _a, const Ports::Calcium_Ports::seq_integer& _s);
void operator<<=(::CORBA::Any& _a, Ports::Calcium_Ports::seq_integer* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, Ports::Calcium_Ports::seq_integer*& _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const Ports::Calcium_Ports::seq_integer*& _sp);

void operator<<=(::CORBA::Any& _a, const Ports::Calcium_Ports::seq_float& _s);
void operator<<=(::CORBA::Any& _a, Ports::Calcium_Ports::seq_float* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, Ports::Calcium_Ports::seq_float*& _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const Ports::Calcium_Ports::seq_float*& _sp);

void operator<<=(::CORBA::Any& _a, const Ports::Calcium_Ports::seq_double& _s);
void operator<<=(::CORBA::Any& _a, Ports::Calcium_Ports::seq_double* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, Ports::Calcium_Ports::seq_double*& _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const Ports::Calcium_Ports::seq_double*& _sp);

void operator<<=(::CORBA::Any& _a, const Ports::Calcium_Ports::seq_string& _s);
void operator<<=(::CORBA::Any& _a, Ports::Calcium_Ports::seq_string* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, Ports::Calcium_Ports::seq_string*& _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const Ports::Calcium_Ports::seq_string*& _sp);

void operator<<=(::CORBA::Any& _a, const Ports::Calcium_Ports::seq_boolean& _s);
void operator<<=(::CORBA::Any& _a, Ports::Calcium_Ports::seq_boolean* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, Ports::Calcium_Ports::seq_boolean*& _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const Ports::Calcium_Ports::seq_boolean*& _sp);

void operator<<=(::CORBA::Any& _a, Ports::Calcium_Ports::Calcium_Integer_Port_ptr _s);
void operator<<=(::CORBA::Any& _a, Ports::Calcium_Ports::Calcium_Integer_Port_ptr* _s);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, Ports::Calcium_Ports::Calcium_Integer_Port_ptr& _s);

void operator<<=(::CORBA::Any& _a, Ports::Calcium_Ports::Calcium_Intc_Port_ptr _s);
void operator<<=(::CORBA::Any& _a, Ports::Calcium_Ports::Calcium_Intc_Port_ptr* _s);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, Ports::Calcium_Ports::Calcium_Intc_Port_ptr& _s);

void operator<<=(::CORBA::Any& _a, Ports::Calcium_Ports::Calcium_Long_Port_ptr _s);
void operator<<=(::CORBA::Any& _a, Ports::Calcium_Ports::Calcium_Long_Port_ptr* _s);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, Ports::Calcium_Ports::Calcium_Long_Port_ptr& _s);

void operator<<=(::CORBA::Any& _a, Ports::Calcium_Ports::Calcium_Real_Port_ptr _s);
void operator<<=(::CORBA::Any& _a, Ports::Calcium_Ports::Calcium_Real_Port_ptr* _s);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, Ports::Calcium_Ports::Calcium_Real_Port_ptr& _s);

void operator<<=(::CORBA::Any& _a, Ports::Calcium_Ports::Calcium_Double_Port_ptr _s);
void operator<<=(::CORBA::Any& _a, Ports::Calcium_Ports::Calcium_Double_Port_ptr* _s);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, Ports::Calcium_Ports::Calcium_Double_Port_ptr& _s);

void operator<<=(::CORBA::Any& _a, Ports::Calcium_Ports::Calcium_String_Port_ptr _s);
void operator<<=(::CORBA::Any& _a, Ports::Calcium_Ports::Calcium_String_Port_ptr* _s);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, Ports::Calcium_Ports::Calcium_String_Port_ptr& _s);

void operator<<=(::CORBA::Any& _a, Ports::Calcium_Ports::Calcium_Logical_Port_ptr _s);
void operator<<=(::CORBA::Any& _a, Ports::Calcium_Ports::Calcium_Logical_Port_ptr* _s);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, Ports::Calcium_Ports::Calcium_Logical_Port_ptr& _s);

void operator<<=(::CORBA::Any& _a, Ports::Calcium_Ports::Calcium_Complex_Port_ptr _s);
void operator<<=(::CORBA::Any& _a, Ports::Calcium_Ports::Calcium_Complex_Port_ptr* _s);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, Ports::Calcium_Ports::Calcium_Complex_Port_ptr& _s);



inline void
Ports::Calcium_Ports::Calcium_Port::_marshalObjRef(::Ports::Calcium_Ports::Calcium_Port_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
Ports::Calcium_Ports::Calcium_Integer_Port::_marshalObjRef(::Ports::Calcium_Ports::Calcium_Integer_Port_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
Ports::Calcium_Ports::Calcium_Intc_Port::_marshalObjRef(::Ports::Calcium_Ports::Calcium_Intc_Port_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
Ports::Calcium_Ports::Calcium_Long_Port::_marshalObjRef(::Ports::Calcium_Ports::Calcium_Long_Port_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
Ports::Calcium_Ports::Calcium_Real_Port::_marshalObjRef(::Ports::Calcium_Ports::Calcium_Real_Port_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
Ports::Calcium_Ports::Calcium_Double_Port::_marshalObjRef(::Ports::Calcium_Ports::Calcium_Double_Port_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
Ports::Calcium_Ports::Calcium_String_Port::_marshalObjRef(::Ports::Calcium_Ports::Calcium_String_Port_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
Ports::Calcium_Ports::Calcium_Logical_Port::_marshalObjRef(::Ports::Calcium_Ports::Calcium_Logical_Port_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
Ports::Calcium_Ports::Calcium_Complex_Port::_marshalObjRef(::Ports::Calcium_Ports::Calcium_Complex_Port_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}




#ifdef   USE_stub_in_nt_dll_NOT_DEFINED_Calcium__Ports
# undef  USE_stub_in_nt_dll
# undef  USE_stub_in_nt_dll_NOT_DEFINED_Calcium__Ports
#endif
#ifdef   USE_core_stub_in_nt_dll_NOT_DEFINED_Calcium__Ports
# undef  USE_core_stub_in_nt_dll
# undef  USE_core_stub_in_nt_dll_NOT_DEFINED_Calcium__Ports
#endif
#ifdef   USE_dyn_stub_in_nt_dll_NOT_DEFINED_Calcium__Ports
# undef  USE_dyn_stub_in_nt_dll
# undef  USE_dyn_stub_in_nt_dll_NOT_DEFINED_Calcium__Ports
#endif

#endif  // __Calcium__Ports_hh__