ChangeLogTag: Wed Jan 10 18:53:20 UTC 2007 Jeff Parsons <j.parsons@vanderbilt.edu>

4 files changed, 286 insertions, 170 deletions

diff --git a/TAO/ChangeLog b/TAO/ChangeLog
index 74f900df4c4..15be3ee7d41 100644
--- a/TAO/ChangeLog
+++ b/TAO/ChangeLog
@@ -1,3 +1,20 @@
+Wed Jan 10 18:53:20 UTC 2007  Jeff Parsons <j.parsons@vanderbilt.edu>
+
+        * tao/DynamicAny/DynAnyUtils_T.cpp:
+        
+          New file, containing the implementation formerly in the
+          header file.
+          
+        * tao/DynamicAny/DynAnyUtils_T.h:
+        
+          Factored out the method bodies and put them in the new file
+          above.
+          
+        * tao/DynamicAny.mpc:
+        
+          Added the new file above explicitly in the Template_Files
+          block, also listed explicitly the rest of the .cpp files.
+
 Wed Jan 10 18:51:20 UTC 2007  Chad Elliott  <elliott_c@ociweb.com>
 
         * NEWS:
diff --git a/TAO/tao/DynamicAny.mpc b/TAO/tao/DynamicAny.mpc
index daece37b93e..b3c5c5de32c 100644
--- a/TAO/tao/DynamicAny.mpc
+++ b/TAO/tao/DynamicAny.mpc
@@ -5,7 +5,19 @@ project : install, valuetype, tao_versioning_idl_defaults {
   dynamicflags  = TAO_DYNAMICANY_BUILD_DLL
 
   Source_Files {
-    DynamicAny
+    DynamicAny/DynamicAny.cpp
+    DynamicAny/DynamicAnyC.cpp
+    DynamicAny/DynAny_i.cpp
+    DynamicAny/DynAnyFactory.cpp
+    DynamicAny/DynArray_i.cpp
+    DynamicAny/DynCommon.cpp
+    DynamicAny/DynEnum_i.cpp
+    DynamicAny/DynSequence_i.cpp
+    DynamicAny/DynStruct_i.cpp
+    DynamicAny/DynUnion_i.cpp
+    DynamicAny/DynValue_i.cpp
+    DynamicAny/DynValueBox_i.cpp
+    DynamicAny/DynValueCommon_i.cpp
   }
 
   Header_Files {
@@ -17,7 +29,7 @@ project : install, valuetype, tao_versioning_idl_defaults {
   }
 
   Template_Files {
-    DynamicAny
+    DynamicAny/DynAnyUtils_T.cpp
   }
 
   Resource_Files {
diff --git a/TAO/tao/DynamicAny/DynAnyUtils_T.cpp b/TAO/tao/DynamicAny/DynAnyUtils_T.cpp
new file mode 100644
index 00000000000..c7bb3c41ad7
--- /dev/null
+++ b/TAO/tao/DynamicAny/DynAnyUtils_T.cpp
@@ -0,0 +1,223 @@
+// -*- C++ -*-
+
+//=============================================================================
+/**
+ *  @file    DynAnyUtils_T.cpp
+ *
+ *  $Id$
+ *
+ *  Implementation of templatized common code used in Dynamic Any
+ *
+ *  @author Jeff Parsons <j.parsons@vanderbilt.edu>
+ */
+//=============================================================================
+
+#ifndef TAO_DYNANYUTILS_T_CPP
+#define TAO_DYNANYUTILS_T_CPP
+
+#include "tao/DynamicAny/DynAnyUtils_T.h"
+
+#include "tao/DynamicAny/DynAny_i.h"
+#include "tao/DynamicAny/DynArray_i.h"
+#include "tao/DynamicAny/DynEnum_i.h"
+#include "tao/DynamicAny/DynSequence_i.h"
+#include "tao/DynamicAny/DynStruct_i.h"
+#include "tao/DynamicAny/DynUnion_i.h"
+
+TAO_BEGIN_VERSIONED_NAMESPACE_DECL
+
+namespace TAO
+{
+  template<typename T>
+  void
+  DynAnyBasicTypeUtils<T>::insert_value (const T &val,
+                                         TAO_DynCommon *the_dynany)
+    ACE_THROW_SPEC ((
+        CORBA::SystemException,
+        DynamicAny::DynAny::TypeMismatch,
+        DynamicAny::DynAny::InvalidValue
+      ))
+  {
+    if (the_dynany->destroyed ())
+      {
+        ACE_THROW (CORBA::OBJECT_NOT_EXIST ());
+      }
+
+    if (the_dynany->has_components ())
+      {
+        DynamicAny::DynAny_var cc = the_dynany->check_component ();
+        TAO_DynCommon *dc = dynamic_cast<TAO_DynCommon *> (cc.in ());
+        DynAnyBasicTypeUtils<T>::insert_value (val, dc);
+      }
+    else
+      {
+        the_dynany->check_type (BasicTypeTraits<T>::tc_value);
+        CORBA::Any &my_any = the_dynany->the_any ();
+        typedef typename TAO::BasicTypeTraits<T>::insert_type i_type;
+        i_type insert_arg (val);
+        my_any <<= insert_arg;
+      }
+  }
+  
+  template<typename T>
+  typename BasicTypeTraits<T>::return_type
+  DynAnyBasicTypeUtils<T>::get_value (TAO_DynCommon *the_dynany)
+    ACE_THROW_SPEC ((
+        CORBA::SystemException,
+        DynamicAny::DynAny::TypeMismatch,
+        DynamicAny::DynAny::InvalidValue
+      ))
+  {
+    if (the_dynany->destroyed ())
+      {
+        ACE_THROW_RETURN (CORBA::OBJECT_NOT_EXIST (),
+                          BasicTypeTraits<T>::return_type ());
+      }
+
+    if (the_dynany->has_components ())
+      {
+        DynamicAny::DynAny_var cc = the_dynany->check_component ();
+        TAO_DynCommon *dc = dynamic_cast<TAO_DynCommon *> (cc.in ());
+        return DynAnyBasicTypeUtils<T>::get_value (dc);
+      }
+    else
+      {
+        typedef typename BasicTypeTraits<T>::return_type ret_type;
+        typedef typename BasicTypeTraits<T>::extract_type ext_type;
+        ret_type retval = ret_type ();
+        ext_type extval (retval);
+        const CORBA::Any &my_any = the_dynany->the_any ();
+
+        if (!(my_any >>= extval))
+          {
+            ACE_THROW_RETURN (DynamicAny::DynAny::TypeMismatch (),
+                              BasicTypeTraits<T>::return_type ());
+          }
+
+        return BasicTypeTraits<T>::convert (extval);
+      }
+  }
+
+  template<typename T>
+  void
+  DynAnyFlagUtils<T>::set_flag_t (DynamicAny::DynAny_ptr component,
+                                  CORBA::Boolean destroying)
+    ACE_THROW_SPEC ((
+        CORBA::SystemException
+      ))
+  {
+    T *tmp = T::_narrow (component);
+
+    if (destroying)
+      {
+        tmp->container_is_destroying (true);
+      }
+    else
+      {
+        tmp->ref_to_component (true);
+      }
+  }
+
+  template<typename DA_IMPL, typename ANY_TC>
+  DynamicAny::DynAny_ptr
+  CreateDynAnyUtils<DA_IMPL, ANY_TC>::create_dyn_any_t (ANY_TC any_tc)
+  {
+    DA_IMPL *p = 0;
+    ACE_NEW_THROW_EX (p,
+                      DA_IMPL,
+                      CORBA::NO_MEMORY ());
+
+    ACE_Auto_Basic_Ptr<DA_IMPL> dp (p);
+    p->init (any_tc);
+
+    return dp.release ();
+  }
+
+  template<typename ANY_TC>
+  DynamicAny::DynAny_ptr
+  MakeDynAnyUtils<ANY_TC>::make_dyn_any_t (CORBA::TypeCode_ptr tc,
+                                           ANY_TC any_tc)
+  {
+    switch (TAO_DynAnyFactory::unalias (tc))
+      {
+        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:
+          return
+            CreateDynAnyUtils<
+              TAO_DynAny_i,
+              ANY_TC>::create_dyn_any_t (any_tc);
+        case CORBA::tk_struct:
+        case CORBA::tk_except:
+          return
+            CreateDynAnyUtils<
+              TAO_DynStruct_i,
+              ANY_TC>::create_dyn_any_t (any_tc);
+        case CORBA::tk_sequence:
+          if (TAO_DynCommon::is_basic_type_seq (tc))
+            {
+              return
+                CreateDynAnyUtils<
+                  TAO_DynAny_i,
+                  ANY_TC>::create_dyn_any_t (any_tc);
+            }
+          else
+            {
+              return
+                CreateDynAnyUtils<
+                  TAO_DynSequence_i,
+                  ANY_TC>::create_dyn_any_t (any_tc);
+            }
+        case CORBA::tk_union:
+          return
+            CreateDynAnyUtils<
+              TAO_DynUnion_i,
+              ANY_TC>::create_dyn_any_t (any_tc);
+        case CORBA::tk_enum:
+          return
+            CreateDynAnyUtils<
+              TAO_DynEnum_i,
+              ANY_TC>::create_dyn_any_t (any_tc);
+        case CORBA::tk_array:
+          return
+            CreateDynAnyUtils<
+              TAO_DynArray_i,
+              ANY_TC>::create_dyn_any_t (any_tc);
+      case CORBA::tk_fixed:
+      case CORBA::tk_value:
+      case CORBA::tk_value_box:
+      case CORBA::tk_abstract_interface:
+      case CORBA::tk_component:
+      case CORBA::tk_home:
+        ACE_THROW_RETURN (CORBA::NO_IMPLEMENT (),
+                          DynamicAny::DynAny::_nil ());
+      case CORBA::tk_native:
+        ACE_THROW_RETURN (DynamicAny::DynAnyFactory::InconsistentTypeCode (),
+                          DynamicAny::DynAny::_nil ());
+      default:
+        break;
+      }
+
+    return DynamicAny::DynAny::_nil ();
+  }
+}
+
+TAO_END_VERSIONED_NAMESPACE_DECL
+
+#endif /* TAO_DYNANYUTILS_T_CPP */
\ No newline at end of file
diff --git a/TAO/tao/DynamicAny/DynAnyUtils_T.h b/TAO/tao/DynamicAny/DynAnyUtils_T.h
index 08742ad5d00..26b4fca2a0b 100644
--- a/TAO/tao/DynamicAny/DynAnyUtils_T.h
+++ b/TAO/tao/DynamicAny/DynAnyUtils_T.h
@@ -6,24 +6,29 @@
  *
  *  $Id$
  *
- *  Collection of templatized common code used in Dynamic Any
+ *  Declaration of templatized common code used in Dynamic Any
  *
  *  @author Jeff Parsons <j.parsons@vanderbilt.edu>
  */
 //=============================================================================
 
-#include "tao/DynamicAny/DynAny_i.h"
-#include "tao/DynamicAny/DynArray_i.h"
-#include "tao/DynamicAny/DynEnum_i.h"
-#include "tao/DynamicAny/DynSequence_i.h"
-#include "tao/DynamicAny/DynStruct_i.h"
-#include "tao/DynamicAny/DynUnion_i.h"
-#include "tao/DynamicAny/DynAnyFactory.h"
+#ifndef TAO_DYNANYUTILS_T_H
+#define TAO_DYNANYUTILS_T_H
+
+#include /**/ "ace/pre.h"
+
+#include "tao/DynamicAny/DynamicAny.h"
+
+#if !defined (ACE_LACKS_PRAGMA_ONCE)
+# pragma once
+#endif /* ACE_LACKS_PRAGMA_ONCE */
 
 #include "tao/AnyTypeCode/BasicTypeTraits.h"
 
 TAO_BEGIN_VERSIONED_NAMESPACE_DECL
 
+class TAO_DynCommon;
+
 namespace TAO
 {
   // Encapsulates common code for inserting and extracting basic
@@ -38,66 +43,15 @@ namespace TAO
           CORBA::SystemException,
           DynamicAny::DynAny::TypeMismatch,
           DynamicAny::DynAny::InvalidValue
-        ))
-    {
-      if (the_dynany->destroyed ())
-        {
-          ACE_THROW (CORBA::OBJECT_NOT_EXIST ());
-        }
-
-      if (the_dynany->has_components ())
-        {
-          DynamicAny::DynAny_var cc = the_dynany->check_component ();
-          TAO_DynCommon *dc = dynamic_cast<TAO_DynCommon *> (cc.in ());
-          TAO::DynAnyBasicTypeUtils<T>::insert_value (val, dc);
-        }
-      else
-        {
-          the_dynany->check_type (TAO::BasicTypeTraits<T>::tc_value);
-          CORBA::Any &my_any = the_dynany->the_any ();
-          typedef typename TAO::BasicTypeTraits<T>::insert_type i_type;
-          i_type insert_arg (val);
-          my_any <<= insert_arg;
-        }
-    }
-
-    static typename TAO::BasicTypeTraits<T>::return_type
+        ));
+
+    static typename BasicTypeTraits<T>::return_type
     get_value (TAO_DynCommon *the_dynany)
       ACE_THROW_SPEC ((
           CORBA::SystemException,
           DynamicAny::DynAny::TypeMismatch,
           DynamicAny::DynAny::InvalidValue
-        ))
-    {
-      if (the_dynany->destroyed ())
-        {
-          ACE_THROW_RETURN (CORBA::OBJECT_NOT_EXIST (),
-                            TAO::BasicTypeTraits<T>::return_type ());
-        }
-
-      if (the_dynany->has_components ())
-        {
-          DynamicAny::DynAny_var cc = the_dynany->check_component ();
-          TAO_DynCommon *dc = dynamic_cast<TAO_DynCommon *> (cc.in ());
-          return TAO::DynAnyBasicTypeUtils<T>::get_value (dc);
-        }
-      else
-        {
-          typedef typename TAO::BasicTypeTraits<T>::return_type ret_type;
-          typedef typename TAO::BasicTypeTraits<T>::extract_type ext_type;
-          ret_type retval = ret_type ();
-          ext_type extval (retval);
-          const CORBA::Any &my_any = the_dynany->the_any ();
-
-          if (!(my_any >>= extval))
-            {
-              ACE_THROW_RETURN (DynamicAny::DynAny::TypeMismatch (),
-                                TAO::BasicTypeTraits<T>::return_type ());
-            }
-
-          return TAO::BasicTypeTraits<T>::convert (extval);
-        }
-    }
+        ));
   };
 
   // Encapsulates code that would otherwise be repeated in
@@ -111,19 +65,7 @@ namespace TAO
                 CORBA::Boolean destroying)
       ACE_THROW_SPEC ((
           CORBA::SystemException
-        ))
-    {
-      T *tmp = T::_narrow (component);
-
-      if (destroying)
-        {
-          tmp->container_is_destroying (true);
-        }
-      else
-        {
-          tmp->ref_to_component (true);
-        }
-    }
+        ));
   };
 
   // Used by MakeDynAnyUtils below, parameterized on the type of
@@ -132,18 +74,7 @@ namespace TAO
   struct CreateDynAnyUtils
   {
     static DynamicAny::DynAny_ptr
-    create_dyn_any_t (ANY_TC any_tc)
-    {
-      DA_IMPL *p = 0;
-      ACE_NEW_THROW_EX (p,
-                        DA_IMPL,
-                        CORBA::NO_MEMORY ());
-
-      ACE_Auto_Basic_Ptr<DA_IMPL> dp (p);
-      p->init (any_tc);
-
-      return dp.release ();
-    }
+    create_dyn_any_t (ANY_TC any_tc);
   };
 
   // Code common to DynAnyFactory create_* calls, parameterized on
@@ -152,87 +83,20 @@ namespace TAO
   struct MakeDynAnyUtils
   {
     static DynamicAny::DynAny_ptr
-    make_dyn_any_t (CORBA::TypeCode_ptr tc, ANY_TC any_tc)
-    {
-      switch (TAO_DynAnyFactory::unalias (tc))
-        {
-          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:
-            return
-              TAO::CreateDynAnyUtils<
-                TAO_DynAny_i,
-                ANY_TC>::create_dyn_any_t (any_tc);
-          case CORBA::tk_struct:
-          case CORBA::tk_except:
-            return
-              TAO::CreateDynAnyUtils<
-                TAO_DynStruct_i,
-                ANY_TC>::create_dyn_any_t (any_tc);
-          case CORBA::tk_sequence:
-            if (TAO_DynCommon::is_basic_type_seq (tc))
-              {
-                return
-                  TAO::CreateDynAnyUtils<
-                    TAO_DynAny_i,
-                    ANY_TC>::create_dyn_any_t (any_tc);
-              }
-            else
-              {
-                return
-                  TAO::CreateDynAnyUtils<
-                    TAO_DynSequence_i,
-                    ANY_TC>::create_dyn_any_t (any_tc);
-              }
-          case CORBA::tk_union:
-            return
-              TAO::CreateDynAnyUtils<
-                TAO_DynUnion_i,
-                ANY_TC>::create_dyn_any_t (any_tc);
-          case CORBA::tk_enum:
-            return
-              TAO::CreateDynAnyUtils<
-                TAO_DynEnum_i,
-                ANY_TC>::create_dyn_any_t (any_tc);
-          case CORBA::tk_array:
-            return
-              TAO::CreateDynAnyUtils<
-                TAO_DynArray_i,
-                ANY_TC>::create_dyn_any_t (any_tc);
-        case CORBA::tk_fixed:
-        case CORBA::tk_value:
-        case CORBA::tk_value_box:
-        case CORBA::tk_abstract_interface:
-        case CORBA::tk_component:
-        case CORBA::tk_home:
-          ACE_THROW_RETURN (CORBA::NO_IMPLEMENT (),
-                            DynamicAny::DynAny::_nil ());
-        case CORBA::tk_native:
-          ACE_THROW_RETURN (DynamicAny::DynAnyFactory::InconsistentTypeCode (),
-                            DynamicAny::DynAny::_nil ());
-        default:
-          break;
-        }
-
-      return DynamicAny::DynAny::_nil ();
-    }
+    make_dyn_any_t (CORBA::TypeCode_ptr tc, ANY_TC any_tc);
   };
 }
 
 TAO_END_VERSIONED_NAMESPACE_DECL
+
+#if defined (ACE_TEMPLATES_REQUIRE_SOURCE)
+#include "tao/DynamicAny/DynanyUtils_T.cpp"
+#endif /* ACE_TEMPLATES_REQUIRE_SOURCE */
+
+#if defined (ACE_TEMPLATES_REQUIRE_PRAGMA)
+#pragma implementation ("tao/DynamicAny/DynAnyUtils_T.cpp")
+#endif /* ACE_TEMPLATES_REQUIRE_PRAGMA */
+
+#include /**/ "ace/post.h"
+
+#endif /* TAO_DYNANYUTILS_T_H */
\ No newline at end of file