[omniORB] IDL compiler output broken for VC++ in recent snapshots
Carl Thompson
cet@carlthompson.net
Wed, 31 Oct 2001 18:34:45 -0800
This is a multi-part message in MIME format.
--------------020401000905080208000706
Content-Type: text/plain; charset=us-ascii; format=flowed
Content-Transfer-Encoding: 7bit
Hello,
I am getting the following output when trying compile IDL compiler
output from omniORB4 2001-10-31 on Windows 2000 with VC++6sp5. I have
attached the offending header and idl files. The same IDL works fine on
the snapshot dated 2001-10-08 and with the current snapshot using GCC on
Linux. This idl and code also works with other ORBs so I'm pretty sure
it's a problem with the IDL compiler generating VC++ incompatible output.
Thank you,
Carl Thompson
cl -c -O2 -MT -TP -GX -nologo -D__WIN32__ -D__x86__ -D__NT__
-D__OSVERSION__=4 -D__OMNIORB4__ -I../../../../omniORB/work/src/include
-I../../../../omniORB/work/src/include/omniORB4 daemon_ui_impl.cc
-Foobj/daemon_ui_impl.obj
daemon_ui_impl.cc
corba/task.h(230) : error C2027: use of undefined type 'Task'
corba/task.h(92) : see declaration of 'Task'
corba/task.h(231) : error C2027: use of undefined type 'Task'
corba/task.h(92) : see declaration of 'Task'
corba/task.h(238) : error C2027: use of undefined type 'Task'
corba/task.h(92) : see declaration of 'Task'
corba/task.h(239) : error C2027: use of undefined type 'Task'
corba/task.h(92) : see declaration of 'Task'
corba/task.h(285) : error C2027: use of undefined type 'Task'
corba/task.h(92) : see declaration of 'Task'
corba/task.h(287) : error C2027: use of undefined type 'Task'
corba/task.h(92) : see declaration of 'Task'
--------------020401000905080208000706
Content-Type: text/plain;
name="task.idl"
Content-Transfer-Encoding: 7bit
Content-Disposition: inline;
filename="task.idl"
// LIBSAMS API
// Carl Thompson
// $Id: task.idl,v 1.1 2001/08/30 03:57:39 carl Exp $
#ifndef LIBSAMS_TASK_IDL
#define LIBSAMS_TASK_IDL
#include "types.idl"
// This is the interface to the UI side
// Everything in our own private namespace
module LIBSAMS {
// Interface for long running tasks
interface Task {
// --------------------------- Types ------------------------------------ //
enum Status { WAITING_S, PROCESSING_S, COMPLETED_S, CANCELLED_S, UNKNOWN_S };
enum Type { BACKUP_T, RESTORE_T, BULK_ADD_T, BULK_DELETE_T };
enum SelectType { START_SELECT, TYPE_SELECT, STATUS_SELECT, USER_SELECT };
// selection criterion for Tasks
union SelectInfo switch (SelectType) {
case START_SELECT:
// start time selection criterion
struct StartInfo {
When after; // start time must be this or after this
When before; // start time must be this or before this
} start_time;
case TYPE_SELECT:
// type selection criterion
Task::Type type;
case STATUS_SELECT:
Task::Status status;
case USER_SELECT:
MailAddress request_user;
};
typedef sequence<SelectInfo> SelectMask;
// ------------------------- Exceptions --------------------------------- //
// task has already started so cannot modify start time or cancel
exception AlreadyStarted {};
// ------------------------- Operations --------------------------------- //
// get the type of this task
Type get_type() raises (AccessDenied);
// get the completion status of this task
Status get_status() raises (AccessDenied);
// when was this task requested?
When get_request_time() raises (AccessDenied);
// what is the start time of this task?
When get_start_time() raises (AccessDenied);
// set the start time of this task
void set_start_time(in When start) raises (AccessDenied, AlreadyStarted);
// get the user that requested this task
MailAddress get_request_user() raises (AccessDenied);
// cancel this task (if possible)
void cancel() raises (AccessDenied, AlreadyStarted);
};
typedef sequence<Task> Tasks;
};
#endif
--------------020401000905080208000706
Content-Type: text/plain;
name="task.h"
Content-Transfer-Encoding: 7bit
Content-Disposition: inline;
filename="task.h"
// This file is generated by omniidl (C++ backend)- omniORB_4_0. Do not edit.
#ifndef __task_hh__
#define __task_hh__
#ifndef USE_omniORB_logStream
#define USE_omniORB_logStream
#endif
#ifndef __CORBA_H_EXTERNAL_GUARD__
#include <omniORB4/CORBA.h>
#endif
#ifndef USE_core_stub_in_nt_dll
# define USE_core_stub_in_nt_dll_NOT_DEFINED_task
#endif
#ifndef USE_dyn_stub_in_nt_dll
# define USE_dyn_stub_in_nt_dll_NOT_DEFINED_task
#endif
#ifndef __types_hh_EXTERNAL_GUARD__
#define __types_hh_EXTERNAL_GUARD__
#include "types.h"
#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 LIBSAMS
_CORBA_MODULE_BEG
#ifndef __LIBSAMS_mTask__
#define __LIBSAMS_mTask__
class Task;
class _objref_Task;
class _impl_Task;
typedef _objref_Task* Task_ptr;
typedef Task_ptr TaskRef;
class Task_Helper {
public:
typedef Task_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_Task, Task_Helper> Task_var;
typedef _CORBA_ObjRef_OUT_arg<_objref_Task,Task_Helper > Task_out;
#endif
class Task {
public:
// Declarations for this interface type.
typedef Task_ptr _ptr_type;
typedef Task_var _var_type;
static _ptr_type _duplicate(_ptr_type);
static _ptr_type _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.
enum Status { WAITING_S, PROCESSING_S, COMPLETED_S, CANCELLED_S, UNKNOWN_S /*, __max_Status=0xffffffff */ };
typedef Status& Status_out;
enum Type { BACKUP_T, RESTORE_T, BULK_ADD_T, BULK_DELETE_T /*, __max_Type=0xffffffff */ };
typedef Type& Type_out;
enum SelectType { START_SELECT, TYPE_SELECT, STATUS_SELECT, USER_SELECT /*, __max_SelectType=0xffffffff */ };
typedef SelectType& SelectType_out;
class SelectInfo {
public:
typedef _CORBA_ConstrType_Variable_Var<SelectInfo> _var_type;
struct StartInfo {
typedef _CORBA_ConstrType_Fix_Var<StartInfo> _var_type;
When after;
When before;
void operator>>= (cdrStream &) const;
void operator<<= (cdrStream &);
};
typedef StartInfo::_var_type StartInfo_var;
typedef StartInfo& StartInfo_out;
SelectInfo(): _pd__initialised(0) {
}
SelectInfo(const SelectInfo& _value) {
_pd__initialised = _value._pd__initialised;
switch(_value._pd__d) {
case START_SELECT: start_time(_value._pd_start_time); break;
case TYPE_SELECT: type(_value._pd_type); break;
case STATUS_SELECT: status(_value._pd_status); break;
case USER_SELECT: request_user(_value._pd_request_user); break;
default: break;
}
_pd__d = _value._pd__d;
}
~SelectInfo() {}
SelectInfo& operator=(const SelectInfo& _value) {
_pd__initialised = _value._pd__initialised;
switch(_value._pd__d) {
case START_SELECT: start_time(_value._pd_start_time); break;
case TYPE_SELECT: type(_value._pd_type); break;
case STATUS_SELECT: status(_value._pd_status); break;
case USER_SELECT: request_user(_value._pd_request_user); break;
default: break;
}
_pd__d = _value._pd__d;
return *this;
}
SelectType _d() const { return _pd__d;}
void _d(SelectType _value){
// illegal to set discriminator before making a member active
if (!_pd__initialised)
OMNIORB_THROW(BAD_PARAM,_OMNI_NS(BAD_PARAM_InvalidUnionDiscValue),CORBA::COMPLETED_NO);
if (_value == _pd__d) return; // no change
switch (_pd__d){
case START_SELECT: goto fail;
case TYPE_SELECT: goto fail;
case STATUS_SELECT: goto fail;
case USER_SELECT: goto fail;
default: goto fail;
};
fail:
OMNIORB_THROW(BAD_PARAM,_OMNI_NS(BAD_PARAM_InvalidUnionDiscValue),CORBA::COMPLETED_NO);
}
const StartInfo &start_time () const { return _pd_start_time; }
StartInfo &start_time () { return _pd_start_time; }
void start_time (const StartInfo& _value) {
_pd__initialised = 1;
_pd__d = START_SELECT;
_pd__default = 0;
_pd_start_time = _value;
}
Task::Type type () const { return _pd_type; }
void type (Task::Type _value) {
_pd__initialised = 1;
_pd__d = TYPE_SELECT;
_pd__default = 0;
_pd_type = _value;
}
Task::Status status () const { return _pd_status; }
void status (Task::Status _value) {
_pd__initialised = 1;
_pd__d = STATUS_SELECT;
_pd__default = 0;
_pd_status = _value;
}
const char * request_user () const { return (const char*) _pd_request_user; }
void request_user(char* _value) {
_pd__initialised = 1;
_pd__d = USER_SELECT;
_pd__default = 0;
_pd_request_user = _value;
}
void request_user(const char* _value) {
_pd__initialised = 1;
_pd__d = USER_SELECT;
_pd__default = 0;
_pd_request_user = _value;
}
void request_user(const CORBA::String_var& _value) {
_pd__initialised = 1;
_pd__d = USER_SELECT;
_pd__default = 0;
_pd_request_user = _value;
}
void request_user(const CORBA::String_member& _value) {
_pd__initialised = 1;
_pd__d = USER_SELECT;
_pd__default = 0;
_pd_request_user = _value;
}
void operator>>= (cdrStream&) const;
void operator<<= (cdrStream&);
private:
SelectType _pd__d;
CORBA::Boolean _pd__default;
CORBA::Boolean _pd__initialised;
union {
Task::Type _pd_type;
Task::Status _pd_status;
};
StartInfo _pd_start_time;
CORBA::String_member _pd_request_user;
};
typedef SelectInfo::_var_type SelectInfo_var;
typedef _CORBA_ConstrType_Variable_OUT_arg< SelectInfo,SelectInfo_var > SelectInfo_out;
class SelectMask_var;
class SelectMask : public _CORBA_Unbounded_Sequence< SelectInfo > {
public:
typedef SelectMask_var _var_type;
inline SelectMask() {}
inline SelectMask(const SelectMask& _s)
: _CORBA_Unbounded_Sequence< SelectInfo > (_s) {}
inline SelectMask(_CORBA_ULong _max)
: _CORBA_Unbounded_Sequence< SelectInfo > (_max) {}
inline SelectMask(_CORBA_ULong _max, _CORBA_ULong _len, SelectInfo* _val, _CORBA_Boolean _rel=0)
: _CORBA_Unbounded_Sequence< SelectInfo > (_max, _len, _val, _rel) {}
inline SelectMask& operator = (const SelectMask& _s) {
_CORBA_Unbounded_Sequence< SelectInfo > ::operator=(_s);
return *this;
}
};
class SelectMask_out;
class SelectMask_var {
public:
inline SelectMask_var() : _pd_seq(0) {}
inline SelectMask_var(SelectMask* _s) : _pd_seq(_s) {}
inline SelectMask_var(const SelectMask_var& _s) {
if( _s._pd_seq ) _pd_seq = new SelectMask(*_s._pd_seq);
else _pd_seq = 0;
}
inline ~SelectMask_var() { if( _pd_seq ) delete _pd_seq; }
inline SelectMask_var& operator = (SelectMask* _s) {
if( _pd_seq ) delete _pd_seq;
_pd_seq = _s;
return *this;
}
inline SelectMask_var& operator = (const SelectMask_var& _s) {
if( _s._pd_seq ) {
if( !_pd_seq ) _pd_seq = new SelectMask;
*_pd_seq = *_s._pd_seq;
} else if( _pd_seq ) {
delete _pd_seq;
_pd_seq = 0;
}
return *this;
}
inline SelectInfo& operator [] (_CORBA_ULong _s) {
return (*_pd_seq)[_s];
}
inline SelectMask* operator -> () { return _pd_seq; }
#if defined(__GNUG__)
inline operator SelectMask& () const { return *_pd_seq; }
#else
inline operator const SelectMask& () const { return *_pd_seq; }
inline operator SelectMask& () { return *_pd_seq; }
#endif
inline const SelectMask& in() const { return *_pd_seq; }
inline SelectMask& inout() { return *_pd_seq; }
inline SelectMask*& out() {
if( _pd_seq ) { delete _pd_seq; _pd_seq = 0; }
return _pd_seq;
}
inline SelectMask* _retn() { SelectMask* tmp = _pd_seq; _pd_seq = 0; return tmp; }
friend class SelectMask_out;
private:
SelectMask* _pd_seq;
};
class SelectMask_out {
public:
inline SelectMask_out(SelectMask*& _s) : _data(_s) { _data = 0; }
inline SelectMask_out(SelectMask_var& _s)
: _data(_s._pd_seq) { _s = (SelectMask*) 0; }
inline SelectMask_out(const SelectMask_out& _s) : _data(_s._data) {}
inline SelectMask_out& operator = (const SelectMask_out& _s) {
_data = _s._data;
return *this;
}
inline SelectMask_out& operator = (SelectMask* _s) {
_data = _s;
return *this;
}
inline operator SelectMask*&() { return _data; }
inline SelectMask*& ptr() { return _data; }
inline SelectMask* operator->() { return _data; }
inline SelectInfo& operator [] (_CORBA_ULong _i) {
return (*_data)[_i];
}
SelectMask*& _data;
private:
SelectMask_out();
SelectMask_out& operator=(const SelectMask_var&);
};
class AlreadyStarted : public CORBA::UserException {
public:
inline AlreadyStarted() {
pd_insertToAnyFn = insertToAnyFn;
pd_insertToAnyFnNCP = insertToAnyFnNCP;
}
AlreadyStarted(const AlreadyStarted&);
AlreadyStarted& operator=(const AlreadyStarted&);
virtual ~AlreadyStarted();
virtual void _raise() const;
static AlreadyStarted* _downcast(CORBA::Exception*);
static const AlreadyStarted* _downcast(const CORBA::Exception*);
static inline AlreadyStarted* _narrow(CORBA::Exception* _e) {
return _downcast(_e);
}
inline void operator>>=(cdrStream&) const { }
inline void operator<<=(cdrStream&) { }
static _core_attr insertExceptionToAny insertToAnyFn;
static _core_attr insertExceptionToAnyNCP insertToAnyFnNCP;
virtual CORBA::Exception* _NP_duplicate() const;
static _core_attr const char* _PD_repoId;
static _core_attr const char* _PD_typeId;
private:
virtual const char* _NP_typeId() const;
virtual const char* _NP_repoId(int*) const;
virtual void _NP_marshal(cdrStream&) const;
};
};
class _objref_Task :
public virtual CORBA::Object, public virtual omniObjRef
{
public:
Task::Type get_type();
Task::Status get_status();
When get_request_time();
When get_start_time();
void set_start_time(When start);
char* get_request_user();
void cancel();
inline _objref_Task() { _PR_setobj(0); } // nil
_objref_Task(omniIOR*, omniIdentity*);
protected:
virtual ~_objref_Task();
private:
virtual void* _ptrToObjRef(const char*);
_objref_Task(const _objref_Task&);
_objref_Task& operator = (const _objref_Task&);
// not implemented
};
class _pof_Task : public _OMNI_NS(proxyObjectFactory) {
public:
inline _pof_Task() : _OMNI_NS(proxyObjectFactory)(Task::_PD_repoId) {}
virtual ~_pof_Task();
virtual omniObjRef* newObjRef(omniIOR*,omniIdentity*);
virtual _CORBA_Boolean is_a(const char*) const;
};
class _impl_Task :
public virtual omniServant
{
public:
virtual ~_impl_Task();
virtual Task::Type get_type() = 0;
virtual Task::Status get_status() = 0;
virtual When get_request_time() = 0;
virtual When get_start_time() = 0;
virtual void set_start_time(When start) = 0;
virtual char* get_request_user() = 0;
virtual void cancel() = 0;
public: // Really protected, workaround for xlC
virtual _CORBA_Boolean _dispatch(omniCallHandle&);
private:
virtual void* _ptrToInterface(const char*);
virtual const char* _mostDerivedRepoId();
};
class Tasks_var;
class Tasks : public _CORBA_Unbounded_Sequence_ObjRef< _objref_Task, _CORBA_ObjRef_Element< _objref_Task, Task_Helper> , Task_Helper > {
public:
typedef Tasks_var _var_type;
inline Tasks() {}
inline Tasks(const Tasks& _s)
: _CORBA_Unbounded_Sequence_ObjRef< _objref_Task, _CORBA_ObjRef_Element< _objref_Task, Task_Helper> , Task_Helper > (_s) {}
inline Tasks(_CORBA_ULong _max)
: _CORBA_Unbounded_Sequence_ObjRef< _objref_Task, _CORBA_ObjRef_Element< _objref_Task, Task_Helper> , Task_Helper > (_max) {}
inline Tasks(_CORBA_ULong _max, _CORBA_ULong _len, Task_ptr* _val, _CORBA_Boolean _rel=0)
: _CORBA_Unbounded_Sequence_ObjRef< _objref_Task, _CORBA_ObjRef_Element< _objref_Task, Task_Helper> , Task_Helper > (_max, _len, _val, _rel) {}
inline Tasks& operator = (const Tasks& _s) {
_CORBA_Unbounded_Sequence_ObjRef< _objref_Task, _CORBA_ObjRef_Element< _objref_Task, Task_Helper> , Task_Helper > ::operator=(_s);
return *this;
}
};
class Tasks_out;
class Tasks_var {
public:
inline Tasks_var() : _pd_seq(0) {}
inline Tasks_var(Tasks* _s) : _pd_seq(_s) {}
inline Tasks_var(const Tasks_var& _s) {
if( _s._pd_seq ) _pd_seq = new Tasks(*_s._pd_seq);
else _pd_seq = 0;
}
inline ~Tasks_var() { if( _pd_seq ) delete _pd_seq; }
inline Tasks_var& operator = (Tasks* _s) {
if( _pd_seq ) delete _pd_seq;
_pd_seq = _s;
return *this;
}
inline Tasks_var& operator = (const Tasks_var& _s) {
if( _s._pd_seq ) {
if( !_pd_seq ) _pd_seq = new Tasks;
*_pd_seq = *_s._pd_seq;
} else if( _pd_seq ) {
delete _pd_seq;
_pd_seq = 0;
}
return *this;
}
inline _CORBA_ObjRef_Element< _objref_Task, Task_Helper> operator [] (_CORBA_ULong _s) {
return (*_pd_seq)[_s];
}
inline Tasks* operator -> () { return _pd_seq; }
#if defined(__GNUG__)
inline operator Tasks& () const { return *_pd_seq; }
#else
inline operator const Tasks& () const { return *_pd_seq; }
inline operator Tasks& () { return *_pd_seq; }
#endif
inline const Tasks& in() const { return *_pd_seq; }
inline Tasks& inout() { return *_pd_seq; }
inline Tasks*& out() {
if( _pd_seq ) { delete _pd_seq; _pd_seq = 0; }
return _pd_seq;
}
inline Tasks* _retn() { Tasks* tmp = _pd_seq; _pd_seq = 0; return tmp; }
friend class Tasks_out;
private:
Tasks* _pd_seq;
};
class Tasks_out {
public:
inline Tasks_out(Tasks*& _s) : _data(_s) { _data = 0; }
inline Tasks_out(Tasks_var& _s)
: _data(_s._pd_seq) { _s = (Tasks*) 0; }
inline Tasks_out(const Tasks_out& _s) : _data(_s._data) {}
inline Tasks_out& operator = (const Tasks_out& _s) {
_data = _s._data;
return *this;
}
inline Tasks_out& operator = (Tasks* _s) {
_data = _s;
return *this;
}
inline operator Tasks*&() { return _data; }
inline Tasks*& ptr() { return _data; }
inline Tasks* operator->() { return _data; }
inline _CORBA_ObjRef_Element< _objref_Task, Task_Helper> operator [] (_CORBA_ULong _i) {
return (*_data)[_i];
}
Tasks*& _data;
private:
Tasks_out();
Tasks_out& operator=(const Tasks_var&);
};
_CORBA_MODULE_END
_CORBA_MODULE POA_LIBSAMS
_CORBA_MODULE_BEG
class Task :
public virtual LIBSAMS::_impl_Task,
public virtual PortableServer::ServantBase
{
public:
virtual ~Task();
inline LIBSAMS::Task_ptr _this() {
return (LIBSAMS::Task_ptr) _do_this(LIBSAMS::Task::_PD_repoId);
}
};
_CORBA_MODULE_END
#undef _core_attr
#undef _dyn_attr
inline void operator >>=(LIBSAMS::Task::Status _e, cdrStream& s) {
::operator>>=((CORBA::ULong)_e, s);
}
inline void operator <<= (LIBSAMS::Task::Status& _e, cdrStream& s) {
CORBA::ULong _0RL_e;
::operator<<=(_0RL_e,s);
switch (_0RL_e) {
case LIBSAMS::Task::WAITING_S:
case LIBSAMS::Task::PROCESSING_S:
case LIBSAMS::Task::COMPLETED_S:
case LIBSAMS::Task::CANCELLED_S:
case LIBSAMS::Task::UNKNOWN_S:
_e = (LIBSAMS::Task::Status) _0RL_e;
break;
default:
OMNIORB_THROW(MARSHAL,_OMNI_NS(MARSHAL_InvalidEnumValue),
(CORBA::CompletionStatus)s.completion());
}
}
inline void operator >>=(LIBSAMS::Task::Type _e, cdrStream& s) {
::operator>>=((CORBA::ULong)_e, s);
}
inline void operator <<= (LIBSAMS::Task::Type& _e, cdrStream& s) {
CORBA::ULong _0RL_e;
::operator<<=(_0RL_e,s);
switch (_0RL_e) {
case LIBSAMS::Task::BACKUP_T:
case LIBSAMS::Task::RESTORE_T:
case LIBSAMS::Task::BULK_ADD_T:
case LIBSAMS::Task::BULK_DELETE_T:
_e = (LIBSAMS::Task::Type) _0RL_e;
break;
default:
OMNIORB_THROW(MARSHAL,_OMNI_NS(MARSHAL_InvalidEnumValue),
(CORBA::CompletionStatus)s.completion());
}
}
inline void operator >>=(LIBSAMS::Task::SelectType _e, cdrStream& s) {
::operator>>=((CORBA::ULong)_e, s);
}
inline void operator <<= (LIBSAMS::Task::SelectType& _e, cdrStream& s) {
CORBA::ULong _0RL_e;
::operator<<=(_0RL_e,s);
switch (_0RL_e) {
case LIBSAMS::Task::START_SELECT:
case LIBSAMS::Task::TYPE_SELECT:
case LIBSAMS::Task::STATUS_SELECT:
case LIBSAMS::Task::USER_SELECT:
_e = (LIBSAMS::Task::SelectType) _0RL_e;
break;
default:
OMNIORB_THROW(MARSHAL,_OMNI_NS(MARSHAL_InvalidEnumValue),
(CORBA::CompletionStatus)s.completion());
}
}
inline void
LIBSAMS::Task::_marshalObjRef(::LIBSAMS::Task_ptr obj, cdrStream& s) {
omniObjRef::_marshal(obj->_PR_getobj(),s);
}
#ifdef USE_core_stub_in_nt_dll_NOT_DEFINED_task
# undef USE_core_stub_in_nt_dll
# undef USE_core_stub_in_nt_dll_NOT_DEFINED_task
#endif
#ifdef USE_dyn_stub_in_nt_dll_NOT_DEFINED_task
# undef USE_dyn_stub_in_nt_dll
# undef USE_dyn_stub_in_nt_dll_NOT_DEFINED_task
#endif
#endif // __task_hh__
--------------020401000905080208000706--