libcos4-dev 4.1.6-2 / usr / include / COS / CosQueryCollection.hh

// This file is generated by omniidl (C++ backend)- omniORB_4_1. Do not edit.
#ifndef __CosQueryCollection_hh__
#define __CosQueryCollection_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_CosQueryCollection
#endif
#ifndef  USE_core_stub_in_nt_dll
# define USE_core_stub_in_nt_dll_NOT_DEFINED_CosQueryCollection
#endif
#ifndef  USE_dyn_stub_in_nt_dll
# define USE_dyn_stub_in_nt_dll_NOT_DEFINED_CosQueryCollection
#endif


#include "COS_sysdep.h"



#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 CosQueryCollection

_CORBA_MODULE_BEG

  class ElementInvalid : public ::CORBA::UserException {
  public:
    
    

    inline ElementInvalid() {
      pd_insertToAnyFn    = insertToAnyFn;
      pd_insertToAnyFnNCP = insertToAnyFnNCP;
    }
    ElementInvalid(const ElementInvalid&);
    
    ElementInvalid& operator=(const ElementInvalid&);
    virtual ~ElementInvalid();
    virtual void _raise() const;
    static ElementInvalid* _downcast(::CORBA::Exception*);
    static const ElementInvalid* _downcast(const ::CORBA::Exception*);
    static inline ElementInvalid* _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;
  };

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_ElementInvalid;

  class IteratorInvalid : public ::CORBA::UserException {
  public:
    
    

    inline IteratorInvalid() {
      pd_insertToAnyFn    = insertToAnyFn;
      pd_insertToAnyFnNCP = insertToAnyFnNCP;
    }
    IteratorInvalid(const IteratorInvalid&);
    
    IteratorInvalid& operator=(const IteratorInvalid&);
    virtual ~IteratorInvalid();
    virtual void _raise() const;
    static IteratorInvalid* _downcast(::CORBA::Exception*);
    static const IteratorInvalid* _downcast(const ::CORBA::Exception*);
    static inline IteratorInvalid* _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;
  };

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_IteratorInvalid;

  class PositionInvalid : public ::CORBA::UserException {
  public:
    
    

    inline PositionInvalid() {
      pd_insertToAnyFn    = insertToAnyFn;
      pd_insertToAnyFnNCP = insertToAnyFnNCP;
    }
    PositionInvalid(const PositionInvalid&);
    
    PositionInvalid& operator=(const PositionInvalid&);
    virtual ~PositionInvalid();
    virtual void _raise() const;
    static PositionInvalid* _downcast(::CORBA::Exception*);
    static const PositionInvalid* _downcast(const ::CORBA::Exception*);
    static inline PositionInvalid* _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;
  };

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_PositionInvalid;

  enum ValueType { TypeBoolean, TypeChar, TypeOctet, TypeShort, TypeUShort, TypeLong, TypeULong, TypeFloat, TypeDouble, TypeString, TypeObject, TypeAny, TypeSmallInt, TypeInteger, TypeReal, TypeDoublePrecision, TypeCharacter, TypeDecimal, TypeNumeric /*, __max_ValueType=0xffffffff */ };
  typedef ValueType& ValueType_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_ValueType;

  struct Decimal {
    typedef _CORBA_ConstrType_Variable_Var<Decimal> _var_type;

    
    ::CORBA::Long precision;

    ::CORBA::Long scale;

    typedef _CORBA_Unbounded_Sequence_Octet _value_seq;
    _value_seq value;

  

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

  typedef Decimal::_var_type Decimal_var;

  typedef _CORBA_ConstrType_Variable_OUT_arg< Decimal,Decimal_var > Decimal_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_Decimal;

  class Value {
  public:

    typedef _CORBA_ConstrType_Variable_Var<Value> _var_type;

    

    Value(): _pd__initialised(0) {
      
    }
    
    Value(const Value& _value) {
      _pd__initialised = _value._pd__initialised;
      switch(_value._pd__d) {
        case TypeBoolean: b(_value._pd_b); break;

        case TypeChar: c(_value._pd_c); break;

        case TypeOctet: o(_value._pd_o); break;

        case TypeShort: s(_value._pd_s); break;

        case TypeUShort: us(_value._pd_us); break;

        case TypeLong: l(_value._pd_l); break;

        case TypeULong: ul(_value._pd_ul); break;

        case TypeFloat: f(_value._pd_f); break;

        case TypeDouble: d(_value._pd_d); break;

        case TypeString: str(_value._pd_str); break;

        case TypeObject: obj(_value._pd_obj); break;

        case TypeAny: a(_value._pd_a); break;

        case TypeSmallInt: si(_value._pd_si); break;

        case TypeInteger: i(_value._pd_i); break;

        case TypeReal: r(_value._pd_r); break;

        case TypeDoublePrecision: dp(_value._pd_dp); break;

        case TypeCharacter: ch(_value._pd_ch); break;

        case TypeDecimal: dec(_value._pd_dec); break;

        case TypeNumeric: n(_value._pd_n); break;

          default: break;

      
      }
      _pd__d = _value._pd__d;
  
    }

    ~Value() {}

    Value& operator=(const Value& _value) {
      _pd__initialised = _value._pd__initialised;
      switch(_value._pd__d) {
        case TypeBoolean: b(_value._pd_b); break;

        case TypeChar: c(_value._pd_c); break;

        case TypeOctet: o(_value._pd_o); break;

        case TypeShort: s(_value._pd_s); break;

        case TypeUShort: us(_value._pd_us); break;

        case TypeLong: l(_value._pd_l); break;

        case TypeULong: ul(_value._pd_ul); break;

        case TypeFloat: f(_value._pd_f); break;

        case TypeDouble: d(_value._pd_d); break;

        case TypeString: str(_value._pd_str); break;

        case TypeObject: obj(_value._pd_obj); break;

        case TypeAny: a(_value._pd_a); break;

        case TypeSmallInt: si(_value._pd_si); break;

        case TypeInteger: i(_value._pd_i); break;

        case TypeReal: r(_value._pd_r); break;

        case TypeDoublePrecision: dp(_value._pd_dp); break;

        case TypeCharacter: ch(_value._pd_ch); break;

        case TypeDecimal: dec(_value._pd_dec); break;

        case TypeNumeric: n(_value._pd_n); break;

          default: break;

      
      }
      _pd__d = _value._pd__d;
  
      return *this;
    }

    ValueType _d() const { return _pd__d;}
    void _d(ValueType _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 TypeBoolean: goto fail;
        case TypeChar: goto fail;
        case TypeOctet: goto fail;
        case TypeShort: goto fail;
        case TypeUShort: goto fail;
        case TypeLong: goto fail;
        case TypeULong: goto fail;
        case TypeFloat: goto fail;
        case TypeDouble: goto fail;
        case TypeString: goto fail;
        case TypeObject: goto fail;
        case TypeAny: goto fail;
        case TypeSmallInt: goto fail;
        case TypeInteger: goto fail;
        case TypeReal: goto fail;
        case TypeDoublePrecision: goto fail;
        case TypeCharacter: goto fail;
        case TypeDecimal: goto fail;
        case TypeNumeric: goto fail;
        default: goto fail;

      };
      

      fail:
      OMNIORB_THROW(BAD_PARAM,_OMNI_NS(BAD_PARAM_InvalidUnionDiscValue),::CORBA::COMPLETED_NO);


  
    }

    

    ::CORBA::Boolean b () const { return _pd_b; }
    void b (::CORBA::Boolean  _value) {
      _pd__initialised = 1;
      _pd__d = TypeBoolean;
      _pd__default = 0;
      _pd_b = _value;
    }

    ::CORBA::Char c () const { return _pd_c; }
    void c (::CORBA::Char  _value) {
      _pd__initialised = 1;
      _pd__d = TypeChar;
      _pd__default = 0;
      _pd_c = _value;
    }

    ::CORBA::Octet o () const { return _pd_o; }
    void o (::CORBA::Octet  _value) {
      _pd__initialised = 1;
      _pd__d = TypeOctet;
      _pd__default = 0;
      _pd_o = _value;
    }

    ::CORBA::Short s () const { return _pd_s; }
    void s (::CORBA::Short  _value) {
      _pd__initialised = 1;
      _pd__d = TypeShort;
      _pd__default = 0;
      _pd_s = _value;
    }

    ::CORBA::UShort us () const { return _pd_us; }
    void us (::CORBA::UShort  _value) {
      _pd__initialised = 1;
      _pd__d = TypeUShort;
      _pd__default = 0;
      _pd_us = _value;
    }

    ::CORBA::Long l () const { return _pd_l; }
    void l (::CORBA::Long  _value) {
      _pd__initialised = 1;
      _pd__d = TypeLong;
      _pd__default = 0;
      _pd_l = _value;
    }

    ::CORBA::ULong ul () const { return _pd_ul; }
    void ul (::CORBA::ULong  _value) {
      _pd__initialised = 1;
      _pd__d = TypeULong;
      _pd__default = 0;
      _pd_ul = _value;
    }

    ::CORBA::Float f () const { return _pd_f; }
    void f (::CORBA::Float  _value) {
      _pd__initialised = 1;
      _pd__d = TypeFloat;
      _pd__default = 0;
      _pd_f = _value;
    }

    ::CORBA::Double d () const { return _pd_d; }
    void d (::CORBA::Double  _value) {
      _pd__initialised = 1;
      _pd__d = TypeDouble;
      _pd__default = 0;
      _pd_d = _value;
    }

    const char * str () const { return (const char*) _pd_str; }
    void str(char* _value) {
      _pd__initialised = 1;
      _pd__d = TypeString;
      _pd__default = 0;
      _pd_str = _value;
    }
    void str(const char*  _value) {
      _pd__initialised = 1;
      _pd__d = TypeString;
      _pd__default = 0;
      _pd_str = _value;
    }
    void str(const ::CORBA::String_var& _value) {
      _pd__initialised = 1;
      _pd__d = TypeString;
      _pd__default = 0;
      _pd_str = _value;
    }
    void str(const ::CORBA::String_member& _value) {
      _pd__initialised = 1;
      _pd__d = TypeString;
      _pd__default = 0;
      _pd_str = _value;
    }

    ::CORBA::Object_ptr obj () const { return _pd_obj._ptr; }
    void obj(::CORBA::Object_ptr _value) {
      _pd__initialised = 1;
      _pd__d = TypeObject;
      _pd__default = 0;
      ::CORBA::Object_Helper::duplicate(_value);
      _pd_obj = _value;
    }
    void obj(const ::CORBA::Object_Member& _value) {
      _pd__initialised = 1;
      _pd__d = TypeObject;
      _pd__default = 0;
      _pd_obj = _value;
    }
    void obj(const ::CORBA::Object_var&  _value) {
      _pd__initialised = 1;
      _pd__d = TypeObject;
      _pd__default = 0;
      _pd_obj = _value;
    }

    const ::CORBA::Any &a () const { return _pd_a; }
    ::CORBA::Any &a () { return _pd_a; }
    void a (const ::CORBA::Any& _value) {
      _pd__initialised = 1;
      _pd__d = TypeAny;
      _pd__default = 0;
      _pd_a = _value;
    }

    ::CORBA::Short si () const { return _pd_si; }
    void si (::CORBA::Short  _value) {
      _pd__initialised = 1;
      _pd__d = TypeSmallInt;
      _pd__default = 0;
      _pd_si = _value;
    }

    ::CORBA::Long i () const { return _pd_i; }
    void i (::CORBA::Long  _value) {
      _pd__initialised = 1;
      _pd__d = TypeInteger;
      _pd__default = 0;
      _pd_i = _value;
    }

    ::CORBA::Float r () const { return _pd_r; }
    void r (::CORBA::Float  _value) {
      _pd__initialised = 1;
      _pd__d = TypeReal;
      _pd__default = 0;
      _pd_r = _value;
    }

    ::CORBA::Double dp () const { return _pd_dp; }
    void dp (::CORBA::Double  _value) {
      _pd__initialised = 1;
      _pd__d = TypeDoublePrecision;
      _pd__default = 0;
      _pd_dp = _value;
    }

    const char * ch () const { return (const char*) _pd_ch; }
    void ch(char* _value) {
      _pd__initialised = 1;
      _pd__d = TypeCharacter;
      _pd__default = 0;
      _pd_ch = _value;
    }
    void ch(const char*  _value) {
      _pd__initialised = 1;
      _pd__d = TypeCharacter;
      _pd__default = 0;
      _pd_ch = _value;
    }
    void ch(const ::CORBA::String_var& _value) {
      _pd__initialised = 1;
      _pd__d = TypeCharacter;
      _pd__default = 0;
      _pd_ch = _value;
    }
    void ch(const ::CORBA::String_member& _value) {
      _pd__initialised = 1;
      _pd__d = TypeCharacter;
      _pd__default = 0;
      _pd_ch = _value;
    }

    const Decimal &dec () const { return _pd_dec; }
    Decimal &dec () { return _pd_dec; }
    void dec (const Decimal& _value) {
      _pd__initialised = 1;
      _pd__d = TypeDecimal;
      _pd__default = 0;
      _pd_dec = _value;
    }

    const Decimal &n () const { return _pd_n; }
    Decimal &n () { return _pd_n; }
    void n (const Decimal& _value) {
      _pd__initialised = 1;
      _pd__d = TypeNumeric;
      _pd__default = 0;
      _pd_n = _value;
    }

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

  private:
    ValueType _pd__d;
    _CORBA_Boolean _pd__default;
    _CORBA_Boolean _pd__initialised;

    union {
      ::CORBA::Boolean _pd_b;

      ::CORBA::Char _pd_c;

      ::CORBA::Octet _pd_o;

      ::CORBA::Short _pd_s;

      ::CORBA::UShort _pd_us;

      ::CORBA::Long _pd_l;

      ::CORBA::ULong _pd_ul;


#ifndef USING_PROXY_FLOAT
        ::CORBA::Float _pd_f;
#endif


#ifndef USING_PROXY_FLOAT
        ::CORBA::Double _pd_d;
#endif

      ::CORBA::Short _pd_si;

      ::CORBA::Long _pd_i;


#ifndef USING_PROXY_FLOAT
        ::CORBA::Float _pd_r;
#endif


#ifndef USING_PROXY_FLOAT
        ::CORBA::Double _pd_dp;
#endif


    };

  
    
#ifdef USING_PROXY_FLOAT
      ::CORBA::Float _pd_f;
#endif


#ifdef USING_PROXY_FLOAT
      ::CORBA::Double _pd_d;
#endif

    ::CORBA::String_member _pd_str;

    ::CORBA::Object_Member _pd_obj;

    ::CORBA::Any _pd_a;


#ifdef USING_PROXY_FLOAT
      ::CORBA::Float _pd_r;
#endif


#ifdef USING_PROXY_FLOAT
      ::CORBA::Double _pd_dp;
#endif

    ::CORBA::String_member _pd_ch;

    Decimal _pd_dec;

    Decimal _pd_n;

  
  };

  typedef Value::_var_type Value_var;

  typedef _CORBA_ConstrType_Variable_OUT_arg< Value,Value_var > Value_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_Value;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_Null;

  typedef ::CORBA::Boolean Null;
  typedef ::CORBA::Boolean_out Null_out;

  class FieldValue {
  public:

    typedef _CORBA_ConstrType_Variable_Var<FieldValue> _var_type;

    

    FieldValue(): _pd__initialised(0) {
      _default();

  
    }
    
    FieldValue(const FieldValue& _value) {
      _pd__initialised = _value._pd__initialised;
      if ((_pd__default = _value._pd__default)) {
        
      }
      else {
        switch(_value._pd__d) {
          case 0: v(_value._pd_v); break;

            default: break;

      
        }
      }
      _pd__d = _value._pd__d;

  
    }

    ~FieldValue() {}

    FieldValue& operator=(const FieldValue& _value) {
      _pd__initialised = _value._pd__initialised;
      if ((_pd__default = _value._pd__default)) {
        
      }
      else {
        switch(_value._pd__d) {
          case 0: v(_value._pd_v); break;

            default: break;

      
        }
      }
      _pd__d = _value._pd__d;

  
      return *this;
    }

    ::CORBA::Boolean _d() const { return _pd__d;}
    void _d(::CORBA::Boolean _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 0: goto fail;
        default:
        switch (_value){
          case 0: goto fail;
          default: _pd__d = _value; return;
        }

      };
      

      fail:
      OMNIORB_THROW(BAD_PARAM,_OMNI_NS(BAD_PARAM_InvalidUnionDiscValue),::CORBA::COMPLETED_NO);


  
    }

    void _default()
    {
      _pd__initialised = 1;
      _pd__d = 1;
      _pd__default = 1;
    }

  

    const Value &v () const { return _pd_v; }
    Value &v () { return _pd_v; }
    void v (const Value& _value) {
      _pd__initialised = 1;
      _pd__d = 0;
      _pd__default = 0;
      _pd_v = _value;
    }

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

  private:
    ::CORBA::Boolean _pd__d;
    _CORBA_Boolean _pd__default;
    _CORBA_Boolean _pd__initialised;

    
    Value _pd_v;

  
  };

  typedef FieldValue::_var_type FieldValue_var;

  typedef _CORBA_ConstrType_Variable_OUT_arg< FieldValue,FieldValue_var > FieldValue_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_FieldValue;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_Record;

  class Record_var;

  class Record : public _CORBA_Unbounded_Sequence< FieldValue >  {
  public:
    typedef Record_var _var_type;
    inline Record() {}
    inline Record(const Record& _s)
      : _CORBA_Unbounded_Sequence< FieldValue > (_s) {}

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

  

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

  class Record_out;

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

  

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

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

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

  

    Record*& _data;

  private:
    Record_out();
    Record_out& operator=(const Record_var&);
  };

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_Istring;

  typedef char* Istring;
  typedef ::CORBA::String_var Istring_var;
  typedef ::CORBA::String_out Istring_out;

  struct NVPair {
    typedef _CORBA_ConstrType_Variable_Var<NVPair> _var_type;

    
    ::CORBA::String_member name;

    ::CORBA::Any value;

  

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

  typedef NVPair::_var_type NVPair_var;

  typedef _CORBA_ConstrType_Variable_OUT_arg< NVPair,NVPair_var > NVPair_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_NVPair;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_ParameterList;

  class ParameterList_var;

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

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

  

    inline ParameterList& operator = (const ParameterList& _s) {
      _CORBA_Unbounded_Sequence< NVPair > ::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 NVPair& 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 NVPair& operator [] (_CORBA_ULong _i) {
      return (*_data)[_i];
    }

  

    ParameterList*& _data;

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

#ifndef __CosQueryCollection_mCollection__
#define __CosQueryCollection_mCollection__

  class Collection;
  class _objref_Collection;
  class _impl_Collection;
  
  typedef _objref_Collection* Collection_ptr;
  typedef Collection_ptr CollectionRef;

  class Collection_Helper {
  public:
    typedef Collection_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_Collection, Collection_Helper> Collection_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_Collection,Collection_Helper > Collection_out;

#endif

#ifndef __CosQueryCollection_mIterator__
#define __CosQueryCollection_mIterator__

  class Iterator;
  class _objref_Iterator;
  class _impl_Iterator;
  
  typedef _objref_Iterator* Iterator_ptr;
  typedef Iterator_ptr IteratorRef;

  class Iterator_Helper {
  public:
    typedef Iterator_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_Iterator, Iterator_Helper> Iterator_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_Iterator,Iterator_Helper > Iterator_out;

#endif

#ifndef __CosQueryCollection_mCollectionFactory__
#define __CosQueryCollection_mCollectionFactory__

  class CollectionFactory;
  class _objref_CollectionFactory;
  class _impl_CollectionFactory;
  
  typedef _objref_CollectionFactory* CollectionFactory_ptr;
  typedef CollectionFactory_ptr CollectionFactoryRef;

  class CollectionFactory_Helper {
  public:
    typedef CollectionFactory_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_CollectionFactory, CollectionFactory_Helper> CollectionFactory_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_CollectionFactory,CollectionFactory_Helper > CollectionFactory_out;

#endif

  // interface CollectionFactory
  class CollectionFactory {
  public:
    // Declarations for this interface type.
    typedef CollectionFactory_ptr _ptr_type;
    typedef CollectionFactory_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_CollectionFactory :
    public virtual ::CORBA::Object,
    public virtual omniObjRef
  {
  public:
    Collection_ptr create(const ::CosQueryCollection::ParameterList& params);

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

  protected:
    virtual ~_objref_CollectionFactory();

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

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

    friend class CollectionFactory;
  };

  class _pof_CollectionFactory : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_CollectionFactory() : _OMNI_NS(proxyObjectFactory)(CollectionFactory::_PD_repoId) {}
    virtual ~_pof_CollectionFactory();

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

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

    virtual Collection_ptr create(const ::CosQueryCollection::ParameterList& params) = 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_CollectionFactory;

#ifndef __CosQueryCollection_mCollection__
#define __CosQueryCollection_mCollection__

  class Collection;
  class _objref_Collection;
  class _impl_Collection;
  
  typedef _objref_Collection* Collection_ptr;
  typedef Collection_ptr CollectionRef;

  class Collection_Helper {
  public:
    typedef Collection_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_Collection, Collection_Helper> Collection_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_Collection,Collection_Helper > Collection_out;

#endif

  // interface Collection
  class Collection {
  public:
    // Declarations for this interface type.
    typedef Collection_ptr _ptr_type;
    typedef Collection_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_Collection :
    public virtual ::CORBA::Object,
    public virtual omniObjRef
  {
  public:
    void add_element(const ::CORBA::Any& element);
    void add_all_elements(::CosQueryCollection::Collection_ptr elements);
    void insert_element_at(const ::CORBA::Any& element, ::CosQueryCollection::Iterator_ptr where);
    void replace_element_at(const ::CORBA::Any& element, ::CosQueryCollection::Iterator_ptr where);
    void remove_element_at(::CosQueryCollection::Iterator_ptr where);
    void remove_all_elements();
    ::CORBA::Any* retrieve_element_at(::CosQueryCollection::Iterator_ptr where);
    Iterator_ptr create_iterator();
    ::CORBA::Long cardinality();

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

  protected:
    virtual ~_objref_Collection();

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

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

    friend class Collection;
  };

  class _pof_Collection : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_Collection() : _OMNI_NS(proxyObjectFactory)(Collection::_PD_repoId) {}
    virtual ~_pof_Collection();

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

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

    virtual void add_element(const ::CORBA::Any& element) = 0;
    virtual void add_all_elements(::CosQueryCollection::Collection_ptr elements) = 0;
    virtual void insert_element_at(const ::CORBA::Any& element, ::CosQueryCollection::Iterator_ptr where) = 0;
    virtual void replace_element_at(const ::CORBA::Any& element, ::CosQueryCollection::Iterator_ptr where) = 0;
    virtual void remove_element_at(::CosQueryCollection::Iterator_ptr where) = 0;
    virtual void remove_all_elements() = 0;
    virtual ::CORBA::Any* retrieve_element_at(::CosQueryCollection::Iterator_ptr where) = 0;
    virtual Iterator_ptr create_iterator() = 0;
    virtual ::CORBA::Long cardinality() = 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_Collection;

#ifndef __CosQueryCollection_mIterator__
#define __CosQueryCollection_mIterator__

  class Iterator;
  class _objref_Iterator;
  class _impl_Iterator;
  
  typedef _objref_Iterator* Iterator_ptr;
  typedef Iterator_ptr IteratorRef;

  class Iterator_Helper {
  public:
    typedef Iterator_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_Iterator, Iterator_Helper> Iterator_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_Iterator,Iterator_Helper > Iterator_out;

#endif

  // interface Iterator
  class Iterator {
  public:
    // Declarations for this interface type.
    typedef Iterator_ptr _ptr_type;
    typedef Iterator_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_Iterator :
    public virtual ::CORBA::Object,
    public virtual omniObjRef
  {
  public:
    ::CORBA::Any* next();
    void reset();
    ::CORBA::Boolean more();

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

  protected:
    virtual ~_objref_Iterator();

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

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

    friend class Iterator;
  };

  class _pof_Iterator : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_Iterator() : _OMNI_NS(proxyObjectFactory)(Iterator::_PD_repoId) {}
    virtual ~_pof_Iterator();

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

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

    virtual ::CORBA::Any* next() = 0;
    virtual void reset() = 0;
    virtual ::CORBA::Boolean more() = 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_Iterator;

_CORBA_MODULE_END



_CORBA_MODULE POA_CosQueryCollection
_CORBA_MODULE_BEG

  class CollectionFactory :
    public virtual CosQueryCollection::_impl_CollectionFactory,
    public virtual ::PortableServer::ServantBase
  {
  public:
    virtual ~CollectionFactory();

    inline ::CosQueryCollection::CollectionFactory_ptr _this() {
      return (::CosQueryCollection::CollectionFactory_ptr) _do_this(::CosQueryCollection::CollectionFactory::_PD_repoId);
    }
  };

  class Collection :
    public virtual CosQueryCollection::_impl_Collection,
    public virtual ::PortableServer::ServantBase
  {
  public:
    virtual ~Collection();

    inline ::CosQueryCollection::Collection_ptr _this() {
      return (::CosQueryCollection::Collection_ptr) _do_this(::CosQueryCollection::Collection::_PD_repoId);
    }
  };

  class Iterator :
    public virtual CosQueryCollection::_impl_Iterator,
    public virtual ::PortableServer::ServantBase
  {
  public:
    virtual ~Iterator();

    inline ::CosQueryCollection::Iterator_ptr _this() {
      return (::CosQueryCollection::Iterator_ptr) _do_this(::CosQueryCollection::Iterator::_PD_repoId);
    }
  };

_CORBA_MODULE_END



_CORBA_MODULE OBV_CosQueryCollection
_CORBA_MODULE_BEG

_CORBA_MODULE_END





#undef _core_attr
#undef _dyn_attr

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

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

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

inline void operator >>=(CosQueryCollection::ValueType _e, cdrStream& s) {
  ::operator>>=((::CORBA::ULong)_e, s);
}

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

void operator<<=(::CORBA::Any& _a, CosQueryCollection::ValueType _s);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, CosQueryCollection::ValueType& _s);

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

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

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

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

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

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

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

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

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



inline void
CosQueryCollection::CollectionFactory::_marshalObjRef(::CosQueryCollection::CollectionFactory_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
CosQueryCollection::Collection::_marshalObjRef(::CosQueryCollection::Collection_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
CosQueryCollection::Iterator::_marshalObjRef(::CosQueryCollection::Iterator_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}




#ifdef   USE_stub_in_nt_dll_NOT_DEFINED_CosQueryCollection
# undef  USE_stub_in_nt_dll
# undef  USE_stub_in_nt_dll_NOT_DEFINED_CosQueryCollection
#endif
#ifdef   USE_core_stub_in_nt_dll_NOT_DEFINED_CosQueryCollection
# undef  USE_core_stub_in_nt_dll
# undef  USE_core_stub_in_nt_dll_NOT_DEFINED_CosQueryCollection
#endif
#ifdef   USE_dyn_stub_in_nt_dll_NOT_DEFINED_CosQueryCollection
# undef  USE_dyn_stub_in_nt_dll
# undef  USE_dyn_stub_in_nt_dll_NOT_DEFINED_CosQueryCollection
#endif

#endif  // __CosQueryCollection_hh__