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

// This file is generated by omniidl (C++ backend)- omniORB_4_1. Do not edit.
#ifndef __SALOME__Parametric_hh__
#define __SALOME__Parametric_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_SALOME__Parametric
#endif
#ifndef  USE_core_stub_in_nt_dll
# define USE_core_stub_in_nt_dll_NOT_DEFINED_SALOME__Parametric
#endif
#ifndef  USE_dyn_stub_in_nt_dll
# define USE_dyn_stub_in_nt_dll_NOT_DEFINED_SALOME__Parametric
#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 SALOME_TYPES

_CORBA_MODULE_BEG

  struct Parameter {
    typedef _CORBA_ConstrType_Variable_Var<Parameter> _var_type;

    
    ::CORBA::String_member name;

    ::CORBA::String_member value;

  

    void operator>>= (cdrStream &) const;
    void operator<<= (cdrStream &);
  };

  typedef Parameter::_var_type Parameter_var;

  typedef _CORBA_ConstrType_Variable_OUT_arg< Parameter,Parameter_var > Parameter_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_Parameter;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_ParameterList;

  class ParameterList_var;

  class ParameterList : public _CORBA_Unbounded_Sequence< Parameter >  {
  public:
    typedef ParameterList_var _var_type;
    inline ParameterList() {}
    inline ParameterList(const ParameterList& _s)
      : _CORBA_Unbounded_Sequence< Parameter > (_s) {}

    inline ParameterList(_CORBA_ULong _max)
      : _CORBA_Unbounded_Sequence< Parameter > (_max) {}
    inline ParameterList(_CORBA_ULong _max, _CORBA_ULong _len, Parameter* _val, _CORBA_Boolean _rel=0)
      : _CORBA_Unbounded_Sequence< Parameter > (_max, _len, _val, _rel) {}

  

    inline ParameterList& operator = (const ParameterList& _s) {
      _CORBA_Unbounded_Sequence< Parameter > ::operator=(_s);
      return *this;
    }
  };

  class ParameterList_out;

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

  

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

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

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

  

    ParameterList*& _data;

  private:
    ParameterList_out();
    ParameterList_out& operator=(const ParameterList_var&);
  };

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_Variable;

  class Variable_var;

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

    inline Variable(_CORBA_ULong _max)
      : _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::Double, 8, 8 > (_max) {}
    inline Variable(_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 Variable& operator = (const Variable& _s) {
      _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::Double, 8, 8 > ::operator=(_s);
      return *this;
    }
  };

  class Variable_out;

  class Variable_var {
  public:
    inline Variable_var() : _pd_seq(0) {}
    inline Variable_var(Variable* _s) : _pd_seq(_s) {}
    inline Variable_var(const Variable_var& _s) {
      if( _s._pd_seq )  _pd_seq = new Variable(*_s._pd_seq);
      else              _pd_seq = 0;
    }
    inline ~Variable_var() { if( _pd_seq )  delete _pd_seq; }
      
    inline Variable_var& operator = (Variable* _s) {
      if( _pd_seq )  delete _pd_seq;
      _pd_seq = _s;
      return *this;
    }
    inline Variable_var& operator = (const Variable_var& _s) {
      if( _s._pd_seq ) {
        if( !_pd_seq )  _pd_seq = new Variable;
        *_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 Variable* operator -> () { return _pd_seq; }
    inline const Variable* operator -> () const { return _pd_seq; }
#if defined(__GNUG__)
    inline operator Variable& () const { return *_pd_seq; }
#else
    inline operator const Variable& () const { return *_pd_seq; }
    inline operator Variable& () { return *_pd_seq; }
#endif
      
    inline const Variable& in() const { return *_pd_seq; }
    inline Variable&       inout()    { return *_pd_seq; }
    inline Variable*&      out() {
      if( _pd_seq ) { delete _pd_seq; _pd_seq = 0; }
      return _pd_seq;
    }
    inline Variable* _retn() { Variable* tmp = _pd_seq; _pd_seq = 0; return tmp; }
      
    friend class Variable_out;
    
  private:
    Variable* _pd_seq;
  };

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

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

  

    Variable*& _data;

  private:
    Variable_out();
    Variable_out& operator=(const Variable_var&);
  };

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_VariableSequence;

  class VariableSequence_var;

  class VariableSequence : public _CORBA_Unbounded_Sequence< Variable >  {
  public:
    typedef VariableSequence_var _var_type;
    inline VariableSequence() {}
    inline VariableSequence(const VariableSequence& _s)
      : _CORBA_Unbounded_Sequence< Variable > (_s) {}

    inline VariableSequence(_CORBA_ULong _max)
      : _CORBA_Unbounded_Sequence< Variable > (_max) {}
    inline VariableSequence(_CORBA_ULong _max, _CORBA_ULong _len, Variable* _val, _CORBA_Boolean _rel=0)
      : _CORBA_Unbounded_Sequence< Variable > (_max, _len, _val, _rel) {}

  

    inline VariableSequence& operator = (const VariableSequence& _s) {
      _CORBA_Unbounded_Sequence< Variable > ::operator=(_s);
      return *this;
    }
  };

  class VariableSequence_out;

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

  

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

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

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

  

    VariableSequence*& _data;

  private:
    VariableSequence_out();
    VariableSequence_out& operator=(const VariableSequence_var&);
  };

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_StateSequence;

  class StateSequence_var;

  class StateSequence : public _CORBA_Unbounded_Sequence< VariableSequence >  {
  public:
    typedef StateSequence_var _var_type;
    inline StateSequence() {}
    inline StateSequence(const StateSequence& _s)
      : _CORBA_Unbounded_Sequence< VariableSequence > (_s) {}

    inline StateSequence(_CORBA_ULong _max)
      : _CORBA_Unbounded_Sequence< VariableSequence > (_max) {}
    inline StateSequence(_CORBA_ULong _max, _CORBA_ULong _len, VariableSequence* _val, _CORBA_Boolean _rel=0)
      : _CORBA_Unbounded_Sequence< VariableSequence > (_max, _len, _val, _rel) {}

  

    inline StateSequence& operator = (const StateSequence& _s) {
      _CORBA_Unbounded_Sequence< VariableSequence > ::operator=(_s);
      return *this;
    }
  };

  class StateSequence_out;

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

  

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

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

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

  

    StateSequence*& _data;

  private:
    StateSequence_out();
    StateSequence_out& operator=(const StateSequence_var&);
  };

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_TimeSequence;

  class TimeSequence_var;

  class TimeSequence : public _CORBA_Unbounded_Sequence< StateSequence >  {
  public:
    typedef TimeSequence_var _var_type;
    inline TimeSequence() {}
    inline TimeSequence(const TimeSequence& _s)
      : _CORBA_Unbounded_Sequence< StateSequence > (_s) {}

    inline TimeSequence(_CORBA_ULong _max)
      : _CORBA_Unbounded_Sequence< StateSequence > (_max) {}
    inline TimeSequence(_CORBA_ULong _max, _CORBA_ULong _len, StateSequence* _val, _CORBA_Boolean _rel=0)
      : _CORBA_Unbounded_Sequence< StateSequence > (_max, _len, _val, _rel) {}

  

    inline TimeSequence& operator = (const TimeSequence& _s) {
      _CORBA_Unbounded_Sequence< StateSequence > ::operator=(_s);
      return *this;
    }
  };

  class TimeSequence_out;

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

  

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

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

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

  

    TimeSequence*& _data;

  private:
    TimeSequence_out();
    TimeSequence_out& operator=(const TimeSequence_var&);
  };

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_VarList;

  class VarList_var;

  class VarList : public _CORBA_Unbounded_Sequence_String {
  public:
    typedef VarList_var _var_type;
    inline VarList() {}
    inline VarList(const VarList& _s)
      : _CORBA_Unbounded_Sequence_String(_s) {}

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

  

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

  class VarList_out;

  class VarList_var {
  public:
    inline VarList_var() : _pd_seq(0) {}
    inline VarList_var(VarList* _s) : _pd_seq(_s) {}
    inline VarList_var(const VarList_var& _s) {
      if( _s._pd_seq )  _pd_seq = new VarList(*_s._pd_seq);
      else              _pd_seq = 0;
    }
    inline ~VarList_var() { if( _pd_seq )  delete _pd_seq; }
      
    inline VarList_var& operator = (VarList* _s) {
      if( _pd_seq )  delete _pd_seq;
      _pd_seq = _s;
      return *this;
    }
    inline VarList_var& operator = (const VarList_var& _s) {
      if( _s._pd_seq ) {
        if( !_pd_seq )  _pd_seq = new VarList;
        *_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 VarList* operator -> () { return _pd_seq; }
    inline const VarList* operator -> () const { return _pd_seq; }
#if defined(__GNUG__)
    inline operator VarList& () const { return *_pd_seq; }
#else
    inline operator const VarList& () const { return *_pd_seq; }
    inline operator VarList& () { return *_pd_seq; }
#endif
      
    inline const VarList& in() const { return *_pd_seq; }
    inline VarList&       inout()    { return *_pd_seq; }
    inline VarList*&      out() {
      if( _pd_seq ) { delete _pd_seq; _pd_seq = 0; }
      return _pd_seq;
    }
    inline VarList* _retn() { VarList* tmp = _pd_seq; _pd_seq = 0; return tmp; }
      
    friend class VarList_out;
    
  private:
    VarList* _pd_seq;
  };

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

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

  

    VarList*& _data;

  private:
    VarList_out();
    VarList_out& operator=(const VarList_var&);
  };

  struct ParametricInput {
    typedef _CORBA_ConstrType_Variable_Var<ParametricInput> _var_type;

    
    VarList inputVarList;

    VarList outputVarList;

    TimeSequence inputValues;

    ParameterList specificParameters;

  

    void operator>>= (cdrStream &) const;
    void operator<<= (cdrStream &);
  };

  typedef ParametricInput::_var_type ParametricInput_var;

  typedef _CORBA_ConstrType_Variable_OUT_arg< ParametricInput,ParametricInput_var > ParametricInput_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_ParametricInput;

  struct ParametricOutput {
    typedef _CORBA_ConstrType_Variable_Var<ParametricOutput> _var_type;

    
    TimeSequence outputValues;

    ParameterList specificOutputInfos;

    ::CORBA::Long returnCode;

    ::CORBA::String_member errorMessage;

  

    void operator>>= (cdrStream &) const;
    void operator<<= (cdrStream &);
  };

  typedef ParametricOutput::_var_type ParametricOutput_var;

  typedef _CORBA_ConstrType_Variable_OUT_arg< ParametricOutput,ParametricOutput_var > ParametricOutput_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_ParametricOutput;

_CORBA_MODULE_END



_CORBA_MODULE POA_SALOME_TYPES
_CORBA_MODULE_BEG

_CORBA_MODULE_END



_CORBA_MODULE OBV_SALOME_TYPES
_CORBA_MODULE_BEG

_CORBA_MODULE_END





#undef _core_attr
#undef _dyn_attr

extern void operator<<=(::CORBA::Any& _a, const SALOME_TYPES::Parameter& _s);
extern void operator<<=(::CORBA::Any& _a, SALOME_TYPES::Parameter* _sp);
extern _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, SALOME_TYPES::Parameter*& _sp);
extern _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const SALOME_TYPES::Parameter*& _sp);

void operator<<=(::CORBA::Any& _a, const SALOME_TYPES::ParameterList& _s);
void operator<<=(::CORBA::Any& _a, SALOME_TYPES::ParameterList* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, SALOME_TYPES::ParameterList*& _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const SALOME_TYPES::ParameterList*& _sp);

void operator<<=(::CORBA::Any& _a, const SALOME_TYPES::Variable& _s);
void operator<<=(::CORBA::Any& _a, SALOME_TYPES::Variable* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, SALOME_TYPES::Variable*& _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const SALOME_TYPES::Variable*& _sp);

void operator<<=(::CORBA::Any& _a, const SALOME_TYPES::VariableSequence& _s);
void operator<<=(::CORBA::Any& _a, SALOME_TYPES::VariableSequence* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, SALOME_TYPES::VariableSequence*& _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const SALOME_TYPES::VariableSequence*& _sp);

void operator<<=(::CORBA::Any& _a, const SALOME_TYPES::StateSequence& _s);
void operator<<=(::CORBA::Any& _a, SALOME_TYPES::StateSequence* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, SALOME_TYPES::StateSequence*& _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const SALOME_TYPES::StateSequence*& _sp);

void operator<<=(::CORBA::Any& _a, const SALOME_TYPES::TimeSequence& _s);
void operator<<=(::CORBA::Any& _a, SALOME_TYPES::TimeSequence* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, SALOME_TYPES::TimeSequence*& _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const SALOME_TYPES::TimeSequence*& _sp);

void operator<<=(::CORBA::Any& _a, const SALOME_TYPES::VarList& _s);
void operator<<=(::CORBA::Any& _a, SALOME_TYPES::VarList* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, SALOME_TYPES::VarList*& _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const SALOME_TYPES::VarList*& _sp);

extern void operator<<=(::CORBA::Any& _a, const SALOME_TYPES::ParametricInput& _s);
extern void operator<<=(::CORBA::Any& _a, SALOME_TYPES::ParametricInput* _sp);
extern _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, SALOME_TYPES::ParametricInput*& _sp);
extern _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const SALOME_TYPES::ParametricInput*& _sp);

extern void operator<<=(::CORBA::Any& _a, const SALOME_TYPES::ParametricOutput& _s);
extern void operator<<=(::CORBA::Any& _a, SALOME_TYPES::ParametricOutput* _sp);
extern _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, SALOME_TYPES::ParametricOutput*& _sp);
extern _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const SALOME_TYPES::ParametricOutput*& _sp);





#ifdef   USE_stub_in_nt_dll_NOT_DEFINED_SALOME__Parametric
# undef  USE_stub_in_nt_dll
# undef  USE_stub_in_nt_dll_NOT_DEFINED_SALOME__Parametric
#endif
#ifdef   USE_core_stub_in_nt_dll_NOT_DEFINED_SALOME__Parametric
# undef  USE_core_stub_in_nt_dll
# undef  USE_core_stub_in_nt_dll_NOT_DEFINED_SALOME__Parametric
#endif
#ifdef   USE_dyn_stub_in_nt_dll_NOT_DEFINED_SALOME__Parametric
# undef  USE_dyn_stub_in_nt_dll
# undef  USE_dyn_stub_in_nt_dll_NOT_DEFINED_SALOME__Parametric
#endif

#endif  // __SALOME__Parametric_hh__