Updated readme after rename of observer_ptr and lock

Author: cschreib

README.md

@@ -4,16 +4,16 @@
 
 ## Introduction
 
-This is a small header-only library, providing a unique-ownership smart pointer that can be observed with weak pointers. It is a mixture of `std::unique_ptr` and `std::shared_ptr`: it borrows the unique-ownership semantic of `std::unique_ptr` (movable, non-copiable), but allows creating `std::weak_ptr` instances to monitor the lifetime of the pointed object.
+This is a small header-only library, providing a unique-ownership smart pointer `observable_unique_ptr` that can be observed with non-owning pointers `observer_ptr`. It is a mixture of `std::unique_ptr` and `std::shared_ptr`: it borrows the unique-ownership semantic of `std::unique_ptr` (movable, non-copiable), but allows creating observer pointers (like `std::weak_ptr` for `std::shared_ptr`) to monitor the lifetime of the pointed object.
 
-This is useful for cases where the shared-ownership of `std::shared_ptr` is not desirable, e.g., when lifetime must be carefully controlled and not be allowed to extend, yet non-owning "weak" references to the object may exist after the object has been deleted.
+This is useful for cases where the shared-ownership of `std::shared_ptr` is not desirable, e.g., when lifetime must be carefully controlled and not be allowed to extend, yet non-owning/weak/observer references to the object may exist after the object has been deleted.
 
-Note: Because of the unique ownership model, weak pointers locking cannot extend the lifetime of the pointed object, hence `observable_unique_ptr` provides less thread-safety compared to `std::shared_ptr`. This is also true of `std::unique_ptr`, and is a fundamental limitation of unique ownership. Do not use this library if the lifetime of your objects is not well understood.
+Note: Because of the unique ownership model, observer pointers cannot extend the lifetime of the pointed object, hence `observable_unique_ptr`/`observer_ptr` provides less thread-safety compared to `std::shared_ptr`/`std::weak_ptr`. This is also true of `std::unique_ptr`, and is a fundamental limitation of unique ownership. If this is an issue, you will need either to add your own explicit locking logic, or use `std::shared_ptr`/`std::weak_ptr`.
 
 
 ## Usage
 
-This is a header-only library. You have multiple ways to set it up:
+This is a header-only library requiring a C++17-compliant compiler. You have multiple ways to set it up:
  - just include this repository as a submodule in your own git repository and use CMake `add_subdirectory`,
  - use CMake `FetchContent`,
  - download the header and include it in your own sources.
@@ -28,35 +28,34 @@ From there, include the single header `<oup/observable_unique_ptr.hpp>`, and dir
 #include <cassert>
 
 int main() {
-    // Weak pointer that will outlive the object
-    oup::weak_ptr<std::string> wptr;
+    // Non-owning pointer that will outlive the object
+    oup::observer_ptr<std::string> obs_ptr;
 
     {
         // Unique pointer that owns the object
-        auto ptr = oup::make_observable_unique<std::string>("hello");
+        auto owner_ptr = oup::make_observable_unique<std::string>("hello");
 
-        // Make the weak pointer observe the object
-        wptr = ptr;
+        // Make the observer pointer point to the object
+        obs_ptr = owner_ptr;
 
-        // Weak pointer is valid
-        assert(!wptr.expired());
+        // Observer pointer is valid
+        assert(!obs_ptr.expired());
 
-        // It can be locked to get a (non-owning!) pointer to the object
-        std::string* s = wptr.lock();
-        assert(s != nullptr);
-        std::cout << *s << std::endl;
+        // It can be used like a regular raw pointer
+        assert(obs_ptr != nullptr);
+        std::cout << *obs_ptr << std::endl;
 
         // The unique pointer cannot be copied
-        auto tmp_copied = ptr; // error!
+        auto tmp_copied = owner_ptr; // error!
 
         // ... but it can be moved
-        auto tmp_moved = std::move(ptr); // OK
+        auto tmp_moved = std::move(owner_ptr); // OK
     }
 
     // The unique pointer has gone out of scope, the object is deleted,
-    // the weak pointer is now null.
-    assert(wptr.expired());
-    assert(wptr.lock() == nullptr);
+    // the observer pointer is now null.
+    assert(obs_ptr.expired());
+    assert(obs_ptr == nullptr);
 
     return 0;
 }