Cosmetic change (rename naked pointer to raw pointer)

4 files changed, 14 insertions, 14 deletions

diff --git a/odb/cache-traits.hxx b/odb/cache-traits.hxx
index a475d35..ea8f504 100644
--- a/odb/cache-traits.hxx
+++ b/odb/cache-traits.hxx
@@ -110,7 +110,7 @@ namespace odb
   };
 
   // Caching traits for objects passed by reference. Only if the object
-  // pointer kind is naked do we add the object to the session.
+  // pointer kind is raw do we add the object to the session.
   //
   template <typename T,
             pointer_kind =
@@ -144,7 +144,7 @@ namespace odb
   };
 
   template <typename T>
-  struct reference_cache_traits<T, pk_naked>
+  struct reference_cache_traits<T, pk_raw>
   {
     typedef T element_type;
     typedef typename object_traits<element_type>::pointer_type pointer_type;
diff --git a/odb/lazy-pointer-traits.hxx b/odb/lazy-pointer-traits.hxx
index 599b051..a92ec29 100644
--- a/odb/lazy-pointer-traits.hxx
+++ b/odb/lazy-pointer-traits.hxx
@@ -17,7 +17,7 @@ namespace odb
   class pointer_traits< lazy_ptr<T> >
   {
   public:
-    static pointer_kind const kind = pk_naked;
+    static pointer_kind const kind = pk_raw;
     static bool const lazy = true;
 
     typedef T element_type;
diff --git a/odb/pointer-traits.hxx b/odb/pointer-traits.hxx
index 07cc253..2f879bb 100644
--- a/odb/pointer-traits.hxx
+++ b/odb/pointer-traits.hxx
@@ -16,7 +16,7 @@ namespace odb
 {
   enum pointer_kind
   {
-    pk_naked,  // Naked or equivalent (i.e., unmanaged).
+    pk_raw,    // Raw pointer or equivalent (i.e., unmanaged).
     pk_unique, // Smart pointer that doesn't support sharing.
     pk_shared, // Smart pointer that support sharing.
     pk_weak    // Weak counterpart for shared pointer.
@@ -29,17 +29,17 @@ namespace odb
   // Standard pointer guards.
   //
 
-  // Naked pointer guard.
+  // Raw pointer guard.
   //
   template <typename P>
-  class naked_ptr_guard
+  class raw_ptr_guard
   {
   public:
-    ~naked_ptr_guard () {delete p_;}
-    naked_ptr_guard (): p_ (0) {}
+    ~raw_ptr_guard () {delete p_;}
+    raw_ptr_guard (): p_ (0) {}
 
     explicit
-    naked_ptr_guard (P p): p_ (p) {}
+    raw_ptr_guard (P p): p_ (p) {}
 
     void
     release () {p_ = 0;}
@@ -69,21 +69,21 @@ namespace odb
     reset (const P&) {}
   };
 
-  // Specialization for naked pointers.
+  // Specialization for raw pointers.
   //
   template <typename T>
   class pointer_traits<T*>
   {
   public:
-    static pointer_kind const kind = pk_naked;
+    static pointer_kind const kind = pk_raw;
     static bool const lazy = false;
 
     typedef T element_type;
     typedef T* pointer_type;
     typedef const T* const_pointer_type;
-    typedef naked_ptr_guard<pointer_type> guard;
+    typedef raw_ptr_guard<pointer_type> guard;
 
-    // Return naked pointer to the pointed-to element, including NULL.
+    // Return raw pointer to the pointed-to element, including NULL.
     //
     static element_type*
     get_ptr (pointer_type p)
diff --git a/odb/result.hxx b/odb/result.hxx
index 0ca7db1..96b50a9 100644
--- a/odb/result.hxx
+++ b/odb/result.hxx
@@ -55,7 +55,7 @@ namespace odb
       return db_;
     }
 
-    // To make this work with all kinds of pointers (naked, std::auto_ptr,
+    // To make this work with all kinds of pointers (raw, std::auto_ptr,
     // shared), we need to make sure we don't make any copies of the
     // pointer on the return path.
     //