Wed Jul 30 16:04:35 UTC 2014 Phil Mesnier <mesnier_p@ociweb.com>

        * tao/DynamicAny/DynAny_i.cpp:
          Added support for an equality test of dynamic anys holding
          sequences of basic types. Thanks to <anonymous> for contributing
          this fix.

        * tests/DynAny_Test/test_dynany.cpp:
          Extension to the test to add coverage of the above fix.

1 files changed, 289 insertions, 0 deletions

diff --git a/TAO/tao/DynamicAny/DynAny_i.cpp b/TAO/tao/DynamicAny/DynAny_i.cpp
index 2daddb2e817..a7c8dbe5ee0 100644
--- a/TAO/tao/DynamicAny/DynAny_i.cpp
+++ b/TAO/tao/DynamicAny/DynAny_i.cpp
@@ -498,6 +498,295 @@ TAO_DynAny_i::equal (DynamicAny::DynAny_ptr rhs)
 
         return ACE_OS::wscmp (rhs_v, lhs_v) == 0;
       }
+    case CORBA::tk_sequence:
+      {
+        // The only way we can get here is if we have a basic sequence (see check_typecode)
+        CORBA::TypeCode_var unaliased_tc =
+          TAO_DynAnyFactory::strip_alias (this->type_.in ());
+
+        CORBA::TCKind tk_content = TAO_DynAnyFactory::unalias (unaliased_tc->content_type());
+
+        switch (tk_content)
+          {
+            case CORBA::tk_short:
+              {
+                CORBA::ShortSeq_var lvalues(this->get_short_seq());
+                CORBA::ShortSeq_var rvalues(rhs_n->get_short_seq());
+
+                if (lvalues->length() != rvalues->length())
+                  {
+                    return 0;
+                  }
+
+                for (CORBA::ULong i = 0; i < lvalues->length(); ++i)
+                  {
+                    if (lvalues[i] != rvalues[i])
+                      return 0;
+                  }
+                return 1; // If we get to here, all was equal
+              }
+              break;
+
+            case CORBA::tk_long:
+              {
+                CORBA::LongSeq_var lvalues(this->get_long_seq());
+                CORBA::LongSeq_var rvalues(rhs_n->get_long_seq());
+
+                if (lvalues->length() != rvalues->length())
+                  {
+                    return 0;
+                  }
+
+                for (CORBA::ULong i = 0; i < lvalues->length(); ++i)
+                  {
+                    if (lvalues[i] != rvalues[i])
+                      {
+                        return 0;
+                      }
+                  }
+                return 1; // If we get to here, all was equal
+              }
+              break;
+
+            case CORBA::tk_ushort:
+              {
+                CORBA::UShortSeq_var lvalues(this->get_ushort_seq());
+                CORBA::UShortSeq_var rvalues(rhs_n->get_ushort_seq());
+
+                if (lvalues->length() != rvalues->length())
+                  {
+                    return 0;
+                  }
+
+                for (CORBA::ULong i = 0; i < lvalues->length(); ++i)
+                  {
+                    if (lvalues[i] != rvalues[i])
+                      {
+                        return 0;
+                      }
+                  }
+                return 1; // If we get to here, all was equal
+              }
+              break;
+
+            case CORBA::tk_ulong:
+              {
+                CORBA::ULongSeq_var lvalues(this->get_ulong_seq());
+                CORBA::ULongSeq_var rvalues(rhs_n->get_ulong_seq());
+
+                if (lvalues->length() != rvalues->length())
+                  {
+                    return 0;
+                  }
+
+                for (CORBA::ULong i = 0; i < lvalues->length(); ++i)
+                  {
+                    if (lvalues[i] != rvalues[i])
+                      {
+                        return 0;
+                      }
+                  }
+                return 1; // If we get to here, all was equal
+              }
+              break;
+
+            case CORBA::tk_float:
+              {
+                CORBA::FloatSeq_var lvalues(this->get_float_seq());
+                CORBA::FloatSeq_var rvalues(rhs_n->get_float_seq());
+
+                if (lvalues->length() != rvalues->length())
+                  {
+                    return 0;
+                  }
+
+                for (CORBA::ULong i = 0; i < lvalues->length(); ++i)
+                  {
+                    if (lvalues[i] != rvalues[i])
+                      {
+                        return 0;
+                      }
+                  }
+                return 1; // If we get to here, all was equal
+              }
+              break;
+
+            case CORBA::tk_double:
+              {
+                CORBA::DoubleSeq_var lvalues(this->get_double_seq());
+                CORBA::DoubleSeq_var rvalues(rhs_n->get_double_seq());
+
+                if (lvalues->length() != rvalues->length())
+                  {
+                    return 0;
+                  }
+
+                for (CORBA::ULong i = 0; i < lvalues->length(); ++i)
+                  {
+                    if (lvalues[i] != rvalues[i])
+                      {
+                        return 0;
+                      }
+                  }
+                return 1; // If we get to here, all was equal
+              }
+              break;
+
+            case CORBA::tk_longlong:
+              {
+                CORBA::LongLongSeq_var lvalues(this->get_longlong_seq());
+                CORBA::LongLongSeq_var rvalues(rhs_n->get_longlong_seq());
+
+                if (lvalues->length() != rvalues->length())
+                  {
+                    return 0;
+                  }
+
+                for (CORBA::ULong i = 0; i < lvalues->length(); ++i)
+                  {
+                    if (lvalues[i] != rvalues[i])
+                      {
+                        return 0;
+                      }
+                  }
+                return 1; // If we get to here, all was equal
+              }
+              break;
+
+            case CORBA::tk_ulonglong:
+              {
+                CORBA::ULongLongSeq_var lvalues(this->get_ulonglong_seq());
+                CORBA::ULongLongSeq_var rvalues(rhs_n->get_ulonglong_seq());
+
+                if (lvalues->length() != rvalues->length())
+                  {
+                    return 0;
+                  }
+
+                for (CORBA::ULong i = 0; i < lvalues->length(); ++i)
+                  {
+                    if (lvalues[i] != rvalues[i])
+                      {
+                        return 0;
+                      }
+                  }
+                return 1; // If we get to here, all was equal
+              }
+              break;
+
+            case CORBA::tk_boolean:
+              {
+                CORBA::BooleanSeq_var lvalues(this->get_boolean_seq());
+                CORBA::BooleanSeq_var rvalues(rhs_n->get_boolean_seq());
+
+                if (lvalues->length() != rvalues->length())
+                  {
+                    return 0;
+                  }
+
+                for (CORBA::ULong i = 0; i < lvalues->length(); ++i)
+                  {
+                    if (lvalues[i] != rvalues[i])
+                      {
+                        return 0;
+                      }
+                  }
+                return 1; // If we get to here, all was equal
+              }
+              break;
+
+            case CORBA::tk_char:
+              {
+                CORBA::CharSeq_var lvalues(this->get_char_seq());
+                CORBA::CharSeq_var rvalues(rhs_n->get_char_seq());
+
+                if (lvalues->length() != rvalues->length())
+                  {
+                    return 0;
+                  }
+
+                for (CORBA::ULong i = 0; i < lvalues->length(); ++i)
+                  {
+                    if (lvalues[i] != rvalues[i])
+                      {
+                        return 0;
+                      }
+                  }
+                return 1; // If we get to here, all was equal
+              }
+              break;
+
+            case CORBA::tk_wchar:
+              {
+                CORBA::WCharSeq_var lvalues(this->get_wchar_seq());
+                CORBA::WCharSeq_var rvalues(rhs_n->get_wchar_seq());
+
+                if (lvalues->length() != rvalues->length())
+                  {
+                    return 0;
+                  }
+
+                for (CORBA::ULong i = 0; i < lvalues->length(); ++i)
+                  {
+                    if (lvalues[i] != rvalues[i])
+                      {
+                        return 0;
+                      }
+                  }
+                return 1; // If we get to here, all was equal
+              }
+              break;
+
+            case CORBA::tk_octet:
+              {
+                CORBA::OctetSeq_var lvalues(this->get_octet_seq());
+                CORBA::OctetSeq_var rvalues(rhs_n->get_octet_seq());
+
+                if (lvalues->length() != rvalues->length())
+                  {
+                    return 0;
+                  }
+
+                for (CORBA::ULong i = 0; i < lvalues->length(); ++i)
+                  {
+                    if (lvalues[i] != rvalues[i])
+                      {
+                        return 0;
+                      }
+                  }
+                return 1; // If we get to here, all was equal
+              }
+              break;
+
+
+            case CORBA::tk_longdouble:
+              {
+                CORBA::LongDoubleSeq_var lvalues(this->get_longdouble_seq());
+                CORBA::LongDoubleSeq_var rvalues(rhs_n->get_longdouble_seq());
+
+                if (lvalues->length() != rvalues->length())
+                  {
+                    return 0;
+                  }
+
+                for (CORBA::ULong i = 0; i < lvalues->length(); ++i)
+                  {
+                    if (lvalues[i] != rvalues[i])
+                      {
+                        return 0;
+                      }
+                  }
+                return 1; // If we get to here, all was equal
+              }
+              break;
+
+            default:
+            // Should never get here
+            break;
+          }
+      }
+
+      break;
     default:
       break; // Cannot happen...
     }