AbstractBase.*

1 files changed, 171 insertions, 168 deletions

diff --git a/TAO/tao/LocalObject.h b/TAO/tao/LocalObject.h
index e4af9361a1a..d8b1f52d2fd 100644
--- a/TAO/tao/LocalObject.h
+++ b/TAO/tao/LocalObject.h
@@ -28,220 +28,222 @@
 # pragma once
 #endif /* ACE_LACKS_PRAGMA_ONCE */
 
-/**
- * @class CORBA_LocalObject
- *
- * @note NW: It is not clear whether minimum CORBA should support
- * LocalObject or not.  I think it should.
- */
-class TAO_Export CORBA_LocalObject : public virtual CORBA_Object
+namespace CORBA
 {
-public:
+  /**
+   * @class LocalObject
+   *
+   * @note NW: It is not clear whether minimum CORBA should support
+   * LocalObject or not.  I think it should.
+   */
+  class TAO_Export LocalObject : public virtual CORBA::Object
+  {
+  public:
 
-  /// Destructor
-  virtual ~CORBA_LocalObject (void);
+    /// Destructor
+    virtual ~LocalObject (void);
 
-  /// Increment the ref count
-  static CORBA_LocalObject_ptr _duplicate (CORBA_LocalObject_ptr obj);
+    /// Increment the ref count
+    static LocalObject_ptr _duplicate (LocalObject_ptr obj);
 
-  /// Return a NIL object
-  static CORBA_LocalObject_ptr _nil (void);
+    /// Return a NIL object
+    static LocalObject_ptr _nil (void);
 
-  /**
-   * @@ Narrowing a CORBA_LocalObject to a CORBA_Object is broken
-   * right now.  The solution seems to be making CORBA_Object an
-   * abstract base class and create a CORBA_RemoteObject for regular
-   * object.  Or, even easier, add a <is_local> member into
-   * CORBA_Object.  I'll take the easier route for now.
-   */
-  static CORBA_LocalObject_ptr _narrow (CORBA::Object_ptr obj
-                                        ACE_ENV_ARG_DECL_WITH_DEFAULTS);
+    /**
+     * @todo Narrowing a LocalObject to a CORBA::Object is broken
+     * right now.  The solution seems to be making CORBA::Object an
+     * abstract base class and create a CORBA::RemoteObject for
+     * regular object.  Or, even easier, add a @c is_local member into
+     * CORBA::Object.  I'll take the easier route for now.
+     */
+    static LocalObject_ptr _narrow (CORBA::Object_ptr obj
+                                    ACE_ENV_ARG_DECL_WITH_DEFAULTS);
 
-  /// No-op it is just here to simplify some templates.
-  static CORBA_LocalObject_ptr _unchecked_narrow (
-             CORBA::Object_ptr obj
-             ACE_ENV_ARG_DECL_WITH_DEFAULTS);
+    /// No-op it is just here to simplify some templates.
+    static LocalObject_ptr _unchecked_narrow (CORBA::Object_ptr obj
+                                              ACE_ENV_ARG_DECL_WITH_DEFAULTS);
 
 #if (TAO_HAS_MINIMUM_CORBA == 0)
 
-  /// Always returns false.
-  virtual CORBA::Boolean _non_existent (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS);
-
-  /// Throws CORBA::NO_IMPLEMENT.
-  virtual CORBA::ImplementationDef_ptr
-      _get_implementation (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS);
-
-  /// Gets info about object from the Interface Repository.
-  virtual CORBA_InterfaceDef_ptr _get_interface (
-      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
-    );
+    /// Always returns false.
+    virtual CORBA::Boolean _non_existent (
+      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS);
 
-  /// Throws NO_IMPLEMENT.
-  virtual CORBA::Object_ptr _get_component (
+    /// Throws CORBA::NO_IMPLEMENT.
+    virtual CORBA::ImplementationDef_ptr _get_implementation (
       ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS);
 
-  virtual void _create_request (CORBA::Context_ptr ctx,
-                                const CORBA::Char *operation,
-                                CORBA::NVList_ptr arg_list,
-                                CORBA::NamedValue_ptr result,
-                                CORBA::Request_ptr &request,
-                                CORBA::Flags req_flags
-                                ACE_ENV_ARG_DECL_WITH_DEFAULTS);
+    /// Gets info about object from the Interface Repository.
+    virtual CORBA::InterfaceDef_ptr _get_interface (
+      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS);
 
-  virtual void _create_request (CORBA::Context_ptr ctx,
-                                const CORBA::Char *operation,
-                                CORBA::NVList_ptr arg_list,
-                                CORBA::NamedValue_ptr result,
-                                CORBA::ExceptionList_ptr exclist,
-                                CORBA::ContextList_ptr ctxtlist,
-                                CORBA::Request_ptr &request,
-                                CORBA::Flags req_flags
-                                ACE_ENV_ARG_DECL_WITH_DEFAULTS);
+    /// Throws NO_IMPLEMENT.
+    virtual CORBA::Object_ptr _get_component (
+      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS);
 
-  /// Throws NO_IMPLEMENT.
-  virtual CORBA::Request_ptr _request (const CORBA::Char *operation
-                                       ACE_ENV_ARG_DECL_WITH_DEFAULTS);
+    virtual void _create_request (CORBA::Context_ptr ctx,
+                                  const char *operation,
+                                  CORBA::NVList_ptr arg_list,
+                                  CORBA::NamedValue_ptr result,
+                                  CORBA::Request_ptr &request,
+                                  CORBA::Flags req_flags
+                                  ACE_ENV_ARG_DECL_WITH_DEFAULTS);
+
+    virtual void _create_request (CORBA::Context_ptr ctx,
+                                  const char *operation,
+                                  CORBA::NVList_ptr arg_list,
+                                  CORBA::NamedValue_ptr result,
+                                  CORBA::ExceptionList_ptr exclist,
+                                  CORBA::ContextList_ptr ctxtlist,
+                                  CORBA::Request_ptr &request,
+                                  CORBA::Flags req_flags
+                                  ACE_ENV_ARG_DECL_WITH_DEFAULTS);
+
+    /// Throws NO_IMPLEMENT.
+    virtual CORBA::Request_ptr _request (const char *operation
+                                         ACE_ENV_ARG_DECL_WITH_DEFAULTS);
 
 #endif /* TAO_HAS_MINIMUM_CORBA */
 
 #if (TAO_HAS_CORBA_MESSAGING == 1)
 
-  /// Throws CORBA::NO_IMPLEMENT.
-  CORBA::Policy_ptr _get_policy (
-      CORBA::PolicyType type
-      ACE_ENV_ARG_DECL_WITH_DEFAULTS);
-
-
-  /// Throws CORBA::NO_IMPLEMENT.
-  CORBA::Policy_ptr _get_client_policy (
-      CORBA::PolicyType type
-      ACE_ENV_ARG_DECL_WITH_DEFAULTS);
+    /// Throws CORBA::NO_IMPLEMENT.
+    CORBA::Policy_ptr _get_policy (CORBA::PolicyType type
+                                   ACE_ENV_ARG_DECL_WITH_DEFAULTS);
 
+    /// Throws CORBA::NO_IMPLEMENT.
+    CORBA::Policy_ptr _get_client_policy (CORBA::PolicyType type
+                                          ACE_ENV_ARG_DECL_WITH_DEFAULTS);
 
-  /// Throws CORBA::NO_IMPLEMENT.
-  CORBA::Object_ptr _set_policy_overrides (
+    /// Throws CORBA::NO_IMPLEMENT.
+    CORBA::Object_ptr _set_policy_overrides (
       const CORBA::PolicyList & policies,
       CORBA::SetOverrideType set_add
       ACE_ENV_ARG_DECL_WITH_DEFAULTS);
 
-
-  /// Throws CORBA::NO_IMPLEMENT.
-  CORBA::PolicyList * _get_policy_overrides (
+    /// Throws CORBA::NO_IMPLEMENT.
+    CORBA::PolicyList * _get_policy_overrides (
       const CORBA::PolicyTypeSeq & types
       ACE_ENV_ARG_DECL_WITH_DEFAULTS);
 
-
-  /// Throws CORBA::NO_IMPLEMENT.
-  CORBA::Boolean _validate_connection (
+    /// Throws CORBA::NO_IMPLEMENT.
+    CORBA::Boolean _validate_connection (
       CORBA::PolicyList_out inconsistent_policies
       ACE_ENV_ARG_DECL_WITH_DEFAULTS);
 
-
 #endif /* TAO_HAS_CORBA_MESSAGING == 1 */
 
-  /**
-   * Return a hash value for this object.  The hash is based on the
-   * address of the object.  On non-32 bit platforms, the hash may be
-   * non-unique.
-   */
-  virtual CORBA::ULong _hash (CORBA::ULong maximum
-                              ACE_ENV_ARG_DECL_WITH_DEFAULTS);
+    /**
+     * Return a hash value for this object.  The hash is based on the
+     * address of the object.  On non-32 bit platforms, the hash may
+     * be non-unique.
+     */
+    virtual CORBA::ULong _hash (CORBA::ULong maximum
+                                ACE_ENV_ARG_DECL_WITH_DEFAULTS);
 
-  /**
-   * Try to determine if this object is the same as <other_obj>.  This
-   * method relies on the representation of the object reference's
-   * private state.  Since that changes easily (when different ORB
-   * protocols are in use) there is no default implementation.
-   */
-  virtual CORBA::Boolean _is_equivalent (CORBA_Object_ptr other_obj
-                                         ACE_ENV_ARG_DECL_WITH_DEFAULTS)
-    ACE_THROW_SPEC (());
+    /**
+     * Try to determine if this object is the same as @c other_obj.
+     * This method relies on the representation of the object
+     * reference's private state.  Since that changes easily (when
+     * different ORB protocols are in use) there is no default
+     * implementation.
+     */
+    virtual CORBA::Boolean _is_equivalent (CORBA::Object_ptr other_obj
+                                           ACE_ENV_ARG_DECL_WITH_DEFAULTS)
+      ACE_THROW_SPEC (());
 
-  // = Reference count managment.
-  /// Increment the reference count.
-  virtual void _add_ref (void);
+    // = Reference count managment.
+    /// Increment the reference count.
+    virtual void _add_ref (void);
 
-  /// Decrement the reference count.
-  virtual void _remove_ref (void);
+    /// Decrement the reference count.
+    virtual void _remove_ref (void);
 
-  // = TAO extensions
+    // = TAO extensions
 
-  /// Throws CORBA::NO_IMPLEMENT.
-  virtual TAO_ObjectKey *_key (ACE_ENV_SINGLE_ARG_DECL);
+    /// Throws CORBA::NO_IMPLEMENT.
+    virtual TAO_ObjectKey *_key (ACE_ENV_SINGLE_ARG_DECL);
 
 #if !defined(__GNUC__) || __GNUC__ > 2 || __GNUC_MINOR__ >= 8
-  /// Useful for template programming.
-  typedef CORBA_LocalObject_ptr _ptr_type;
-  typedef CORBA_LocalObject_var _var_type;
+    /// Useful for template programming.
+    typedef LocalObject_ptr _ptr_type;
+    typedef LocalObject_var _var_type;
 #endif /* __GNUC__ */
 
-protected:
-
-  /// Default constructor.
-  /**
-   * Make it protected to prevent instantiation of this class.
-   */
-  CORBA_LocalObject (void);
-
-private:
-
-  /**
-   * @name Unimplemented methods
-   */
-  //@{
-  CORBA_LocalObject (const CORBA_LocalObject &);
-  CORBA_LocalObject &operator = (const CORBA_LocalObject &);
-  //@}
-
-};
-
-class TAO_Export CORBA_LocalObject_var
-{
-public:
-  CORBA_LocalObject_var (void); // default constructor
-  CORBA_LocalObject_var (CORBA_LocalObject_ptr);
-  CORBA_LocalObject_var (const CORBA_LocalObject_var &); // copy constructor
-  ~CORBA_LocalObject_var (void); // destructor
-
-  CORBA_LocalObject_var &operator= (CORBA_LocalObject_ptr);
-  CORBA_LocalObject_var &operator= (const CORBA_LocalObject_var &);
-  CORBA_LocalObject_ptr operator-> (void) const;
-
-  /// in, inout, out, _retn
-  operator const CORBA_LocalObject_ptr &() const;
-  operator CORBA_LocalObject_ptr &();
-  CORBA_LocalObject_ptr in (void) const;
-  CORBA_LocalObject_ptr &inout (void);
-  CORBA_LocalObject_ptr &out (void);
-  CORBA_LocalObject_ptr _retn (void);
-  CORBA_LocalObject_ptr ptr (void) const;
-
-private:
-  CORBA_LocalObject_ptr ptr_;
-};
-
-class TAO_Export CORBA_LocalObject_out
-{
-public:
-  CORBA_LocalObject_out (CORBA_LocalObject_ptr &);
-  CORBA_LocalObject_out (CORBA_LocalObject_var &);
-  CORBA_LocalObject_out (const CORBA_LocalObject_out &);
-  CORBA_LocalObject_out &operator= (const CORBA_LocalObject_out &);
-  CORBA_LocalObject_out &operator= (const CORBA_LocalObject_var &);
-  CORBA_LocalObject_out &operator= (CORBA_LocalObject_ptr);
-  operator CORBA_LocalObject_ptr &();
-  CORBA_LocalObject_ptr &ptr (void);
-  CORBA_LocalObject_ptr operator-> (void);
-
-private:
-  CORBA_LocalObject_ptr &ptr_;
-};
+  protected:
+
+    /// Default constructor.
+    /**
+     * Make it protected to prevent instantiation of this class.
+     */
+    LocalObject (void);
+
+  private:
+
+    /**
+     * @name Unimplemented methods
+     */
+    //@{
+    LocalObject (const LocalObject &);
+    LocalObject &operator = (const LocalObject &);
+    //@}
+
+  };
+
+  class TAO_Export LocalObject_var
+  {
+  public:
+    LocalObject_var (void); // default constructor
+    LocalObject_var (LocalObject_ptr);
+    LocalObject_var (const LocalObject_var &); // copy constructor
+    ~LocalObject_var (void); // destructor
+
+    LocalObject_var &operator= (LocalObject_ptr);
+    LocalObject_var &operator= (const LocalObject_var &);
+    LocalObject_ptr operator-> (void) const;
+
+    /// in, inout, out, _retn
+    operator const LocalObject_ptr &() const;
+    operator LocalObject_ptr &();
+    LocalObject_ptr in (void) const;
+    LocalObject_ptr &inout (void);
+    LocalObject_ptr &out (void);
+    LocalObject_ptr _retn (void);
+    LocalObject_ptr ptr (void) const;
+
+  private:
+    LocalObject_ptr ptr_;
+  };
+
+  class TAO_Export LocalObject_out
+  {
+  public:
+    LocalObject_out (LocalObject_ptr &);
+    LocalObject_out (LocalObject_var &);
+    LocalObject_out (const LocalObject_out &);
+    LocalObject_out &operator= (const LocalObject_out &);
+    LocalObject_out &operator= (const LocalObject_var &);
+    LocalObject_out &operator= (LocalObject_ptr);
+    operator LocalObject_ptr &();
+    LocalObject_ptr &ptr (void);
+    LocalObject_ptr operator-> (void);
+
+  private:
+    LocalObject_ptr &ptr_;
+  };
+}   // End CORBA namespace
 
 /**
  * @class TAO_Local_RefCounted_Object
- This class adds default reference counting to local objects.
+ *
+ * @brief This class adds default reference counting to local
+ *        objects.
+ *
+ * This is proprietary convenience class that implements reference
+ * counting in locality constrained objects.
  */
-class TAO_Export TAO_Local_RefCounted_Object : public virtual CORBA_LocalObject
+class TAO_Export TAO_Local_RefCounted_Object
+  : public virtual CORBA::LocalObject
 {
 public:
 
@@ -279,6 +281,7 @@ protected:
 
 };
 
+
 #if defined (__ACE_INLINE__)
 # include "LocalObject.i"
 #endif /* __ACE_INLINE__ */