C++ TypeCode_ptr::member_name方法代码示例

CORBA::Boolean
TAO::TypeCode::Enum<char const *,
                    char const * const *,
                    TAO::Null_RefCount_Policy>::equal_i (
  CORBA::TypeCode_ptr tc
  ) const
{
  // This call shouldn't throw since CORBA::TypeCode::equal() verified
  // that the TCKind is the same as our's prior to invoking this
  // method, meaning that member_count() is supported.

  CORBA::ULong const tc_nenumerators =
    tc->member_count ();

  if (tc_nenumerators != this->nenumerators_)
    return false;

  for (CORBA::ULong i = 0; i < this->nenumerators_; ++i)
    {
      char const * const & lhs_enumerator = this->enumerators_[i];

      char const * const lhs_name =
        Traits<char const *>::get_string (lhs_enumerator);
      char const * const rhs_name = tc->member_name (i);

      if (ACE_OS::strcmp (lhs_name, rhs_name) != 0)
        return false;
    }

  return true;
}

CORBA::Boolean TIDorb::core::typecode::StructTypeCode::equal(CORBA::TypeCode_ptr tc) const
{
  if (!ComplexTypeCode::equal(tc))
        return false;

  if (!m_exhaustive_equal)
        return true;
  try {

        CORBA::ULong length = m_members->length();
        if (length != tc->member_count())
                return false;


        for (CORBA::ULong i = 0; i < length; i++) {
                if (strcmp(member_name(i), tc->member_name(i)))
                        return false;
                if (! member_type(i)->equal(tc->member_type(i)))
                        return false;
        }
        // allright
        return true;
  } catch (const CORBA::TypeCode::BadKind& bk) {
        return false;
  } catch (const CORBA::TypeCode::Bounds& bn) {
        return false;
  }
}

bool
TAO::TypeCode::Case<StringType, TypeCodeType>::equal (CORBA::ULong index,
        CORBA::TypeCode_ptr tc
                                                     ) const
{
    // Check case names.
    char const * const lhs_name = this->name ();
    char const * const rhs_name = tc->member_name (index
                                                  );

    if (ACE_OS::strcmp (lhs_name, rhs_name) != 0)
        return false;

    // Check case TypeCodes.
    CORBA::TypeCode_ptr const lhs_tc = this->type ();
    CORBA::TypeCode_var const rhs_tc =
        tc->member_type (index
                        );

    CORBA::Boolean const equal_members =
        lhs_tc->equal (rhs_tc.in ()
                      );

    if (!equal_members)
        return false;

    // Check case label.
    return this->equal_label (index,
                              tc
                             );
}

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>::equal_i (
  CORBA::TypeCode_ptr tc) const
{
  // This call shouldn't throw since CORBA::TypeCode::equal() verified
  // that the TCKind is the same as our's prior to invoking this
  // method, meaning that member_count() is supported.

  CORBA::ULong const tc_nfields =
    tc->member_count ();

  if (tc_nfields != this->nfields_)
    return false;

  for (CORBA::ULong i = 0; i < this->nfields_; ++i)
    {
      Struct_Field<char const *, CORBA::TypeCode_ptr const *> const &
        lhs_field = this->fields_[i];

      char const * const lhs_name =
        Traits<char const *>::get_string (lhs_field.name);
      char const * const rhs_name = tc->member_name (i
                                                    );

      if (ACE_OS::strcmp (lhs_name, rhs_name) != 0)
        return false;

      CORBA::TypeCode_ptr const lhs_tc =
        Traits<char const *>::get_typecode (lhs_field.type);
      CORBA::TypeCode_var const rhs_tc =
        tc->member_type (i);

      CORBA::Boolean const equal_members =
        lhs_tc->equal (rhs_tc.in ());

      if (!equal_members)
        return false;
    }

  return true;
}

CORBA::Boolean
TAO::TypeCode::Value<char const *,
                     CORBA::TypeCode_ptr const *,
                     TAO::TypeCode::Value_Field<char const *,
                                                CORBA::TypeCode_ptr const *> const *,
                     TAO::Null_RefCount_Policy>::equal_i (
  CORBA::TypeCode_ptr tc) const
{
  // None of these calls should throw since CORBA::TypeCode::equal()
  // verified that the TCKind is the same as our's prior to invoking
  // this method.

  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 equal_concrete_base_types =
    this->equal (rhs_concrete_base_type.in ());

  if (!equal_concrete_base_types)
    return false;

  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<char const *, CORBA::TypeCode_ptr const *> 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;

      char const * const lhs_name =
        Traits<char const *>::get_string (lhs_field.name);;
      char const * const rhs_name = tc->member_name (i);

      if (ACE_OS::strcmp (lhs_name, rhs_name) != 0)
        return false;

      CORBA::TypeCode_ptr const lhs_tc =
        Traits<char const *>::get_typecode (lhs_field.type);
      CORBA::TypeCode_var const rhs_tc =
        tc->member_type (i);

      CORBA::Boolean const equal_members =
        lhs_tc->equal (rhs_tc.in ());

      if (!equal_members)
        return false;
    }

  return true;
}