CORBA::Boolean TAO::TypeCode::Struct<char const *, CORBA::TypeCode_ptr const *, TAO::TypeCode::Struct_Field<char const *, CORBA::TypeCode_ptr const *> const *, TAO::Null_RefCount_Policy>::equivalent_i ( CORBA::TypeCode_ptr tc) const { // Perform a structural comparison, excluding the name() and // member_name() operations. CORBA::ULong const tc_nfields = tc->member_count (); if (tc_nfields != this->nfields_) return false; for (CORBA::ULong i = 0; i < this->nfields_; ++i) { CORBA::TypeCode_ptr const lhs = Traits<char const *>::get_typecode (this->fields_[i].type); CORBA::TypeCode_var const rhs = tc->member_type (i); CORBA::Boolean const equiv_members = lhs->equivalent (rhs.in ()); if (!equiv_members) return false; } return true; }
bool TAO::TypeCode::Case<StringType, TypeCodeType>::equivalent ( CORBA::ULong index, CORBA::TypeCode_ptr tc ) const { // Member names are ignore when determining equivalence. // Check case TypeCodes. CORBA::TypeCode_ptr const lhs_tc = this->type (); CORBA::TypeCode_var const rhs_tc = tc->member_type (index ); CORBA::Boolean const equivalent_members = lhs_tc->equivalent (rhs_tc.in () ); if (!equivalent_members) return 0; // Check case label. // The label must be equal when determining equivalence, too. return this->equal_label (index, tc ); }
CORBA::Boolean TAO::TypeCode::Value<StringType, TypeCodeType, FieldArrayType, RefCountPolicy>::equivalent_i (CORBA::TypeCode_ptr tc) const { CORBA::ValueModifier const tc_type_modifier = tc->type_modifier (); if (tc_type_modifier != this->type_modifier_) return false; CORBA::TypeCode_var rhs_concrete_base_type = tc->concrete_base_type (); CORBA::Boolean const equivalent_concrete_base_types = this->equivalent (rhs_concrete_base_type.in ()); if (!equivalent_concrete_base_types) return false; // Perform a structural comparison, excluding the name() and // member_name() operations. CORBA::ULong const tc_nfields = tc->member_count (); if (tc_nfields != this->nfields_) return false; for (CORBA::ULong i = 0; i < this->nfields_; ++i) { Value_Field<StringType, TypeCodeType> const & lhs_field = this->fields_[i]; CORBA::Visibility const lhs_visibility = lhs_field.visibility; CORBA::Visibility const rhs_visibility = tc->member_visibility (i); if (lhs_visibility != rhs_visibility) return false; CORBA::TypeCode_ptr const lhs_tc = Traits<StringType>::get_typecode (lhs_field.type); CORBA::TypeCode_var const rhs_tc = tc->member_type (i); CORBA::Boolean const equiv_types = lhs_tc->equivalent (rhs_tc.in () ); if (!equiv_types) return false; } return true; }
void TAO_DynAny_i::check_typecode (CORBA::TypeCode_ptr tc) { // Check to see if it's a simple type. CORBA::TCKind tk = TAO_DynAnyFactory::unalias (tc); switch (tk) { case CORBA::tk_null: case CORBA::tk_void: case CORBA::tk_short: case CORBA::tk_long: case CORBA::tk_ushort: case CORBA::tk_ulong: case CORBA::tk_float: case CORBA::tk_double: case CORBA::tk_longlong: case CORBA::tk_ulonglong: case CORBA::tk_boolean: case CORBA::tk_char: case CORBA::tk_wchar: case CORBA::tk_octet: case CORBA::tk_any: case CORBA::tk_TypeCode: case CORBA::tk_objref: case CORBA::tk_string: case CORBA::tk_wstring: case CORBA::tk_longdouble: break; case CORBA::tk_sequence: if (tc->equivalent (CORBA::_tc_BooleanSeq) || tc->equivalent (CORBA::_tc_OctetSeq) || tc->equivalent (CORBA::_tc_CharSeq) || tc->equivalent (CORBA::_tc_WCharSeq) || tc->equivalent (CORBA::_tc_ShortSeq) || tc->equivalent (CORBA::_tc_UShortSeq) || tc->equivalent (CORBA::_tc_LongSeq) || tc->equivalent (CORBA::_tc_ULongSeq) || tc->equivalent (CORBA::_tc_LongLongSeq) || tc->equivalent (CORBA::_tc_ULongLongSeq) || tc->equivalent (CORBA::_tc_FloatSeq) || tc->equivalent (CORBA::_tc_DoubleSeq) || tc->equivalent (CORBA::_tc_LongDoubleSeq)) { // Otherwise fall through. break; } // fallthrough default: throw DynamicAny::DynAnyFactory::InconsistentTypeCode (); } }