TAO: TAO Namespace Reference


Classes
class	Arg_Traits< CORBA::Short >
	Specializations for basic stub arg types, except (w)char/boolean/octet. More...
class	Arg_Traits< CORBA::Long >
class	Arg_Traits< CORBA::UShort >
class	Arg_Traits< CORBA::ULong >
class	Arg_Traits< CORBA::Float >
class	Arg_Traits< CORBA::Double >
class	Arg_Traits< CORBA::LongLong >
class	Arg_Traits< CORBA::ULongLong >
class	Arg_Traits< CORBA::LongDouble >
class	Arg_Traits< CORBA::Object >
struct	Objref_Traits< CORBA::Object >
struct	In_Object_Argument_Cloner_T< CORBA::InterfaceDef_ptr >
class	Arg_Traits< CORBA::Policy >
class	Arg_Traits< ACE_InputCDR::to_char >
	Specializations for (w)char, octet and boolean. More...
class	Arg_Traits< ACE_InputCDR::to_wchar >
class	Arg_Traits< ACE_InputCDR::to_octet >
class	Arg_Traits< ACE_InputCDR::to_boolean >
class	Arg_Traits< CORBA::Char * >
	Specializatons for unbounded (w)strings. More...
class	Arg_Traits< CORBA::WChar * >
class	unbounded_value_sequence< CORBA::Octet >
struct	Objref_Traits< ::CORBA::Policy >
Namespaces
namespace	CSD
namespace	details
namespace	ORB
namespace	Transport
namespace	TypeCode
namespace	Utils
Functions
template<typename stream, typename T_array, typename T_slice, typename T_tag, CORBA::ULong MAX>
bool	demarshal_sequence (stream &strm, TAO::bounded_array_sequence< T_array, T_slice, T_tag, MAX > &target)
template<typename stream, typename T_array, typename T_slice, typename T_tag, CORBA::ULong MAX>
bool	marshal_sequence (stream &strm, const TAO::bounded_array_sequence< T_array, T_slice, T_tag, MAX > &source)
template<typename stream, CORBA::ULong MAX>
bool	demarshal_sequence (stream &strm, TAO::bounded_value_sequence< CORBA::Short, MAX > &target)
template<typename stream, CORBA::ULong MAX>
bool	demarshal_sequence (stream &strm, TAO::bounded_value_sequence< CORBA::Long, MAX > &target)
template<typename stream, CORBA::ULong MAX>
bool	demarshal_sequence (stream &strm, TAO::bounded_value_sequence< CORBA::ULong, MAX > &target)
template<typename stream, CORBA::ULong MAX>
bool	demarshal_sequence (stream &strm, TAO::bounded_value_sequence< CORBA::UShort, MAX > &target)
template<typename stream, CORBA::ULong MAX>
bool	demarshal_sequence (stream &strm, TAO::bounded_value_sequence< CORBA::Octet, MAX > &target)
template<typename stream, CORBA::ULong MAX>
bool	demarshal_sequence (stream &strm, TAO::bounded_value_sequence< CORBA::Char, MAX > &target)
template<typename stream, CORBA::ULong MAX>
bool	demarshal_sequence (stream &strm, TAO::bounded_value_sequence< CORBA::Float, MAX > &target)
template<typename stream, CORBA::ULong MAX>
bool	demarshal_sequence (stream &strm, TAO::bounded_value_sequence< CORBA::Double, MAX > &target)
template<typename stream, CORBA::ULong MAX>
bool	demarshal_sequence (stream &strm, TAO::bounded_value_sequence< CORBA::ULongLong, MAX > &target)
template<typename stream, CORBA::ULong MAX>
bool	demarshal_sequence (stream &strm, TAO::bounded_value_sequence< CORBA::LongDouble, MAX > &target)
template<typename stream, CORBA::ULong MAX>
bool	demarshal_sequence (stream &strm, TAO::bounded_value_sequence< CORBA::Boolean, MAX > &target)
template<typename stream, typename value_t, CORBA::ULong MAX>
bool	demarshal_sequence (stream &strm, TAO::bounded_value_sequence< value_t, MAX > &target)
template<typename stream, typename charT, CORBA::ULong MAX>
bool	demarshal_sequence (stream &strm, TAO::bounded_basic_string_sequence< charT, MAX > &target)
template<typename stream, typename object_t, typename object_t_var, CORBA::ULong MAX>
bool	demarshal_sequence (stream &strm, TAO::bounded_object_reference_sequence< object_t, object_t_var, MAX > &target)
template<typename stream, CORBA::ULong MAX>
bool	marshal_sequence (stream &strm, const TAO::bounded_value_sequence< CORBA::Short, MAX > &source)
template<typename stream, CORBA::ULong MAX>
bool	marshal_sequence (stream &strm, const TAO::bounded_value_sequence< CORBA::Long, MAX > &source)
template<typename stream, CORBA::ULong MAX>
bool	marshal_sequence (stream &strm, const TAO::bounded_value_sequence< CORBA::ULong, MAX > &source)
template<typename stream, CORBA::ULong MAX>
bool	marshal_sequence (stream &strm, const TAO::bounded_value_sequence< CORBA::UShort, MAX > &source)
template<typename stream, CORBA::ULong MAX>
bool	marshal_sequence (stream &strm, const TAO::bounded_value_sequence< CORBA::Octet, MAX > &source)
template<typename stream, CORBA::ULong MAX>
bool	marshal_sequence (stream &strm, const TAO::bounded_value_sequence< CORBA::Char, MAX > &source)
template<typename stream, CORBA::ULong MAX>
bool	marshal_sequence (stream &strm, const TAO::bounded_value_sequence< CORBA::Float, MAX > &source)
template<typename stream, CORBA::ULong MAX>
bool	marshal_sequence (stream &strm, const TAO::bounded_value_sequence< CORBA::Double, MAX > &source)
template<typename stream, CORBA::ULong MAX>
bool	marshal_sequence (stream &strm, const TAO::bounded_value_sequence< CORBA::ULongLong, MAX > &source)
template<typename stream, CORBA::ULong MAX>
bool	marshal_sequence (stream &strm, const TAO::bounded_value_sequence< CORBA::LongDouble, MAX > &source)
template<typename stream, CORBA::ULong MAX>
bool	marshal_sequence (stream &strm, const TAO::bounded_value_sequence< CORBA::Boolean, MAX > &source)
template<typename stream, typename value_t, CORBA::ULong MAX>
bool	marshal_sequence (stream &strm, const TAO::bounded_value_sequence< value_t, MAX > &source)
template<typename stream, typename charT, CORBA::ULong MAX>
bool	marshal_sequence (stream &strm, const TAO::bounded_basic_string_sequence< charT, MAX > &source)
template<typename stream, typename object_t, typename object_t_var, CORBA::ULong MAX>
bool	marshal_sequence (stream &strm, const TAO::bounded_object_reference_sequence< object_t, object_t_var, MAX > &source)
TAO_Export CORBA::SystemException *	create_system_exception (const char *id)
	Create a CORBA::SystemException given the interface repository ID.
bool	parse_orb_opt (ACE_Argv_Type_Converter &command_line, const ACE_TCHAR *orb_opt, ACE_CString &opt_arg)
ACE_Intrusive_Auto_Ptr< ACE_Service_Gestalt >	find_orb_context (const ACE_CString &orbconfig_string)
STANDARD_EXCEPTION_LIST CORBA::SystemException *	create_system_exception (const char *id)
	Create a CORBA::SystemException given the interface repository ID.
template<typename stream, typename T_array, typename T_slice, typename T_tag>
bool	demarshal_sequence (stream &strm, TAO::unbounded_array_sequence< T_array, T_slice, T_tag > &target)
template<typename stream, typename T_array, typename T_slice, typename T_tag>
bool	marshal_sequence (stream &strm, const TAO::unbounded_array_sequence< T_array, T_slice, T_tag > &source)
template<typename stream>
bool	demarshal_sequence (stream &strm, TAO::unbounded_value_sequence< CORBA::Short > &target)
template<typename stream>
bool	demarshal_sequence (stream &strm, TAO::unbounded_value_sequence< CORBA::Long > &target)
template<typename stream>
bool	demarshal_sequence (stream &strm, TAO::unbounded_value_sequence< CORBA::ULong > &target)
template<typename stream>
bool	demarshal_sequence (stream &strm, TAO::unbounded_value_sequence< CORBA::UShort > &target)
template<typename stream>
bool	demarshal_sequence (stream &strm, TAO::unbounded_value_sequence< CORBA::Octet > &target)
template<typename stream>
bool	demarshal_sequence (stream &strm, TAO::unbounded_value_sequence< CORBA::Char > &target)
template<typename stream>
bool	demarshal_sequence (stream &strm, TAO::unbounded_value_sequence< CORBA::Float > &target)
template<typename stream>
bool	demarshal_sequence (stream &strm, TAO::unbounded_value_sequence< CORBA::Double > &target)
template<typename stream>
bool	demarshal_sequence (stream &strm, TAO::unbounded_value_sequence< CORBA::ULongLong > &target)
template<typename stream>
bool	demarshal_sequence (stream &strm, TAO::unbounded_value_sequence< CORBA::LongDouble > &target)
template<typename stream>
bool	demarshal_sequence (stream &strm, TAO::unbounded_value_sequence< CORBA::Boolean > &target)
template<typename stream, typename value_t>
bool	demarshal_sequence (stream &strm, TAO::unbounded_value_sequence< value_t > &target)
template<typename stream, typename charT>
bool	demarshal_sequence (stream &strm, TAO::unbounded_basic_string_sequence< charT > &target)
template<typename stream, typename object_t, typename object_t_var>
bool	demarshal_sequence (stream &strm, TAO::unbounded_object_reference_sequence< object_t, object_t_var > &target)
template<typename stream>
bool	marshal_sequence (stream &strm, const TAO::unbounded_value_sequence< CORBA::Short > &source)
template<typename stream>
bool	marshal_sequence (stream &strm, const TAO::unbounded_value_sequence< CORBA::Long > &source)
template<typename stream>
bool	marshal_sequence (stream &strm, const TAO::unbounded_value_sequence< CORBA::ULong > &source)
template<typename stream>
bool	marshal_sequence (stream &strm, const TAO::unbounded_value_sequence< CORBA::UShort > &source)
template<typename stream>
bool	marshal_sequence (stream &strm, const TAO::unbounded_value_sequence< CORBA::Octet > &source)
template<typename stream>
bool	marshal_sequence (stream &strm, const TAO::unbounded_value_sequence< CORBA::Char > &source)
template<typename stream>
bool	marshal_sequence (stream &strm, const TAO::unbounded_value_sequence< CORBA::Float > &source)
template<typename stream>
bool	marshal_sequence (stream &strm, const TAO::unbounded_value_sequence< CORBA::Double > &source)
template<typename stream>
bool	marshal_sequence (stream &strm, const TAO::unbounded_value_sequence< CORBA::ULongLong > &source)
template<typename stream>
bool	marshal_sequence (stream &strm, const TAO::unbounded_value_sequence< CORBA::LongDouble > &source)
template<typename stream>
bool	marshal_sequence (stream &strm, const TAO::unbounded_value_sequence< CORBA::Boolean > &source)
template<typename stream, typename value_t>
bool	marshal_sequence (stream &strm, const TAO::unbounded_value_sequence< value_t > &source)
template<typename stream, typename charT>
bool	marshal_sequence (stream &strm, const TAO::unbounded_basic_string_sequence< charT > &source)
template<typename stream, typename object_t, typename object_t_var>
bool	marshal_sequence (stream &strm, const TAO::unbounded_object_reference_sequence< object_t, object_t_var > &source)

Detailed Description

Function Documentation

template<typename stream, typename T_array, typename T_slice, typename T_tag, CORBA::ULong MAX>

bool TAO::demarshal_sequence	(	stream &	strm,
		TAO::bounded_array_sequence< T_array, T_slice, T_tag, MAX > &	target
	)

Definition at line 94 of file Bounded_Array_Sequence_T.h.

References free().

Referenced by operator>>().

00094                                                                                                            {
00095     typedef typename TAO::bounded_array_sequence<T_array, T_slice, T_tag, MAX> sequence;
00096     typedef TAO_Array_Forany_T<T_array, T_slice, T_tag> forany;
00097     typedef TAO::Array_Traits<forany> array_traits;
00098 
00099     ::CORBA::ULong new_length = 0;
00100     if (!(strm >> new_length)) {
00101       return false;
00102     }
00103     if ((new_length > strm.length()) || (new_length > target.maximum ())) {
00104       return false;
00105     }
00106     sequence tmp;
00107     tmp.length(new_length);
00108     typename sequence::value_type * buffer = tmp.get_buffer();
00109     for(CORBA::ULong i = 0; i < new_length; ++i) {
00110       forany tmp (array_traits::alloc ());
00111       bool const _tao_marshal_flag = (strm >> tmp);
00112       if (_tao_marshal_flag) {
00113         array_traits::copy (buffer[i], tmp.in ());
00114       }
00115       array_traits::free (tmp.inout ());
00116       if (!_tao_marshal_flag) {
00117         return false;
00118       }
00119     }
00120     tmp.swap(target);
00121     return true;
00122   }

template<typename stream, typename T_array, typename T_slice, typename T_tag, CORBA::ULong MAX>

bool TAO::marshal_sequence	(	stream &	strm,
		const TAO::bounded_array_sequence< T_array, T_slice, T_tag, MAX > &	source
	)

Definition at line 125 of file Bounded_Array_Sequence_T.h.

References dup().

Referenced by operator<<().

00125                                                                                                                {
00126     typedef TAO_Array_Forany_T<T_array, T_slice, T_tag> forany;
00127     typedef TAO_FixedArray_Var_T <T_array, T_slice, T_tag> fixed_array;
00128     typedef TAO::Array_Traits<forany> array_traits;
00129     ::CORBA::ULong const length = source.length ();
00130     if (!(strm << length)) {
00131       return false;
00132     }
00133     for(CORBA::ULong i = 0; i < length; ++i) {
00134       fixed_array tmp_array = array_traits::dup (source[i]);
00135       forany tmp (tmp_array.inout ());
00136       if (!(strm << tmp)) {
00137         return false;
00138       }
00139     }
00140     return true;
00141   }

template<typename stream, CORBA::ULong MAX>

bool TAO::demarshal_sequence	(	stream &	strm,
		TAO::bounded_value_sequence< CORBA::Short, MAX > &	target
	)

Definition at line 20 of file Bounded_Sequence_CDR_T.h.

00020                                                                                                {
00021     typedef TAO::bounded_value_sequence <CORBA::Short, MAX> sequence;
00022     ::CORBA::ULong new_length = 0;
00023     if (!(strm >> new_length)) {
00024       return false;
00025     }
00026     if ((new_length > strm.length()) || (new_length > target.maximum ())) {
00027       return false;
00028     }
00029     sequence tmp;
00030     tmp.length(new_length);
00031     typename sequence::value_type * buffer = tmp.get_buffer();
00032     if (!strm.read_short_array (buffer, new_length)) {
00033       return false;
00034     }
00035     tmp.swap(target);
00036     return true;
00037   }

template<typename stream, CORBA::ULong MAX>

bool TAO::demarshal_sequence	(	stream &	strm,
		TAO::bounded_value_sequence< CORBA::Long, MAX > &	target
	)

Definition at line 40 of file Bounded_Sequence_CDR_T.h.

00040                                                                                               {
00041     typedef TAO::bounded_value_sequence <CORBA::Long, MAX> sequence;
00042     ::CORBA::ULong new_length = 0;
00043     if (!(strm >> new_length)) {
00044       return false;
00045     }
00046     if ((new_length > strm.length()) || (new_length > target.maximum ())) {
00047       return false;
00048     }
00049     sequence tmp;
00050     tmp.length(new_length);
00051     typename sequence::value_type * buffer = tmp.get_buffer();
00052     if (!strm.read_long_array (buffer, new_length)) {
00053       return false;
00054     }
00055     tmp.swap(target);
00056     return true;
00057   }

template<typename stream, CORBA::ULong MAX>

bool TAO::demarshal_sequence	(	stream &	strm,
		TAO::bounded_value_sequence< CORBA::ULong, MAX > &	target
	)

Definition at line 60 of file Bounded_Sequence_CDR_T.h.

00060                                                                                                {
00061     typedef TAO::bounded_value_sequence <CORBA::ULong, MAX> sequence;
00062     ::CORBA::ULong new_length = 0;
00063     if (!(strm >> new_length)) {
00064       return false;
00065     }
00066     if ((new_length > strm.length()) || (new_length > target.maximum ())) {
00067       return false;
00068     }
00069     sequence tmp;
00070     tmp.length(new_length);
00071     typename sequence::value_type * buffer = tmp.get_buffer();
00072     if (!strm.read_ulong_array (buffer, new_length)) {
00073       return false;
00074     }
00075     tmp.swap(target);
00076     return true;
00077   }

template<typename stream, CORBA::ULong MAX>

bool TAO::demarshal_sequence	(	stream &	strm,
		TAO::bounded_value_sequence< CORBA::UShort, MAX > &	target
	)

Definition at line 80 of file Bounded_Sequence_CDR_T.h.

00080                                                                                                 {
00081     typedef TAO::bounded_value_sequence <CORBA::UShort, MAX> sequence;
00082     ::CORBA::ULong new_length = 0;
00083     if (!(strm >> new_length)) {
00084       return false;
00085     }
00086     if ((new_length > strm.length()) || (new_length > target.maximum ())) {
00087       return false;
00088     }
00089     sequence tmp;
00090     tmp.length(new_length);
00091     typename sequence::value_type * buffer = tmp.get_buffer();
00092     if (!strm.read_ushort_array (buffer, new_length)) {
00093       return false;
00094     }
00095     tmp.swap(target);
00096     return true;
00097   }

template<typename stream, CORBA::ULong MAX>

bool TAO::demarshal_sequence	(	stream &	strm,
		TAO::bounded_value_sequence< CORBA::Octet, MAX > &	target
	)

Definition at line 100 of file Bounded_Sequence_CDR_T.h.

00100                                                                                                {
00101     typedef TAO::bounded_value_sequence <CORBA::Octet, MAX> sequence;
00102     ::CORBA::ULong new_length = 0;
00103     if (!(strm >> new_length)) {
00104       return false;
00105     }
00106     if ((new_length > strm.length()) || (new_length > target.maximum ())) {
00107       return false;
00108     }
00109     sequence tmp;
00110     tmp.length(new_length);
00111     typename sequence::value_type * buffer = tmp.get_buffer();
00112     if (!strm.read_octet_array (buffer, new_length)) {
00113       return false;
00114     }
00115     tmp.swap(target);
00116     return true;
00117   }

template<typename stream, CORBA::ULong MAX>

bool TAO::demarshal_sequence	(	stream &	strm,
		TAO::bounded_value_sequence< CORBA::Char, MAX > &	target
	)

Definition at line 120 of file Bounded_Sequence_CDR_T.h.

00120                                                                                               {
00121     typedef TAO::bounded_value_sequence <CORBA::Char, MAX> sequence;
00122     ::CORBA::ULong new_length = 0;
00123     if (!(strm >> new_length)) {
00124       return false;
00125     }
00126     if ((new_length > strm.length()) || (new_length > target.maximum ())) {
00127       return false;
00128     }
00129     sequence tmp;
00130     tmp.length(new_length);
00131     typename sequence::value_type * buffer = tmp.get_buffer();
00132     if (!strm.read_char_array (buffer, new_length)) {
00133       return false;
00134     }
00135     tmp.swap(target);
00136     return true;
00137   }

template<typename stream, CORBA::ULong MAX>

bool TAO::demarshal_sequence	(	stream &	strm,
		TAO::bounded_value_sequence< CORBA::Float, MAX > &	target
	)

Definition at line 162 of file Bounded_Sequence_CDR_T.h.

00162                                                                                                {
00163     typedef TAO::bounded_value_sequence <CORBA::Float, MAX> sequence;
00164     ::CORBA::ULong new_length = 0;
00165     if (!(strm >> new_length)) {
00166       return false;
00167     }
00168     if ((new_length > strm.length()) || (new_length > target.maximum ())) {
00169       return false;
00170     }
00171     sequence tmp;
00172     tmp.length(new_length);
00173     typename sequence::value_type * buffer = tmp.get_buffer();
00174     if (!strm.read_float_array (buffer, new_length)) {
00175       return false;
00176     }
00177     tmp.swap(target);
00178     return true;
00179   }

template<typename stream, CORBA::ULong MAX>

bool TAO::demarshal_sequence	(	stream &	strm,
		TAO::bounded_value_sequence< CORBA::Double, MAX > &	target
	)

Definition at line 182 of file Bounded_Sequence_CDR_T.h.

00182                                                                                                 {
00183     typedef TAO::bounded_value_sequence <CORBA::Double, MAX> sequence;
00184     ::CORBA::ULong new_length = 0;
00185     if (!(strm >> new_length)) {
00186       return false;
00187     }
00188     if ((new_length > strm.length()) || (new_length > target.maximum ())) {
00189       return false;
00190     }
00191     sequence tmp;
00192     tmp.length(new_length);
00193     typename sequence::value_type * buffer = tmp.get_buffer();
00194     if (!strm.read_double_array (buffer, new_length)) {
00195       return false;
00196     }
00197     tmp.swap(target);
00198     return true;
00199   }

template<typename stream, CORBA::ULong MAX>

bool TAO::demarshal_sequence	(	stream &	strm,
		TAO::bounded_value_sequence< CORBA::ULongLong, MAX > &	target
	)

Definition at line 202 of file Bounded_Sequence_CDR_T.h.

00202                                                                                                    {
00203     typedef TAO::bounded_value_sequence <CORBA::ULongLong, MAX> sequence;
00204     ::CORBA::ULong new_length = 0;
00205     if (!(strm >> new_length)) {
00206       return false;
00207     }
00208     if ((new_length > strm.length()) || (new_length > target.maximum ())) {
00209       return false;
00210     }
00211     sequence tmp;
00212     tmp.length(new_length);
00213     typename sequence::value_type * buffer = tmp.get_buffer();
00214     if (!strm.read_ulonglong_array (buffer, new_length)) {
00215       return false;
00216     }
00217     tmp.swap(target);
00218     return true;
00219   }

template<typename stream, CORBA::ULong MAX>

bool TAO::demarshal_sequence	(	stream &	strm,
		TAO::bounded_value_sequence< CORBA::LongDouble, MAX > &	target
	)

Definition at line 222 of file Bounded_Sequence_CDR_T.h.

00222                                                                                                     {
00223     typedef TAO::bounded_value_sequence <CORBA::LongDouble, MAX> sequence;
00224     ::CORBA::ULong new_length = 0;
00225     if (!(strm >> new_length)) {
00226       return false;
00227     }
00228     if ((new_length > strm.length()) || (new_length > target.maximum ())) {
00229       return false;
00230     }
00231     sequence tmp;
00232     tmp.length(new_length);
00233     typename sequence::value_type * buffer = tmp.get_buffer();
00234     if (!strm.read_longdouble_array (buffer, new_length)) {
00235       return false;
00236     }
00237     tmp.swap(target);
00238     return true;
00239   }

template<typename stream, CORBA::ULong MAX>

bool TAO::demarshal_sequence	(	stream &	strm,
		TAO::bounded_value_sequence< CORBA::Boolean, MAX > &	target
	)

Definition at line 242 of file Bounded_Sequence_CDR_T.h.

00242                                                                                                  {
00243     typedef TAO::bounded_value_sequence <CORBA::Boolean, MAX> sequence;
00244     ::CORBA::ULong new_length = 0;
00245     if (!(strm >> new_length)) {
00246       return false;
00247     }
00248     if ((new_length > strm.length()) || (new_length > target.maximum ())) {
00249       return false;
00250     }
00251     sequence tmp;
00252     tmp.length(new_length);
00253     typename sequence::value_type * buffer = tmp.get_buffer();
00254     if (!strm.read_boolean_array (buffer, new_length)) {
00255       return false;
00256     }
00257     tmp.swap(target);
00258     return true;
00259   }

template<typename stream, typename value_t, CORBA::ULong MAX>

bool TAO::demarshal_sequence	(	stream &	strm,
		TAO::bounded_value_sequence< value_t, MAX > &	target
	)

Definition at line 262 of file Bounded_Sequence_CDR_T.h.

00262                                                                                             {
00263     typedef TAO::bounded_value_sequence <value_t, MAX> sequence;
00264     ::CORBA::ULong new_length = 0;
00265     if (!(strm >> new_length)) {
00266       return false;
00267     }
00268     if ((new_length > strm.length()) || (new_length > target.maximum ())) {
00269       return false;
00270     }
00271     sequence tmp;
00272     tmp.length(new_length);
00273     typename sequence::value_type * buffer = tmp.get_buffer();
00274     for(CORBA::ULong i = 0; i < new_length; ++i) {
00275       if (!(strm >> buffer[i])) {
00276         return false;
00277       }
00278     }
00279     tmp.swap(target);
00280     return true;
00281   }

template<typename stream, typename charT, CORBA::ULong MAX>

bool TAO::demarshal_sequence	(	stream &	strm,
		TAO::bounded_basic_string_sequence< charT, MAX > &	target
	)

Definition at line 284 of file Bounded_Sequence_CDR_T.h.

00284                                                                                                  {
00285     typedef typename TAO::bounded_basic_string_sequence <charT, MAX> sequence;
00286     typedef typename sequence::element_traits::string_var string_var;
00287     ::CORBA::ULong new_length = 0;
00288     if (!(strm >> new_length)) {
00289       return false;
00290     }
00291     if ((new_length > strm.length()) || (new_length > target.maximum ())) {
00292       return false;
00293     }
00294     sequence tmp;
00295     tmp.length(new_length);
00296     for(CORBA::ULong i = 0; i < new_length; ++i) {
00297       string_var string;
00298       if (!(strm >> string.inout ())) {
00299         return false;
00300       }
00301       else {
00302         tmp[i] = string._retn ();
00303       }
00304     }
00305     tmp.swap(target);
00306     return true;
00307   }

template<typename stream, typename object_t, typename object_t_var, CORBA::ULong MAX>

bool TAO::demarshal_sequence	(	stream &	strm,
		TAO::bounded_object_reference_sequence< object_t, object_t_var, MAX > &	target
	)

Definition at line 310 of file Bounded_Sequence_CDR_T.h.

00310                                                                                                                      {
00311     typedef typename TAO::bounded_object_reference_sequence<object_t, object_t_var, MAX> sequence;
00312     ::CORBA::ULong new_length = 0;
00313     if (!(strm >> new_length)) {
00314       return false;
00315     }
00316     if ((new_length > strm.length()) || (new_length > target.maximum ())) {
00317       return false;
00318     }
00319     sequence tmp;
00320     tmp.length(new_length);
00321     typename sequence::value_type * buffer = tmp.get_buffer();
00322     for(CORBA::ULong i = 0; i < new_length; ++i) {
00323       if (!(strm >> buffer[i])) {
00324         return false;
00325       }
00326     }
00327     tmp.swap(target);
00328     return true;
00329   }

template<typename stream, CORBA::ULong MAX>

bool TAO::marshal_sequence	(	stream &	strm,
		const TAO::bounded_value_sequence< CORBA::Short, MAX > &	source
	)

Definition at line 334 of file Bounded_Sequence_CDR_T.h.

00334                                                                                                    {
00335     ::CORBA::ULong const length = source.length ();
00336     if (!(strm << length)) {
00337       return false;
00338     }
00339     return strm.write_short_array (source.get_buffer (), length);
00340   }

template<typename stream, CORBA::ULong MAX>

bool TAO::marshal_sequence	(	stream &	strm,
		const TAO::bounded_value_sequence< CORBA::Long, MAX > &	source
	)

Definition at line 343 of file Bounded_Sequence_CDR_T.h.

00343                                                                                                   {
00344     ::CORBA::ULong const length = source.length ();
00345     if (!(strm << length)) {
00346       return false;
00347     }
00348     return strm.write_long_array (source.get_buffer (), length);
00349   }

template<typename stream, CORBA::ULong MAX>

bool TAO::marshal_sequence	(	stream &	strm,
		const TAO::bounded_value_sequence< CORBA::ULong, MAX > &	source
	)

Definition at line 352 of file Bounded_Sequence_CDR_T.h.

00352                                                                                                    {
00353     ::CORBA::ULong const length = source.length ();
00354     if (!(strm << length)) {
00355       return false;
00356     }
00357     return strm.write_ulong_array (source.get_buffer (), length);
00358   }

template<typename stream, CORBA::ULong MAX>

bool TAO::marshal_sequence	(	stream &	strm,
		const TAO::bounded_value_sequence< CORBA::UShort, MAX > &	source
	)

Definition at line 361 of file Bounded_Sequence_CDR_T.h.

00361                                                                                                     {
00362     ::CORBA::ULong const length = source.length ();
00363     if (!(strm << length)) {
00364       return false;
00365     }
00366     return strm.write_ushort_array (source.get_buffer (), length);
00367   }

template<typename stream, CORBA::ULong MAX>

bool TAO::marshal_sequence	(	stream &	strm,
		const TAO::bounded_value_sequence< CORBA::Octet, MAX > &	source
	)

Definition at line 370 of file Bounded_Sequence_CDR_T.h.

00370                                                                                                    {
00371     ::CORBA::ULong const length = source.length ();
00372     if (!(strm << length)) {
00373       return false;
00374     }
00375     return strm.write_octet_array (source.get_buffer (), length);
00376   }

template<typename stream, CORBA::ULong MAX>

bool TAO::marshal_sequence	(	stream &	strm,
		const TAO::bounded_value_sequence< CORBA::Char, MAX > &	source
	)

Definition at line 379 of file Bounded_Sequence_CDR_T.h.

00379                                                                                                   {
00380     ::CORBA::ULong const length = source.length ();
00381     if (!(strm << length)) {
00382       return false;
00383     }
00384     return strm.write_char_array (source.get_buffer (), length);
00385   }

template<typename stream, CORBA::ULong MAX>

bool TAO::marshal_sequence	(	stream &	strm,
		const TAO::bounded_value_sequence< CORBA::Float, MAX > &	source
	)

Definition at line 399 of file Bounded_Sequence_CDR_T.h.

00399                                                                                                    {
00400     ::CORBA::ULong const length = source.length ();
00401     if (!(strm << length)) {
00402       return false;
00403     }
00404     return strm.write_float_array (source.get_buffer (), length);
00405   }

template<typename stream, CORBA::ULong MAX>

bool TAO::marshal_sequence	(	stream &	strm,
		const TAO::bounded_value_sequence< CORBA::Double, MAX > &	source
	)

Definition at line 408 of file Bounded_Sequence_CDR_T.h.

00408                                                                                                     {
00409     ::CORBA::ULong const length = source.length ();
00410     if (!(strm << length)) {
00411       return false;
00412     }
00413     return strm.write_double_array (source.get_buffer (), length);
00414   }

template<typename stream, CORBA::ULong MAX>

bool TAO::marshal_sequence	(	stream &	strm,
		const TAO::bounded_value_sequence< CORBA::ULongLong, MAX > &	source
	)

Definition at line 417 of file Bounded_Sequence_CDR_T.h.

00417                                                                                                        {
00418     ::CORBA::ULong const length = source.length ();
00419     if (!(strm << length)) {
00420       return false;
00421     }
00422     return strm.write_ulonglong_array (source.get_buffer (), length);
00423   }

template<typename stream, CORBA::ULong MAX>

bool TAO::marshal_sequence	(	stream &	strm,
		const TAO::bounded_value_sequence< CORBA::LongDouble, MAX > &	source
	)

Definition at line 426 of file Bounded_Sequence_CDR_T.h.

00426                                                                                                         {
00427     ::CORBA::ULong const length = source.length ();
00428     if (!(strm << length)) {
00429       return false;
00430     }
00431     return strm.write_longdouble_array (source.get_buffer (), length);
00432   }

template<typename stream, CORBA::ULong MAX>

bool TAO::marshal_sequence	(	stream &	strm,
		const TAO::bounded_value_sequence< CORBA::Boolean, MAX > &	source
	)

Definition at line 435 of file Bounded_Sequence_CDR_T.h.

00435                                                                                                      {
00436     ::CORBA::ULong const length = source.length ();
00437     if (!(strm << length)) {
00438       return false;
00439     }
00440     return strm.write_boolean_array (source.get_buffer (), length);
00441   }

template<typename stream, typename value_t, CORBA::ULong MAX>

bool TAO::marshal_sequence	(	stream &	strm,
		const TAO::bounded_value_sequence< value_t, MAX > &	source
	)

Definition at line 444 of file Bounded_Sequence_CDR_T.h.

00444                                                                                                 {
00445     ::CORBA::ULong const length = source.length ();
00446     if (!(strm << length)) {
00447       return false;
00448     }
00449     for(CORBA::ULong i = 0; i < length; ++i) {
00450       if (!(strm << source[i])) {
00451         return false;
00452       }
00453     }
00454     return true;
00455   }

template<typename stream, typename charT, CORBA::ULong MAX>

bool TAO::marshal_sequence	(	stream &	strm,
		const TAO::bounded_basic_string_sequence< charT, MAX > &	source
	)

Definition at line 458 of file Bounded_Sequence_CDR_T.h.

00458                                                                                                      {
00459     ::CORBA::ULong const length = source.length ();
00460     if (!(strm << length)) {
00461       return false;
00462     }
00463     for(CORBA::ULong i = 0; i < length; ++i) {
00464       if (!(strm << source[i])) {
00465         return false;
00466       }
00467     }
00468     return true;
00469   }

template<typename stream, typename object_t, typename object_t_var, CORBA::ULong MAX>

bool TAO::marshal_sequence	(	stream &	strm,
		const TAO::bounded_object_reference_sequence< object_t, object_t_var, MAX > &	source
	)

Definition at line 472 of file Bounded_Sequence_CDR_T.h.

00472                                                                                                                          {
00473     typedef typename TAO::bounded_object_reference_sequence<object_t, object_t_var, MAX>::object_type object_type;
00474     ::CORBA::ULong const length = source.length ();
00475     if (!(strm << length)) {
00476       return false;
00477     }
00478     for(CORBA::ULong i = 0; i < length; ++i) {
00479       if (!TAO::Objref_Traits<object_type>::marshal (source[i], strm)) {
00480         return false;
00481       }
00482     }
00483     return true;
00484   }

TAO_Export CORBA::SystemException* TAO::create_system_exception ( const char * id )

Create a CORBA::SystemException given the interface repository ID.

Definition at line 935 of file SystemException.cpp.

References array_sz, repo_id_array, and ACE_OS::strcmp().

Referenced by TAO::Synch_Twoway_Invocation::handle_system_exception().

00936 {
00937   for (CORBA::ULong i = 0; i < array_sz; ++i)
00938     {
00939       if (ACE_OS::strcmp (id, repo_id_array[i]) == 0)
00940         return (*(excp_array[i])) ();
00941     }
00942 
00943   return 0;
00944 }

bool TAO::parse_orb_opt	(	ACE_Argv_Type_Converter &	command_line,
		const ACE_TCHAR *	orb_opt,
		ACE_CString &	opt_arg
	)

Definition at line 1070 of file ORB.cpp.

References ACE_TEXT_ALWAYS_CHAR, ACE_Argv_Type_Converter::get_argc(), ACE_Argv_Type_Converter::get_TCHAR_argv(), ACE_String_Base< CHAR >::length(), ACE_OS::strcasecmp(), ACE_OS::strlen(), and ACE_OS::strncasecmp().

Referenced by CORBA::ORB_init().

01073   {
01074 
01075     if (opt_arg.length () > 0)
01076       return false;
01077 
01078     ACE_Arg_Shifter arg_shifter (command_line.get_argc (),
01079                                  command_line.get_TCHAR_argv ());
01080 
01081     size_t opt_len = ACE_OS::strlen (orb_opt);
01082 
01083     bool found = false;
01084     while (arg_shifter.is_anything_left ())
01085       {
01086         const ACE_TCHAR *current_arg = arg_shifter.get_current ();
01087 
01088         if (ACE_OS::strcasecmp (current_arg,
01089                                 orb_opt) == 0)
01090           {
01091             found = true;
01092             arg_shifter.consume_arg ();
01093             if (arg_shifter.is_parameter_next ())
01094               {
01095                 opt_arg =
01096                   ACE_TEXT_ALWAYS_CHAR (arg_shifter.get_current ());
01097                 arg_shifter.consume_arg ();
01098               }
01099           }
01100         else if (ACE_OS::strncasecmp (current_arg, orb_opt,
01101                                       opt_len) == 0)
01102           {
01103             arg_shifter.consume_arg ();
01104             // The rest of the argument is the ORB id...
01105             // but we should skip an optional space...
01106             if (current_arg[opt_len] == ' ')
01107               opt_arg =
01108                 ACE_TEXT_ALWAYS_CHAR (current_arg + opt_len + 1);
01109             else
01110               opt_arg = ACE_TEXT_ALWAYS_CHAR (current_arg + opt_len);
01111           }
01112         else
01113           arg_shifter.ignore_arg ();
01114       }
01115     return found;
01116   }

ACE_Intrusive_Auto_Ptr<ACE_Service_Gestalt> TAO::find_orb_context ( const ACE_CString & orbconfig_string )

Definition at line 1119 of file ORB.cpp.

References CORBA::SystemException::_tao_minor_code(), ACE_ERROR, ACE_NEW_THROW_EX, ACE_TEXT, ACE_TEXT_CHAR_TO_TCHAR, ACE_String_Base< CHAR >::c_str(), CORBA::COMPLETED_NO, ENOTSUP, ACE_Service_Config::global(), ACE_String_Base< CHAR >::is_empty(), LM_ERROR, ACE_Service_Gestalt::MAX_SERVICES, ACE_OS::strcasecmp(), ACE_OS::strncmp(), ACE_String_Base< CHAR >::substr(), TAO_debug_level, and TAO_ORB_CORE_INIT_LOCATION_CODE.

Referenced by CORBA::ORB_init().

01120     {
01121       const ACE_TCHAR *arg = ACE_TEXT_CHAR_TO_TCHAR(orbconfig_string.c_str ());
01122 
01123       // Need a local repo? Make one which typically should not be as
01124       // big as the default repository
01125       const ACE_TCHAR *local = ACE_TEXT("LOCAL");
01126       if  (ACE_OS::strcasecmp (arg, local) == 0)
01127         {
01128           ACE_Service_Gestalt* gestalt = 0;
01129           ACE_NEW_THROW_EX (gestalt,
01130                             ACE_Service_Gestalt
01131                             (ACE_Service_Gestalt::MAX_SERVICES / 4, true),
01132                             CORBA::NO_MEMORY
01133                             (CORBA::SystemException::_tao_minor_code (0,
01134                                                                       ENOMEM),
01135                              CORBA::COMPLETED_NO));
01136           return ACE_Intrusive_Auto_Ptr<ACE_Service_Gestalt> (gestalt);
01137         }
01138 
01139       // Explicit global case?
01140       const ACE_TCHAR *global = ACE_TEXT("GLOBAL");
01141       if  (orbconfig_string.is_empty () || ACE_OS::strcasecmp (arg, global) == 0)
01142         {
01143           return ACE_Service_Config::global ();
01144         }
01145 
01146       // Someone else's context?
01147       const ACE_TCHAR *shared = ACE_TEXT("ORB:");
01148       if (ACE_OS::strncmp (arg, shared, sizeof (shared) - 1) == 0)
01149         {
01150           ACE_CString orbid (orbconfig_string.substr (sizeof (shared)));
01151 
01152           // Get ORB Core
01153           TAO_ORB_Core_Auto_Ptr oc (TAO::ORB_Table::instance ()->find (orbid.c_str ()));
01154           if (oc.get () != 0)
01155               return oc->configuration ();
01156 
01157           if (TAO_debug_level > 0)
01158               ACE_ERROR ((LM_ERROR,
01159               ACE_TEXT ("ERROR: Unable to find ORB: %s. Invalid shared ")
01160               ACE_TEXT ("configuration argument \"%s\"\n"),
01161                 orbid.c_str (), arg));
01162 
01163           throw ::CORBA::BAD_PARAM
01164             (CORBA::SystemException::_tao_minor_code
01165              ( TAO_ORB_CORE_INIT_LOCATION_CODE,
01166                ENOTSUP),
01167              CORBA::COMPLETED_NO);
01168         }
01169 
01170 
01171       // Unknown value
01172       if (TAO_debug_level > 0)
01173             ACE_ERROR ((LM_ERROR,
01174                         ACE_TEXT ("ERROR: -ORBGestalt unknown value <%s>\n"),
01175                         orbconfig_string.c_str()));
01176 
01177       throw ::CORBA::BAD_PARAM
01178           (CORBA::SystemException::_tao_minor_code
01179            ( TAO_ORB_CORE_INIT_LOCATION_CODE,
01180              EINVAL),
01181            CORBA::COMPLETED_NO);
01182      }

STANDARD_EXCEPTION_LIST CORBA::SystemException* TAO::create_system_exception ( const char * id )

Create a CORBA::SystemException given the interface repository ID.

Definition at line 935 of file SystemException.cpp.

References array_sz, repo_id_array, and ACE_OS::strcmp().

Referenced by TAO::Synch_Twoway_Invocation::handle_system_exception().

00936 {
00937   for (CORBA::ULong i = 0; i < array_sz; ++i)
00938     {
00939       if (ACE_OS::strcmp (id, repo_id_array[i]) == 0)
00940         return (*(excp_array[i])) ();
00941     }
00942 
00943   return 0;
00944 }

template<typename stream, typename T_array, typename T_slice, typename T_tag>

bool TAO::demarshal_sequence	(	stream &	strm,
		TAO::unbounded_array_sequence< T_array, T_slice, T_tag > &	target
	)

Definition at line 100 of file Unbounded_Array_Sequence_T.h.

References free().

00100                                                                                                         {
00101     typedef TAO::unbounded_array_sequence<T_array, T_slice, T_tag> sequence;
00102     typedef TAO_Array_Forany_T <T_array, T_slice, T_tag> forany;
00103     typedef TAO::Array_Traits<forany> array_traits;
00104 
00105     ::CORBA::ULong new_length = 0;
00106     if (!(strm >> new_length)) {
00107       return false;
00108     }
00109     if (new_length > strm.length()) {
00110       return false;
00111     }
00112     sequence tmp(new_length);
00113     tmp.length(new_length);
00114     typename sequence::value_type * buffer = tmp.get_buffer();
00115     for(CORBA::ULong i = 0; i < new_length; ++i) {
00116       forany tmp (array_traits::alloc ());
00117       bool const _tao_marshal_flag = (strm >> tmp);
00118       if (_tao_marshal_flag) {
00119         array_traits::copy (buffer[i], tmp.in ());
00120       }
00121       array_traits::free (tmp.inout ());
00122       if (!_tao_marshal_flag) {
00123         return false;
00124       }
00125     }
00126     tmp.swap(target);
00127     return true;
00128   }

template<typename stream, typename T_array, typename T_slice, typename T_tag>

bool TAO::marshal_sequence	(	stream &	strm,
		const TAO::unbounded_array_sequence< T_array, T_slice, T_tag > &	source
	)

Definition at line 131 of file Unbounded_Array_Sequence_T.h.

References dup().

00131                                                                                                             {
00132     typedef TAO_FixedArray_Var_T <T_array, T_slice, T_tag> fixed_array;
00133     typedef TAO_Array_Forany_T <T_array, T_slice, T_tag> forany;
00134     typedef TAO::Array_Traits<forany> array_traits;
00135     ::CORBA::ULong const length = source.length ();
00136     if (!(strm << length)) {
00137       return false;
00138     }
00139     for(CORBA::ULong i = 0; i < length; ++i) {
00140       fixed_array tmp_array = array_traits::dup (source[i]);
00141       forany const tmp (tmp_array.inout ());
00142       if (!(strm << tmp)) {
00143         return false;
00144       }
00145     }
00146     return true;
00147   }

template<typename stream>

bool TAO::demarshal_sequence	(	stream &	strm,
		TAO::unbounded_value_sequence< CORBA::Short > &	target
	)

Definition at line 21 of file Unbounded_Sequence_CDR_T.h.

00021                                                                                             {
00022     typedef TAO::unbounded_value_sequence <CORBA::Short> sequence;
00023     ::CORBA::ULong new_length = 0;
00024     if (!(strm >> new_length)) {
00025       return false;
00026     }
00027     if (new_length > strm.length()) {
00028       return false;
00029     }
00030     sequence tmp(new_length);
00031     tmp.length(new_length);
00032     typename sequence::value_type * buffer = tmp.get_buffer();
00033     if (!strm.read_short_array (buffer, new_length)) {
00034       return false;
00035     }
00036     tmp.swap(target);
00037     return true;
00038   }

template<typename stream>

bool TAO::demarshal_sequence	(	stream &	strm,
		TAO::unbounded_value_sequence< CORBA::Long > &	target
	)

Definition at line 41 of file Unbounded_Sequence_CDR_T.h.

00041                                                                                            {
00042     typedef TAO::unbounded_value_sequence <CORBA::Long> sequence;
00043     ::CORBA::ULong new_length = 0;
00044     if (!(strm >> new_length)) {
00045       return false;
00046     }
00047     if (new_length > strm.length()) {
00048       return false;
00049     }
00050     sequence tmp(new_length);
00051     tmp.length(new_length);
00052     typename sequence::value_type * buffer = tmp.get_buffer();
00053     if (!strm.read_long_array (buffer, new_length)) {
00054       return false;
00055     }
00056     tmp.swap(target);
00057     return true;
00058   }

template<typename stream>

bool TAO::demarshal_sequence	(	stream &	strm,
		TAO::unbounded_value_sequence< CORBA::ULong > &	target
	)

Definition at line 61 of file Unbounded_Sequence_CDR_T.h.

00061                                                                                             {
00062     typedef TAO::unbounded_value_sequence <CORBA::ULong> sequence;
00063     ::CORBA::ULong new_length = 0;
00064     if (!(strm >> new_length)) {
00065       return false;
00066     }
00067     if (new_length > strm.length()) {
00068       return false;
00069     }
00070     sequence tmp(new_length);
00071     tmp.length(new_length);
00072     typename sequence::value_type * buffer = tmp.get_buffer();
00073     if (!strm.read_ulong_array (buffer, new_length)) {
00074       return false;
00075     }
00076     tmp.swap(target);
00077     return true;
00078   }

template<typename stream>

bool TAO::demarshal_sequence	(	stream &	strm,
		TAO::unbounded_value_sequence< CORBA::UShort > &	target
	)

Definition at line 81 of file Unbounded_Sequence_CDR_T.h.

00081                                                                                              {
00082     typedef TAO::unbounded_value_sequence <CORBA::UShort> sequence;
00083     ::CORBA::ULong new_length = 0;
00084     if (!(strm >> new_length)) {
00085       return false;
00086     }
00087     if (new_length > strm.length()) {
00088       return false;
00089     }
00090     sequence tmp(new_length);
00091     tmp.length(new_length);
00092     typename sequence::value_type * buffer = tmp.get_buffer();
00093     if (!strm.read_ushort_array (buffer, new_length)) {
00094       return false;
00095     }
00096     tmp.swap(target);
00097     return true;
00098   }

template<typename stream>

bool TAO::demarshal_sequence	(	stream &	strm,
		TAO::unbounded_value_sequence< CORBA::Octet > &	target
	)

Definition at line 102 of file Unbounded_Sequence_CDR_T.h.

References ACE_BIT_DISABLED, ACE_Message_Block::DONT_DELETE, and TAO_ORB_Core::resource_factory().

00102                                                                                             {
00103     typedef TAO::unbounded_value_sequence <CORBA::Octet> sequence;
00104     ::CORBA::ULong new_length = 0;
00105     if (!(strm >> new_length)) {
00106       return false;
00107     }
00108     if (new_length > strm.length()) {
00109       return false;
00110     }
00111     sequence tmp(new_length);
00112     tmp.length(new_length);
00113     if (ACE_BIT_DISABLED (strm.start ()->flags (), ACE_Message_Block::DONT_DELETE))
00114     {
00115       TAO_ORB_Core* orb_core = strm.orb_core ();
00116       if (orb_core != 0 && strm.orb_core ()->resource_factory ()->
00117         input_cdr_allocator_type_locked () == 1)
00118       {
00119         tmp.replace (new_length, strm.start ());
00120         tmp.mb ()->wr_ptr (tmp.mb()->rd_ptr () + new_length);
00121         strm.skip_bytes (new_length);
00122         tmp.swap(target);
00123         return true;
00124       }
00125     }
00126     typename sequence::value_type * buffer = tmp.get_buffer();
00127     if (!strm.read_octet_array (buffer, new_length)) {
00128       return false;
00129     }
00130     tmp.swap(target);
00131     return true;
00132   }

template<typename stream>

bool TAO::demarshal_sequence	(	stream &	strm,
		TAO::unbounded_value_sequence< CORBA::Char > &	target
	)

Definition at line 156 of file Unbounded_Sequence_CDR_T.h.

00156                                                                                            {
00157     typedef TAO::unbounded_value_sequence <CORBA::Char> sequence;
00158     ::CORBA::ULong new_length = 0;
00159     if (!(strm >> new_length)) {
00160       return false;
00161     }
00162     if (new_length > strm.length()) {
00163       return false;
00164     }
00165     sequence tmp(new_length);
00166     tmp.length(new_length);
00167     typename sequence::value_type * buffer = tmp.get_buffer();
00168     if (!strm.read_char_array (buffer, new_length)) {
00169       return false;
00170     }
00171     tmp.swap(target);
00172     return true;
00173   }

template<typename stream>

bool TAO::demarshal_sequence	(	stream &	strm,
		TAO::unbounded_value_sequence< CORBA::Float > &	target
	)

Definition at line 198 of file Unbounded_Sequence_CDR_T.h.

00198                                                                                             {
00199     typedef TAO::unbounded_value_sequence <CORBA::Float> sequence;
00200     ::CORBA::ULong new_length = 0;
00201     if (!(strm >> new_length)) {
00202       return false;
00203     }
00204     if (new_length > strm.length()) {
00205       return false;
00206     }
00207     sequence tmp(new_length);
00208     tmp.length(new_length);
00209     typename sequence::value_type * buffer = tmp.get_buffer();
00210     if (!strm.read_float_array (buffer, new_length)) {
00211       return false;
00212     }
00213     tmp.swap(target);
00214     return true;
00215   }

template<typename stream>

bool TAO::demarshal_sequence	(	stream &	strm,
		TAO::unbounded_value_sequence< CORBA::Double > &	target
	)

Definition at line 218 of file Unbounded_Sequence_CDR_T.h.

00218                                                                                              {
00219     typedef TAO::unbounded_value_sequence <CORBA::Double> sequence;
00220     ::CORBA::ULong new_length = 0;
00221     if (!(strm >> new_length)) {
00222       return false;
00223     }
00224     if (new_length > strm.length()) {
00225       return false;
00226     }
00227     sequence tmp(new_length);
00228     tmp.length(new_length);
00229     typename sequence::value_type * buffer = tmp.get_buffer();
00230     if (!strm.read_double_array (buffer, new_length)) {
00231       return false;
00232     }
00233     tmp.swap(target);
00234     return true;
00235   }

template<typename stream>

bool TAO::demarshal_sequence	(	stream &	strm,
		TAO::unbounded_value_sequence< CORBA::ULongLong > &	target
	)

Definition at line 238 of file Unbounded_Sequence_CDR_T.h.

00238                                                                                                 {
00239     typedef TAO::unbounded_value_sequence <CORBA::ULongLong> sequence;
00240     ::CORBA::ULong new_length = 0;
00241     if (!(strm >> new_length)) {
00242       return false;
00243     }
00244     if (new_length > strm.length()) {
00245       return false;
00246     }
00247     sequence tmp(new_length);
00248     tmp.length(new_length);
00249     typename sequence::value_type * buffer = tmp.get_buffer();
00250     if (!strm.read_ulonglong_array (buffer, new_length)) {
00251       return false;
00252     }
00253     tmp.swap(target);
00254     return true;
00255   }

template<typename stream>

bool TAO::demarshal_sequence	(	stream &	strm,
		TAO::unbounded_value_sequence< CORBA::LongDouble > &	target
	)

Definition at line 258 of file Unbounded_Sequence_CDR_T.h.

00258                                                                                                  {
00259     typedef TAO::unbounded_value_sequence <CORBA::LongDouble> sequence;
00260     ::CORBA::ULong new_length = 0;
00261     if (!(strm >> new_length)) {
00262       return false;
00263     }
00264     if (new_length > strm.length()) {
00265       return false;
00266     }
00267     sequence tmp(new_length);
00268     tmp.length(new_length);
00269     typename sequence::value_type * buffer = tmp.get_buffer();
00270     if (!strm.read_longdouble_array (buffer, new_length)) {
00271       return false;
00272     }
00273     tmp.swap(target);
00274     return true;
00275   }

template<typename stream>

bool TAO::demarshal_sequence	(	stream &	strm,
		TAO::unbounded_value_sequence< CORBA::Boolean > &	target
	)

Definition at line 278 of file Unbounded_Sequence_CDR_T.h.

00278                                                                                               {
00279     typedef TAO::unbounded_value_sequence <CORBA::Boolean> sequence;
00280     ::CORBA::ULong new_length = 0;
00281     if (!(strm >> new_length)) {
00282       return false;
00283     }
00284     if (new_length > strm.length()) {
00285       return false;
00286     }
00287     sequence tmp(new_length);
00288     tmp.length(new_length);
00289     typename sequence::value_type * buffer = tmp.get_buffer();
00290     if (!strm.read_boolean_array (buffer, new_length)) {
00291       return false;
00292     }
00293     tmp.swap(target);
00294     return true;
00295   }

template<typename stream, typename value_t>

bool TAO::demarshal_sequence	(	stream &	strm,
		TAO::unbounded_value_sequence< value_t > &	target
	)

Definition at line 298 of file Unbounded_Sequence_CDR_T.h.

00298                                                                                          {
00299     typedef TAO::unbounded_value_sequence <value_t> sequence;
00300     ::CORBA::ULong new_length = 0;
00301     if (!(strm >> new_length)) {
00302       return false;
00303     }
00304     if (new_length > strm.length()) {
00305       return false;
00306     }
00307     sequence tmp(new_length);
00308     tmp.length(new_length);
00309     typename sequence::value_type * buffer = tmp.get_buffer();
00310     for(CORBA::ULong i = 0; i < new_length; ++i) {
00311       if (!(strm >> buffer[i])) {
00312         return false;
00313       }
00314     }
00315     tmp.swap(target);
00316     return true;
00317   }

template<typename stream, typename charT>

bool TAO::demarshal_sequence	(	stream &	strm,
		TAO::unbounded_basic_string_sequence< charT > &	target
	)

Definition at line 320 of file Unbounded_Sequence_CDR_T.h.

00320                                                                                               {
00321     typedef TAO::unbounded_basic_string_sequence <charT> sequence;
00322     typedef typename sequence::element_traits::string_var string_var;
00323     ::CORBA::ULong new_length = 0;
00324     if (!(strm >> new_length)) {
00325       return false;
00326     }
00327     if (new_length > strm.length()) {
00328       return false;
00329     }
00330     sequence tmp(new_length);
00331     tmp.length(new_length);
00332     for(CORBA::ULong i = 0; i < new_length; ++i) {
00333       string_var string;
00334       if (!(strm >> string.inout ())) {
00335         return false;
00336       }
00337       else {
00338         tmp[i] = string._retn ();
00339       }
00340     }
00341     tmp.swap(target);
00342     return true;
00343   }

template<typename stream, typename object_t, typename object_t_var>

bool TAO::demarshal_sequence	(	stream &	strm,
		TAO::unbounded_object_reference_sequence< object_t, object_t_var > &	target
	)

Definition at line 346 of file Unbounded_Sequence_CDR_T.h.

00346                                                                                                                   {
00347     typedef TAO::unbounded_object_reference_sequence<object_t, object_t_var> sequence;
00348     ::CORBA::ULong new_length = 0;
00349     if (!(strm >> new_length)) {
00350       return false;
00351     }
00352     if (new_length > strm.length()) {
00353       return false;
00354     }
00355     sequence tmp(new_length);
00356     tmp.length(new_length);
00357     typename sequence::value_type * buffer = tmp.get_buffer();
00358     for(CORBA::ULong i = 0; i < new_length; ++i) {
00359       if (!(strm >> buffer[i])) {
00360         return false;
00361       }
00362     }
00363     tmp.swap(target);
00364     return true;
00365   }

template<typename stream>

bool TAO::marshal_sequence	(	stream &	strm,
		const TAO::unbounded_value_sequence< CORBA::Short > &	source
	)

Definition at line 370 of file Unbounded_Sequence_CDR_T.h.

00370                                                                                                 {
00371     ::CORBA::ULong const length = source.length ();
00372     if (!(strm << length)) {
00373       return false;
00374     }
00375     return strm.write_short_array (source.get_buffer (), length);
00376   }

template<typename stream>

bool TAO::marshal_sequence	(	stream &	strm,
		const TAO::unbounded_value_sequence< CORBA::Long > &	source
	)

Definition at line 379 of file Unbounded_Sequence_CDR_T.h.

00379                                                                                                {
00380     ::CORBA::ULong const length = source.length ();
00381     if (!(strm << length)) {
00382       return false;
00383     }
00384     return strm.write_long_array (source.get_buffer (), length);
00385   }

template<typename stream>

bool TAO::marshal_sequence	(	stream &	strm,
		const TAO::unbounded_value_sequence< CORBA::ULong > &	source
	)

Definition at line 388 of file Unbounded_Sequence_CDR_T.h.

00388                                                                                                 {
00389     ::CORBA::ULong const length = source.length ();
00390     if (!(strm << length)) {
00391       return false;
00392     }
00393     return strm.write_ulong_array (source.get_buffer (), length);
00394   }

template<typename stream>

bool TAO::marshal_sequence	(	stream &	strm,
		const TAO::unbounded_value_sequence< CORBA::UShort > &	source
	)

Definition at line 397 of file Unbounded_Sequence_CDR_T.h.

00397                                                                                                  {
00398     ::CORBA::ULong const length = source.length ();
00399     if (!(strm << length)) {
00400       return false;
00401     }
00402     return strm.write_ushort_array (source.get_buffer (), length);
00403   }

template<typename stream>

bool TAO::marshal_sequence	(	stream &	strm,
		const TAO::unbounded_value_sequence< CORBA::Octet > &	source
	)

Definition at line 407 of file Unbounded_Sequence_CDR_T.h.

00407                                                                                                 {
00408     ::CORBA::ULong const length = source.length ();
00409     if (!(strm << length)) {
00410       return false;
00411     }
00412     if (source.mb ()) {
00413       return strm.write_octet_array_mb (source.mb ());
00414     }
00415     return strm.write_octet_array (source.get_buffer (), length);
00416   }

template<typename stream>

bool TAO::marshal_sequence	(	stream &	strm,
		const TAO::unbounded_value_sequence< CORBA::Char > &	source
	)

Definition at line 429 of file Unbounded_Sequence_CDR_T.h.

00429                                                                                                {
00430     ::CORBA::ULong const length = source.length ();
00431     if (!(strm << length)) {
00432       return false;
00433     }
00434     return strm.write_char_array (source.get_buffer (), length);
00435   }

template<typename stream>

bool TAO::marshal_sequence	(	stream &	strm,
		const TAO::unbounded_value_sequence< CORBA::Float > &	source
	)

Definition at line 449 of file Unbounded_Sequence_CDR_T.h.

00449                                                                                                 {
00450     ::CORBA::ULong const length = source.length ();
00451     if (!(strm << length)) {
00452       return false;
00453     }
00454     return strm.write_float_array (source.get_buffer (), length);
00455   }

template<typename stream>

bool TAO::marshal_sequence	(	stream &	strm,
		const TAO::unbounded_value_sequence< CORBA::Double > &	source
	)

Definition at line 458 of file Unbounded_Sequence_CDR_T.h.

00458                                                                                                  {
00459     ::CORBA::ULong const length = source.length ();
00460     if (!(strm << length)) {
00461       return false;
00462     }
00463     return strm.write_double_array (source.get_buffer (), length);
00464   }

template<typename stream>

bool TAO::marshal_sequence	(	stream &	strm,
		const TAO::unbounded_value_sequence< CORBA::ULongLong > &	source
	)

Definition at line 467 of file Unbounded_Sequence_CDR_T.h.

00467                                                                                                     {
00468     ::CORBA::ULong const length = source.length ();
00469     if (!(strm << length)) {
00470       return false;
00471     }
00472     return strm.write_ulonglong_array (source.get_buffer (), length);
00473   }

template<typename stream>

bool TAO::marshal_sequence	(	stream &	strm,
		const TAO::unbounded_value_sequence< CORBA::LongDouble > &	source
	)

Definition at line 476 of file Unbounded_Sequence_CDR_T.h.

00476                                                                                                      {
00477     ::CORBA::ULong const length = source.length ();
00478     if (!(strm << length)) {
00479       return false;
00480     }
00481     return strm.write_longdouble_array (source.get_buffer (), length);
00482   }

template<typename stream>

bool TAO::marshal_sequence	(	stream &	strm,
		const TAO::unbounded_value_sequence< CORBA::Boolean > &	source
	)

Definition at line 485 of file Unbounded_Sequence_CDR_T.h.

00485                                                                                                   {
00486     ::CORBA::ULong const length = source.length ();
00487     if (!(strm << length)) {
00488       return false;
00489     }
00490     return strm.write_boolean_array (source.get_buffer (), length);
00491   }

template<typename stream, typename value_t>

bool TAO::marshal_sequence	(	stream &	strm,
		const TAO::unbounded_value_sequence< value_t > &	source
	)

Definition at line 494 of file Unbounded_Sequence_CDR_T.h.

00494                                                                                              {
00495     ::CORBA::ULong const length = source.length ();
00496     if (!(strm << length)) {
00497       return false;
00498     }
00499     for(CORBA::ULong i = 0; i < length; ++i) {
00500       if (!(strm << source[i])) {
00501         return false;
00502       }
00503     }
00504     return true;
00505   }

template<typename stream, typename charT>

bool TAO::marshal_sequence	(	stream &	strm,
		const TAO::unbounded_basic_string_sequence< charT > &	source
	)

Definition at line 508 of file Unbounded_Sequence_CDR_T.h.

00508                                                                                                   {
00509     ::CORBA::ULong const length = source.length ();
00510     if (!(strm << length)) {
00511       return false;
00512     }
00513     for(CORBA::ULong i = 0; i < length; ++i) {
00514       if (!(strm << source[i])) {
00515         return false;
00516       }
00517     }
00518     return true;
00519   }

template<typename stream, typename object_t, typename object_t_var>

bool TAO::marshal_sequence	(	stream &	strm,
		const TAO::unbounded_object_reference_sequence< object_t, object_t_var > &	source
	)

Definition at line 522 of file Unbounded_Sequence_CDR_T.h.

00522                                                                                                                       {
00523     typedef typename TAO::unbounded_object_reference_sequence<object_t, object_t_var>::object_type objec_t;
00524     ::CORBA::ULong const length = source.length ();
00525     if (!(strm << length)) {
00526       return false;
00527     }
00528     for(CORBA::ULong i = 0; i < length; ++i) {
00529       if (!TAO::Objref_Traits<objec_t>::marshal (source[i], strm)) {
00530         return false;
00531       }
00532     }
00533     return true;
00534   }

TAO Namespace Reference

Classes

Namespaces

Functions

Detailed Description

Function Documentation