shared_ptr -> ptr_shared

(bzr r240)

2 files changed, 31 insertions, 31 deletions

diff --git a/src/util/share.cpp b/src/util/share.cpp
index 7f2d09bf6..2f693fac9 100644
--- a/src/util/share.cpp
+++ b/src/util/share.cpp
@@ -1,5 +1,5 @@
 /*
- * Inkscape::Util::shared_ptr<T> - like T const *, but stronger
+ * Inkscape::Util::ptr_shared<T> - like T const *, but stronger
  *
  * Authors:
  *   MenTaLguY <mental@rydia.net>
@@ -15,12 +15,12 @@
 namespace Inkscape {
 namespace Util {
 
-shared_ptr<char> share_string(char const *string) {
+ptr_shared<char> share_string(char const *string) {
     g_return_val_if_fail(string != NULL, share_unsafe<char>(NULL));
     return share_string(string, std::strlen(string));
 }
 
-shared_ptr<char> share_string(char const *string, std::size_t length) {
+ptr_shared<char> share_string(char const *string, std::size_t length) {
     g_return_val_if_fail(string != NULL, share_unsafe<char>(NULL));
     char *new_string=new (GC::ATOMIC) char[length+1];
     std::memcpy(new_string, string, length);
diff --git a/src/util/share.h b/src/util/share.h
index 93cef7a02..3a2b73561 100644
--- a/src/util/share.h
+++ b/src/util/share.h
@@ -1,5 +1,5 @@
 /*
- * Inkscape::Util::shared_ptr<T> - like T const *, but stronger
+ * Inkscape::Util::ptr_shared<T> - like T const *, but stronger
  *
  * Authors:
  *   MenTaLguY <mental@rydia.net>
@@ -19,12 +19,12 @@ namespace Inkscape {
 namespace Util {
 
 template <typename T>
-class shared_ptr {
+class ptr_shared {
 public:
-    shared_ptr() : _obj(NULL) {}
+    ptr_shared() : _obj(NULL) {}
 
     template <typename T1>
-    shared_ptr(shared_ptr<T1> const &other) : _obj(other._obj) {}
+    ptr_shared(ptr_shared<T1> const &other) : _obj(other._obj) {}
 
     T const *pointer() const { return _obj; }
 
@@ -37,98 +37,98 @@ public:
     T const *operator->() const { return _obj; }
     T const &operator[](int i) const { return _obj[i]; }
 
-    shared_ptr<T> operator+(int i) const {
+    ptr_shared<T> operator+(int i) const {
         return share_unsafe(_obj+i);
     }
-    shared_ptr<T> operator-(int i) const {
+    ptr_shared<T> operator-(int i) const {
         return share_unsafe(_obj-i);
     }
 
-    shared_ptr<T> &operator+=(int i) const {
+    ptr_shared<T> &operator+=(int i) const {
         _obj += i;
         return *this;
     }
-    shared_ptr<T> &operator-=(int i) const {
+    ptr_shared<T> &operator-=(int i) const {
         _obj -= i;
         return *this;
     }
 
     template <typename T1>
-    std::ptrdiff_t operator-(shared_ptr<T1> const &other) {
+    std::ptrdiff_t operator-(ptr_shared<T1> const &other) {
         return _obj - other._obj;
     }
 
     template <typename T1>
-    shared_ptr<T> &operator=(shared_ptr<T1> const &other) {
+    ptr_shared<T> &operator=(ptr_shared<T1> const &other) {
         _obj = other._obj;
         return *this;
     }
 
     template <typename T1>
-    bool operator==(shared_ptr<T1> const &other) const {
+    bool operator==(ptr_shared<T1> const &other) const {
         return _obj == other._obj;
     }
 
     template <typename T1>
-    bool operator!=(shared_ptr<T1> const &other) const {
+    bool operator!=(ptr_shared<T1> const &other) const {
         return _obj != other._obj;
     }
 
     template <typename T1>
-    bool operator>(shared_ptr<T1> const &other) const {
+    bool operator>(ptr_shared<T1> const &other) const {
         return _obj > other._obj;
     }
 
     template <typename T1>
-    bool operator<(shared_ptr<T1> const &other) const {
+    bool operator<(ptr_shared<T1> const &other) const {
         return _obj < other._obj;
     }
 
-    static shared_ptr<T> share_unsafe(T const *obj) {
-        return shared_ptr<T>(obj);
+    static ptr_shared<T> share_unsafe(T const *obj) {
+        return ptr_shared<T>(obj);
     }
 
 protected:
-    explicit shared_ptr(T const *obj) : _obj(obj) {}
+    explicit ptr_shared(T const *obj) : _obj(obj) {}
 
 private:
     T const *_obj;
 };
 
 template <typename T>
-inline shared_ptr<T> share(T const *obj) {
+inline ptr_shared<T> share(T const *obj) {
     return share_unsafe(obj ? new T(*obj) : NULL);
 }
 
-shared_ptr<char> share_string(char const *string);
-shared_ptr<char> share_string(char const *string, std::size_t length);
+ptr_shared<char> share_string(char const *string);
+ptr_shared<char> share_string(char const *string, std::size_t length);
 
 template <typename T>
-inline shared_ptr<T> reshare(T const *obj) {
-    return shared_ptr<T>::share_unsafe(obj);
+inline ptr_shared<T> reshare(T const *obj) {
+    return ptr_shared<T>::share_unsafe(obj);
 }
 
 template <typename T>
-inline shared_ptr<T> share_unsafe(T const *obj) {
-    return shared_ptr<T>::share_unsafe(obj);
+inline ptr_shared<T> share_unsafe(T const *obj) {
+    return ptr_shared<T>::share_unsafe(obj);
 }
 
-inline shared_ptr<char> share_static_string(char const *string) {
+inline ptr_shared<char> share_static_string(char const *string) {
     return share_unsafe(string);
 }
 
 template <typename T1, typename T2>
-inline shared_ptr<T1> static_cast_shared(shared_ptr<T2> const &ref) {
+inline ptr_shared<T1> static_cast_shared(ptr_shared<T2> const &ref) {
     return reshare(static_cast<T1 const *>(ref.pointer()));
 }
 
 template <typename T1, typename T2>
-inline shared_ptr<T1> dynamic_cast_shared(shared_ptr<T2> const &ref) {
+inline ptr_shared<T1> dynamic_cast_shared(ptr_shared<T2> const &ref) {
     return reshare(dynamic_cast<T1 const *>(ref.pointer()));
 }
 
 template <typename T1, typename T2>
-inline shared_ptr<T1> reinterpret_cast_shared(shared_ptr<T2> const &ref) {
+inline ptr_shared<T1> reinterpret_cast_shared(ptr_shared<T2> const &ref) {
     return reshare(reinterpret_cast<T1 const *>(ref.pointer()));
 }