1 files changed, 294 insertions, 294 deletions

diff --git a/TAO/IIOP/test/Orbix/base_server/cubitC.h b/TAO/IIOP/test/Orbix/base_server/cubitC.h
index 584efa67c8d..5c020bd0c4b 100644
--- a/TAO/IIOP/test/Orbix/base_server/cubitC.h
+++ b/TAO/IIOP/test/Orbix/base_server/cubitC.h
@@ -28,316 +28,316 @@ typedef Cubit_ptr CubitRef;
 class Cubit_var
 {
     public:
-	Cubit_var();
-	Cubit_var(Cubit_ptr);
-	Cubit_var(const Cubit_var&);
-	~Cubit_var();
-	Cubit_var& operator=(Cubit_ptr);
-	operator Cubit_ptr() const { return _ptr; }
+        Cubit_var();
+        Cubit_var(Cubit_ptr);
+        Cubit_var(const Cubit_var&);
+        ~Cubit_var();
+        Cubit_var& operator=(Cubit_ptr);
+        operator Cubit_ptr() const { return _ptr; }
 #if defined(_HPCC_BUG)
-	operator Cubit *&() { return _ptr; }
+        operator Cubit *&() { return _ptr; }
 #else
-	operator Cubit_ptr&() { return _ptr; }
+        operator Cubit_ptr&() { return _ptr; }
 #endif
-	Cubit_ptr operator->() const { return _ptr;}
-	friend NCistream& operator>>(NCistream&, Cubit_var&);
-	friend NCostream& operator<<(NCostream&, const Cubit_var&);
-	friend istream& operator>>(istream&, Cubit_var&);
-	friend ostream& operator<<(ostream&, const Cubit_var&);
+        Cubit_ptr operator->() const { return _ptr;}
+        friend NCistream& operator>>(NCistream&, Cubit_var&);
+        friend NCostream& operator<<(NCostream&, const Cubit_var&);
+        friend istream& operator>>(istream&, Cubit_var&);
+        friend ostream& operator<<(ostream&, const Cubit_var&);
     private:
-	Cubit_ptr	_ptr;
-	void operator=(const Cubit_var&) {}
+        Cubit_ptr       _ptr;
+        void operator=(const Cubit_var&) {}
 };
 #endif
 class Cubit: public virtual CORBA_Object
 {
     private:
-	static const CORBA::TypeInfo _class_info;
-	Cubit(const Cubit&) {}
-	void operator=(const Cubit&){}
+        static const CORBA::TypeInfo _class_info;
+        Cubit(const Cubit&) {}
+        void operator=(const Cubit&){}
     public:
-	static const CORBA::TypeInfo *_desc();
-	virtual const CORBA::TypeInfo *_type_info() const;
-	virtual void *_safe_narrow(const CORBA::TypeInfo& ) const;
-	static CORBA::Object *_factory();
+        static const CORBA::TypeInfo *_desc();
+        virtual const CORBA::TypeInfo *_type_info() const;
+        virtual void *_safe_narrow(const CORBA::TypeInfo& ) const;
+        static CORBA::Object *_factory();
     protected:
-	Cubit(const char *obj_name = NULL) :CORBA_Object(obj_name, 1) {}
-	Cubit(NCistream& strm) :CORBA_Object(strm) {}
-	virtual ~Cubit() {}
+        Cubit(const char *obj_name = NULL) :CORBA_Object(obj_name, 1) {}
+        Cubit(NCistream& strm) :CORBA_Object(strm) {}
+        virtual ~Cubit() {}
     public:
-	static Cubit_ptr _duplicate(Cubit_ptr obj) {
-		if (obj ) obj->_ref();
-		return obj;
-	}
-	static Cubit_ptr _nil() { return (Cubit_ptr)NULL;}
-	static Cubit_ptr _narrow(CORBA::Object *obj);
-	static Cubit_ptr _clone(Cubit_ptr obj) {
-		CORBA::Object_var obj_var(__clone(obj));
+        static Cubit_ptr _duplicate(Cubit_ptr obj) {
+                if (obj ) obj->_ref();
+                return obj;
+        }
+        static Cubit_ptr _nil() { return (Cubit_ptr)NULL;}
+        static Cubit_ptr _narrow(CORBA::Object *obj);
+        static Cubit_ptr _clone(Cubit_ptr obj) {
+                CORBA::Object_var obj_var(__clone(obj));
 
 #if defined(_HPCC_BUG)
-		return _narrow(obj_var.operator CORBA::Object_ptr());
+                return _narrow(obj_var.operator CORBA::Object_ptr());
 #else
-		return _narrow(obj_var);
+                return _narrow(obj_var);
 #endif
-	}
-	static Cubit_ptr _bind(const char *object_name = NULL,
-		const char *host_name = NULL,
-		const CORBA::BindOptions* opt = NULL); 
-
-	virtual CORBA::Octet cube_octet(CORBA::Octet o);
-	
-	virtual CORBA::Short cube_short(CORBA::Short s);
-	
-	virtual CORBA::Long cube_long(CORBA::Long l);
-	
-	struct Many {
-		CORBA::Octet	o;
-		CORBA::Long	l;
-		CORBA::Short	s;
-	};
-	friend NCostream& operator<<(NCostream&, const Many& );
-	friend NCistream& operator>>(NCistream&, Many& );
-	
-	friend ostream& operator<<(ostream&, const Many& );
-	inline friend istream& operator>>(istream& _strm, Many& _obj) {
-		NCistream _istrm(_strm);
-		_istrm >> _obj;
-		return _strm;
-	}
-	
-	
-	typedef Many *Many_ptr;
-	class Many_var
-	{
-	    public:
-		Many_var() { _ptr = (Many*)NULL;}
-		Many_var(Many *ptr) {
-			_ptr = ptr;
-		}
-		Many_var(const Many_var& var) {
-			if (var._ptr)
-				_ptr = new Many(*var._ptr);
-			else
-				_ptr = (Many *)NULL;
-		}
-		~Many_var() {
-			if (_ptr != (Many *)NULL) delete _ptr;
-		}
-		Many_var& operator=(Many *ptr) {
-			if (_ptr != (Many *)NULL) delete _ptr;
-			_ptr = ptr;
-			return *this;
-		}
-		Many_var& operator=(const Many_var& var) {
-			if (_ptr != (Many *)NULL) delete _ptr;
-			if (var._ptr)
-				_ptr = new Many(*var._ptr);
-			else
-				_ptr = (Many *)NULL;
-			return *this;
-		}
-		Many *operator->() { return _ptr; }
-		operator Many () const { return *_ptr; }
-		operator Many& () { return *_ptr; }
-		inline friend NCostream& operator<<(NCostream& strm,
-				const Many_var& var) {
-			if (var._ptr == (Many *)NULL) {
-				throw CORBA::BAD_PARAM();
-			}
-			else
-				strm << *var._ptr;
-			return strm;
-		}
-		inline friend NCistream& operator>>(NCistream& strm,
-				Many_var& var) {
-			if ( ! var._ptr)
-				var._ptr = new Many;
-			strm >> *var._ptr;
-			return strm;
-		}
-	    private:
-		Many *_ptr;
-	};
-	
-	
-	virtual Cubit::Many cube_struct(const Cubit::Many& values);
-	
-	enum discrim {
-		e_0th,
-		e_1st,
-		e_2nd,
-		e_3rd,
-		e_4th,
-		e_5th
-	};
-	inline friend NCostream& operator<<(NCostream& _strm, discrim _enum_type) {
-		_strm << (CORBA::ULong)_enum_type;
-		return _strm;
-	}
-	inline friend NCistream& operator>>(NCistream& _strm, discrim& _enum_type) {
-		CORBA::ULong _temp;
-		_strm >> _temp;
-		if (_temp >= 6)
-			throw CORBA::BAD_PARAM();
-		_enum_type = discrim(_temp);
-		return _strm;
-	}
-	inline friend ostream& operator<<(ostream& _strm, discrim _enum_type) {
-		if( &_strm == &cout || &_strm == &cerr || &_strm == &clog) {
-			_strm << "discrim:";
-			switch(_enum_type) {
-				case e_0th:
-					_strm << "e_0th" << endl;
-					break;
-				case e_1st:
-					_strm << "e_1st" << endl;
-					break;
-				case e_2nd:
-					_strm << "e_2nd" << endl;
-					break;
-				case e_3rd:
-					_strm << "e_3rd" << endl;
-					break;
-				case e_4th:
-					_strm << "e_4th" << endl;
-					break;
-				case e_5th:
-					_strm << "e_5th" << endl;
-					break;
-			}
-		}
-		else 
-			_strm << (CORBA::ULong)_enum_type;
-		return _strm;
-	}
-	inline friend istream& operator>>(istream& _strm, discrim& _enum_type) {
-		CORBA::ULong _temp;
-		_strm >> _temp;
-		_enum_type = discrim(_temp);
-		return _strm;
-	}
-	
-	
-	class oneof
-	{
-	    public:
-	    private:
-		discrim	_disc;
-		CORBA::Octet	__o;
-		CORBA::Short	__s;
-		CORBA::Long	__l;
-		Cubit::Many	__cm;
-	    public:
-		oneof() : _disc(discrim(0)) {}
-		~oneof() {}
-		oneof(const oneof& obj);
-		oneof& operator=(const oneof& obj);
-	
-		void _d(discrim val) { _disc = val; }
-		discrim _d() const { return _disc; }
-	
-		void o(CORBA::Octet val) {
-			__o = val;
-			_disc = Cubit::e_0th;
-		}
-		CORBA::Octet o() const { return __o; }
-	
-		void s(CORBA::Short val) {
-			__s = val;
-			_disc = Cubit::e_1st;
-		}
-		CORBA::Short s() const { return __s; }
-	
-		void l(CORBA::Long val) {
-			__l = val;
-			_disc = Cubit::e_2nd;
-		}
-		CORBA::Long l() const { return __l; }
-	
-		void cm(const Cubit::Many& val) {
-			__cm = val;
-			_disc = Cubit::e_3rd;
-		}
-		const Cubit::Many& cm() const { return __cm; }
-		Cubit::Many& cm() { return __cm; }
-	
-		friend NCostream& operator<<(NCostream&, const oneof& );
-		friend NCistream& operator>>(NCistream&, oneof& );
-		friend ostream& operator<<(ostream&, const oneof&);
-		inline friend istream& operator>>(istream& strm, oneof& obj) {
-			NCistream istrm(strm);
-			strm >> obj;
-			return strm;
-		}
-	};
-	
-	typedef oneof *oneof_ptr;
-	class oneof_var
-	{
-	    public:
-		oneof_var() { _ptr = (oneof*)NULL;}
-		oneof_var(oneof *ptr) {
-			_ptr = ptr;
-		}
-		oneof_var(const oneof_var& var) {
-			_ptr = new oneof(*var._ptr);
-		}
-		~oneof_var() {
-			if (_ptr != (oneof *)NULL) delete _ptr;
-		}
-		oneof_var& operator=(oneof *ptr) {
-			if (_ptr != (oneof *)NULL) delete _ptr;
-			_ptr = ptr;
-			return *this;
-		}
-		oneof_var& operator=(const oneof_var& var) {
-			if (_ptr != (oneof *)NULL) delete _ptr;
-			_ptr = new oneof(*var._ptr);
-			return *this;
-		}
-		oneof *operator->() { return _ptr; }
-		operator oneof () const { return *_ptr; }
-		operator oneof& () { return *_ptr; }
-		inline friend NCostream& operator<<(NCostream& strm,
-				const oneof_var& var) {
-			if (var._ptr == (oneof *)NULL) {
-				throw CORBA::BAD_PARAM();
-			}
-			else
-				strm << *var._ptr;
-			return strm;
-		}
-		inline friend NCistream& operator>>(NCistream& strm,
-				oneof_var& var) {
-			if ( ! var._ptr)
-				var._ptr = new oneof;
-			strm >> *var._ptr;
-			return strm;
-		}
-	    private:
-		oneof *_ptr;
-	};
-	
-	
-	virtual Cubit::oneof cube_union(const Cubit::oneof& values);
-	
-	virtual void please_exit();
-	
-	inline friend NCistream& operator>>(NCistream& strm, Cubit_ptr& obj) {
-		CORBA::Object_var _obj(obj);
-		_obj = CORBA::Object::_read(strm, Cubit::_desc());
-		obj = Cubit::_narrow(_obj);
-		return strm;
-	}
-	inline friend ostream& operator<<(ostream& strm, const Cubit_ptr obj) {
-		strm << (CORBA::Object_ptr)obj;
-		return strm;
-	}
-	inline friend istream& operator>>(istream& strm, Cubit_ptr& obj) {
-		NCistream istrm(strm);
-		istrm >> obj;
-		return strm;
-	}
+        }
+        static Cubit_ptr _bind(const char *object_name = NULL,
+                const char *host_name = NULL,
+                const CORBA::BindOptions* opt = NULL);
+
+        virtual CORBA::Octet cube_octet(CORBA::Octet o);
+
+        virtual CORBA::Short cube_short(CORBA::Short s);
+
+        virtual CORBA::Long cube_long(CORBA::Long l);
+
+        struct Many {
+                CORBA::Octet    o;
+                CORBA::Long     l;
+                CORBA::Short    s;
+        };
+        friend NCostream& operator<<(NCostream&, const Many& );
+        friend NCistream& operator>>(NCistream&, Many& );
+
+        friend ostream& operator<<(ostream&, const Many& );
+        inline friend istream& operator>>(istream& _strm, Many& _obj) {
+                NCistream _istrm(_strm);
+                _istrm >> _obj;
+                return _strm;
+        }
+
+
+        typedef Many *Many_ptr;
+        class Many_var
+        {
+            public:
+                Many_var() { _ptr = (Many*)NULL;}
+                Many_var(Many *ptr) {
+                        _ptr = ptr;
+                }
+                Many_var(const Many_var& var) {
+                        if (var._ptr)
+                                _ptr = new Many(*var._ptr);
+                        else
+                                _ptr = (Many *)NULL;
+                }
+                ~Many_var() {
+                        if (_ptr != (Many *)NULL) delete _ptr;
+                }
+                Many_var& operator=(Many *ptr) {
+                        if (_ptr != (Many *)NULL) delete _ptr;
+                        _ptr = ptr;
+                        return *this;
+                }
+                Many_var& operator=(const Many_var& var) {
+                        if (_ptr != (Many *)NULL) delete _ptr;
+                        if (var._ptr)
+                                _ptr = new Many(*var._ptr);
+                        else
+                                _ptr = (Many *)NULL;
+                        return *this;
+                }
+                Many *operator->() { return _ptr; }
+                operator Many () const { return *_ptr; }
+                operator Many& () { return *_ptr; }
+                inline friend NCostream& operator<<(NCostream& strm,
+                                const Many_var& var) {
+                        if (var._ptr == (Many *)NULL) {
+                                throw CORBA::BAD_PARAM();
+                        }
+                        else
+                                strm << *var._ptr;
+                        return strm;
+                }
+                inline friend NCistream& operator>>(NCistream& strm,
+                                Many_var& var) {
+                        if ( ! var._ptr)
+                                var._ptr = new Many;
+                        strm >> *var._ptr;
+                        return strm;
+                }
+            private:
+                Many *_ptr;
+        };
+
+
+        virtual Cubit::Many cube_struct(const Cubit::Many& values);
+
+        enum discrim {
+                e_0th,
+                e_1st,
+                e_2nd,
+                e_3rd,
+                e_4th,
+                e_5th
+        };
+        inline friend NCostream& operator<<(NCostream& _strm, discrim _enum_type) {
+                _strm << (CORBA::ULong)_enum_type;
+                return _strm;
+        }
+        inline friend NCistream& operator>>(NCistream& _strm, discrim& _enum_type) {
+                CORBA::ULong _temp;
+                _strm >> _temp;
+                if (_temp >= 6)
+                        throw CORBA::BAD_PARAM();
+                _enum_type = discrim(_temp);
+                return _strm;
+        }
+        inline friend ostream& operator<<(ostream& _strm, discrim _enum_type) {
+                if( &_strm == &cout || &_strm == &cerr || &_strm == &clog) {
+                        _strm << "discrim:";
+                        switch(_enum_type) {
+                                case e_0th:
+                                        _strm << "e_0th" << endl;
+                                        break;
+                                case e_1st:
+                                        _strm << "e_1st" << endl;
+                                        break;
+                                case e_2nd:
+                                        _strm << "e_2nd" << endl;
+                                        break;
+                                case e_3rd:
+                                        _strm << "e_3rd" << endl;
+                                        break;
+                                case e_4th:
+                                        _strm << "e_4th" << endl;
+                                        break;
+                                case e_5th:
+                                        _strm << "e_5th" << endl;
+                                        break;
+                        }
+                }
+                else
+                        _strm << (CORBA::ULong)_enum_type;
+                return _strm;
+        }
+        inline friend istream& operator>>(istream& _strm, discrim& _enum_type) {
+                CORBA::ULong _temp;
+                _strm >> _temp;
+                _enum_type = discrim(_temp);
+                return _strm;
+        }
+
+
+        class oneof
+        {
+            public:
+            private:
+                discrim _disc;
+                CORBA::Octet    __o;
+                CORBA::Short    __s;
+                CORBA::Long     __l;
+                Cubit::Many     __cm;
+            public:
+                oneof() : _disc(discrim(0)) {}
+                ~oneof() {}
+                oneof(const oneof& obj);
+                oneof& operator=(const oneof& obj);
+
+                void _d(discrim val) { _disc = val; }
+                discrim _d() const { return _disc; }
+
+                void o(CORBA::Octet val) {
+                        __o = val;
+                        _disc = Cubit::e_0th;
+                }
+                CORBA::Octet o() const { return __o; }
+
+                void s(CORBA::Short val) {
+                        __s = val;
+                        _disc = Cubit::e_1st;
+                }
+                CORBA::Short s() const { return __s; }
+
+                void l(CORBA::Long val) {
+                        __l = val;
+                        _disc = Cubit::e_2nd;
+                }
+                CORBA::Long l() const { return __l; }
+
+                void cm(const Cubit::Many& val) {
+                        __cm = val;
+                        _disc = Cubit::e_3rd;
+                }
+                const Cubit::Many& cm() const { return __cm; }
+                Cubit::Many& cm() { return __cm; }
+
+                friend NCostream& operator<<(NCostream&, const oneof& );
+                friend NCistream& operator>>(NCistream&, oneof& );
+                friend ostream& operator<<(ostream&, const oneof&);
+                inline friend istream& operator>>(istream& strm, oneof& obj) {
+                        NCistream istrm(strm);
+                        strm >> obj;
+                        return strm;
+                }
+        };
+
+        typedef oneof *oneof_ptr;
+        class oneof_var
+        {
+            public:
+                oneof_var() { _ptr = (oneof*)NULL;}
+                oneof_var(oneof *ptr) {
+                        _ptr = ptr;
+                }
+                oneof_var(const oneof_var& var) {
+                        _ptr = new oneof(*var._ptr);
+                }
+                ~oneof_var() {
+                        if (_ptr != (oneof *)NULL) delete _ptr;
+                }
+                oneof_var& operator=(oneof *ptr) {
+                        if (_ptr != (oneof *)NULL) delete _ptr;
+                        _ptr = ptr;
+                        return *this;
+                }
+                oneof_var& operator=(const oneof_var& var) {
+                        if (_ptr != (oneof *)NULL) delete _ptr;
+                        _ptr = new oneof(*var._ptr);
+                        return *this;
+                }
+                oneof *operator->() { return _ptr; }
+                operator oneof () const { return *_ptr; }
+                operator oneof& () { return *_ptr; }
+                inline friend NCostream& operator<<(NCostream& strm,
+                                const oneof_var& var) {
+                        if (var._ptr == (oneof *)NULL) {
+                                throw CORBA::BAD_PARAM();
+                        }
+                        else
+                                strm << *var._ptr;
+                        return strm;
+                }
+                inline friend NCistream& operator>>(NCistream& strm,
+                                oneof_var& var) {
+                        if ( ! var._ptr)
+                                var._ptr = new oneof;
+                        strm >> *var._ptr;
+                        return strm;
+                }
+            private:
+                oneof *_ptr;
+        };
+
+
+        virtual Cubit::oneof cube_union(const Cubit::oneof& values);
+
+        virtual void please_exit();
+
+        inline friend NCistream& operator>>(NCistream& strm, Cubit_ptr& obj) {
+                CORBA::Object_var _obj(obj);
+                _obj = CORBA::Object::_read(strm, Cubit::_desc());
+                obj = Cubit::_narrow(_obj);
+                return strm;
+        }
+        inline friend ostream& operator<<(ostream& strm, const Cubit_ptr obj) {
+                strm << (CORBA::Object_ptr)obj;
+                return strm;
+        }
+        inline friend istream& operator>>(istream& strm, Cubit_ptr& obj) {
+                NCistream istrm(strm);
+                istrm >> obj;
+                return strm;
+        }
 };