diff --git a/include/loki/LockingPtr.h b/include/loki/LockingPtr.h
index e1af7ba..363329e 100755
--- a/include/loki/LockingPtr.h
+++ b/include/loki/LockingPtr.h
@@ -19,6 +19,20 @@
 namespace Loki
 {
 
+    template<class T>
+    struct NonConstObject
+    {
+        typedef T Type;
+    };
+
+    template<class T>
+    struct ConstObject
+    {
+        typedef const T Type;
+    };
+
+
+
     /** @class LockingPtr
      Locks a volatile object and casts away volatility so that the object
      can be safely used in a single-threaded region of code.
@@ -27,16 +41,19 @@ namespace Loki
      the mutex type as a LockingPolicy class.  The only requirements for a
      LockingPolicy class are to provide Lock and Unlock methods.
      */
-    template < typename SharedObject, typename LockingPolicy = Loki::Mutex >
+    template < typename SharedObject, typename LockingPolicy = Loki::Mutex, 
+               template<class> class ConstPolicy = NonConstObject >
     class LockingPtr
     {
     public:
 
+        typedef typename ConstPolicy<SharedObject>::Type ConstOrNotType;
+
         /** Constructor locks mutex associated with an object.
          @param obj Reference to object.
          @param mtx Mutex used to control thread access to object.
          */
-        LockingPtr( volatile SharedObject & object, LockingPolicy & mutex )
+        LockingPtr( volatile ConstOrNotType & object, LockingPolicy & mutex )
            : pObject_( const_cast< SharedObject * >( &object ) ),
             pMutex_( &mutex )
         {
@@ -50,13 +67,13 @@ namespace Loki
         }
 
         /// Star-operator dereferences pointer.
-        SharedObject & operator * ()
+        ConstOrNotType & operator * ()
         {
             return *pObject_;
         }
 
         /// Point-operator returns pointer to object.
-        SharedObject * operator -> ()
+        ConstOrNotType * operator -> ()
         {
             return pObject_;
         }
@@ -73,13 +90,23 @@ namespace Loki
         LockingPtr & operator = ( const LockingPtr & );
 
         /// Pointer to the shared object.
-        SharedObject * pObject_;
+        ConstOrNotType * pObject_;
 
         /// Pointer to the mutex.
         LockingPolicy * pMutex_;
 
     }; // end class LockingPtr
 
+
+    template<typename SharedObject,    typename LockingPolicy = Mutex>
+    struct Locking
+    {
+        typedef LockingPtr<SharedObject, LockingPolicy, NonConstObject> Ptr;
+        typedef LockingPtr<SharedObject, LockingPolicy, ConstObject>    ConstPtr;
+    };
+
+
+#if 0
     /** @class ConstLockingPtr
      Similar to LockingPtr, except that it returns pointers and references to
      a const SharedObject instead of a mutuable SharedObject.
@@ -138,12 +165,19 @@ namespace Loki
         LockingPolicy * pMutex_;
 
     }; // end class ConstLockingPtr
+#endif
+
 
 } // namespace Loki
 
 #endif  // end file guardian
 
+
+
 // $Log$
+// Revision 1.6  2006/01/21 14:09:09  syntheticpp
+// replace LockPtr/ConstLockPtr implementation with a template policy based one
+//
 // Revision 1.5  2006/01/21 01:02:12  rich_sposato
 // Added Mutex class to Loki.  Made it the default policy class for locking.
 //
diff --git a/test/LockingPtr/LockingPtr.vcproj b/test/LockingPtr/LockingPtr.vcproj
index 1c3dac9..45df12c 100755
--- a/test/LockingPtr/LockingPtr.vcproj
+++ b/test/LockingPtr/LockingPtr.vcproj
@@ -206,10 +206,6 @@
 				RelativePath="..\..\include\loki\HierarchyGenerators.h"
 				>
 			</File>
-			<File
-				RelativePath="..\..\include\loki\LockingPtr.h"
-				>
-			</File>
 			<File
 				RelativePath="..\..\include\loki\LokiTypeInfo.h"
 				>
@@ -254,10 +250,6 @@
 				RelativePath="..\..\include\loki\static_check.h"
 				>
 			</File>
-			<File
-				RelativePath="..\..\include\loki\Threads.h"
-				>
-			</File>
 			<File
 				RelativePath="..\..\include\loki\Tuple.h"
 				>
@@ -324,6 +316,10 @@
 			Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"
 			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
 			>
+			<File
+				RelativePath="..\..\include\loki\LockingPtr.h"
+				>
+			</File>
 			<File
 				RelativePath=".\main.cpp"
 				>
@@ -332,6 +328,10 @@
 				RelativePath=".\Thread.h"
 				>
 			</File>
+			<File
+				RelativePath="..\..\include\loki\Threads.h"
+				>
+			</File>
 		</Filter>
 	</Files>
 	<Globals>
diff --git a/test/LockingPtr/main.cpp b/test/LockingPtr/main.cpp
index 596aa55..9df1ad7 100755
--- a/test/LockingPtr/main.cpp
+++ b/test/LockingPtr/main.cpp
@@ -14,6 +14,10 @@
 
 #define LOKI_CLASS_LEVEL_THREADING
 
+#ifndef LOKI_CLASS_LEVEL_THREADING
+#define LOKI_OBJECT_LEVEL_THREADING
+#endif 
+
 #include "Thread.h"
 
 #include <loki/LockingPtr.h>
@@ -29,6 +33,8 @@ int loop = 5;
 
 struct A
 {
+    A(){};
+
 #define  DO for(int i=0; i<10000000; i++) g++;
 
     void print(void* id) const
@@ -54,8 +60,8 @@ struct A
     }
 };
 
-typedef Loki::LockingPtr<A,Loki::Mutex> LPtr;
-typedef Loki::ConstLockingPtr<A,Loki::Mutex> CLPtr;
+typedef Loki::Locking<A>::Ptr LPtr;
+typedef Loki::Locking<A>::ConstPtr CLPtr;
 
 void* RunLocked(void *id)
 {
@@ -96,7 +102,7 @@ int main ()
     for(int i=0; i<numThreads; i++)
     {
         Printf("Creating thread %d\n")(i);
-        threads.push_back(new Thread(RunLocked,(void*)i));
+        threads.push_back(new Thread(RunLocked,reinterpret_cast<void*>(i)));
     }
     for(int i=0; i<numThreads; i++)
         threads.at(i)->start();
@@ -111,7 +117,7 @@ int main ()
     for(int i=0; i<numThreads; i++)
     {
         Printf("Creating thread %d\n")(i);
-        threads.push_back(new Thread(Run,(void*)i));
+        threads.push_back(new Thread(Run,reinterpret_cast<void*>(i)));
     }
     for(int i=0; i<numThreads; i++)
         threads.at(i)->start();