Merge branch 'master' into powerpencil

7 files changed, 59 insertions, 618 deletions

diff --git a/src/util/CMakeLists.txt b/src/util/CMakeLists.txt
index 9680b6377..b8c61e2fe 100644
--- a/src/util/CMakeLists.txt
+++ b/src/util/CMakeLists.txt
@@ -10,8 +10,6 @@ set(util_SRC
 
 	# -------
 	# Headers
-	accumulators.h
-	compose.hpp
 	copy.h
 	ege-appear-time-tracker.h
 	ege-tags.h
diff --git a/src/util/accumulators.h b/src/util/accumulators.h
deleted file mode 100644
index 2cd51b101..000000000
--- a/src/util/accumulators.h
+++ /dev/null
@@ -1,113 +0,0 @@
-/** @file
- * Frequently used accumulators for use with libsigc++
- */
-/* Authors:
- *   Krzysztof Kosiński <tweenk.pl@gmail.com>
- *
- * Copyright (C) 2009 Authors
- * Released under GNU GPL, read the file 'COPYING' for more information
- */
-
-#ifndef SEEN_UTIL_ACCUMULATORS_H
-#define SEEN_UTIL_ACCUMULATORS_H
-
-#include <iterator>
-
-namespace Inkscape {
-namespace Util {
-
-/**
- * Accumulator which evaluates slots in reverse connection order.
- * The slot that was connected last is evaluated first.
- */
-struct Reverse {
-    typedef void result_type;
-    template <typename T_iterator>
-    result_type operator()(T_iterator first, T_iterator last) const {
-        while (first != last) *(--last);
-    }
-};
-
-/**
- * Accumulator type for interruptible signals. Slots return a boolean value; emission
- * is stopped when true is returned from a slot.
- */
-struct Interruptible {
-    typedef bool result_type;
-    template <typename T_iterator>
-    result_type operator()(T_iterator first, T_iterator last) const {
-        for (; first != last; ++first)
-            if (*first) return true;
-        return false;
-    }
-};
-
-/**
- * Same as Interruptible, but the slots are called in reverse order of connection,
- * e.g. the slot that was connected last is evaluated first.
- */
-struct ReverseInterruptible {
-    typedef bool result_type;
-    template <typename T_iterator>
-    result_type operator()(T_iterator first, T_iterator last) const {
-        while (first != last) {
-            if (*(--last)) return true;
-        }
-        return false;
-    }
-};
-
-/**
- * The template parameter specifies how many slots from the beginning of the list
- * should be evaluated after other slots. Useful for signals which invoke other signals
- * once complete. Undefined results if the signal does not have at least @c num_chained
- * slots before first emission.
- *
- * For example, if template param = 3, the execution order is as follows:
- * @verbatim
-   8. 1. 2. 3. 4. 5. 6. 7.
-   S1 S2 S3 S4 S5 S6 S7 S8 @endverbatim
- */
-template <unsigned num_chained = 1>
-struct Chained {
-    typedef void result_type;
-    template <typename T_iterator>
-    result_type operator()(T_iterator first, T_iterator last) const {
-        T_iterator save_first = first;
-        // ARGH, iterator_traits is not defined for slot iterators!
-        //std::advance(first, num_chained);
-        for (unsigned i = 0; i < num_chained && first != last; ++i) ++first;
-        for (; first != last; ++first) *first;
-        for (unsigned i = 0; i < num_chained && save_first != last; ++i, ++save_first)
-            *save_first;
-    }
-};
-
-/**
- * Executes a logical OR on the results from slots.
- */
-struct LogicalOr {
-    typedef bool result_type;
-    template <typename T_iterator>
-    result_type operator()(T_iterator first, T_iterator last) const {
-        bool ret = false;
-        for (; first != last; ++first) ret |= *first;
-        return ret;
-    }
-};
-
-} // namespace Util
-} // namespace Inkscape
-
-#endif
-
-/*
-  Local Variables:
-  mode:c++
-  c-file-style:"stroustrup"
-  c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
-  indent-tabs-mode:nil
-  fill-column:99
-  End:
-*/
-// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 :
diff --git a/src/util/compose.hpp b/src/util/compose.hpp
deleted file mode 100644
index b3f410c8e..000000000
--- a/src/util/compose.hpp
+++ /dev/null
@@ -1,393 +0,0 @@
-/* Defines String::compose(fmt, arg...) for easy, i18n-friendly
- * composition of strings.
- *
- * Version 1.0.
- *
- * Copyright (c) 2002 Ole Laursen <olau@hardworking.dk>.
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public License
- * as published by the Free Software Foundation; either version 2.1 of
- * the License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
- * USA.
- */
-
-//
-// Basic usage is like
-//
-//   std::cout << String::compose("This is a %1x%2 matrix.", rows, cols);
-//
-// See http://www.cs.aau.dk/~olau/compose/ or the included README.compose for
-// more details.
-//
-
-#ifndef STRING_COMPOSE_H
-#define STRING_COMPOSE_H
-
-#include <sstream>
-#include <string>
-#include <list>
-#include <map>			// for multimap
-
-namespace StringPrivate
-{
-  // the actual composition class - using string::compose is cleaner, so we
-  // hide it here
-  class Composition
-  {
-  public:
-    // initialize and prepare format string on the form "text %1 text %2 etc."
-    explicit Composition(std::string fmt);
-
-    // supply an replacement argument starting from %1
-    template <typename T>
-    Composition &arg(const T &obj);
-
-    // compose and return string
-    std::string str() const;
-
-  private:
-    std::ostringstream os;
-    int arg_no;
-
-    // we store the output as a list - when the output string is requested, the
-    // list is concatenated to a string; this way we can keep iterators into
-    // the list instead of into a string where they're possibly invalidated on
-    // inserting a specification string
-    typedef std::list<std::string> output_list;
-    output_list output;
-
-    // the initial parse of the format string fills in the specification map
-    // with positions for each of the various %?s
-    typedef std::multimap<int, output_list::iterator> specification_map;
-    specification_map specs;
-  };
-
-  // helper for converting spec string numbers
-  inline int char_to_int(char c)
-  {
-    switch (c) {
-    case '0': return 0;
-    case '1': return 1;
-    case '2': return 2;
-    case '3': return 3;
-    case '4': return 4;
-    case '5': return 5;
-    case '6': return 6;
-    case '7': return 7;
-    case '8': return 8;
-    case '9': return 9;
-    default: return -1000;
-    }
-  }
-
-  inline bool is_number(int n)
-  {
-    switch (n) {
-    case '0':
-    case '1':
-    case '2':
-    case '3':
-    case '4':
-    case '5':
-    case '6':
-    case '7':
-    case '8':
-    case '9':
-      return true;
-    
-    default:
-      return false;
-    }
-  }
-
-
-  // implementation of class Composition
-  template <typename T>
-  inline Composition &Composition::arg(const T &obj)
-  {
-    os << obj;
-
-    std::string rep = os.str();
-  
-    if (!rep.empty()) {		// manipulators don't produce output
-      for (specification_map::const_iterator i = specs.lower_bound(arg_no),
-	     end = specs.upper_bound(arg_no); i != end; ++i) {
-	output_list::iterator pos = i->second;
-	++pos;
-      
-	output.insert(pos, rep);
-      }
-    
-      os.str(std::string());
-      //os.clear();
-      ++arg_no;
-    }
-  
-    return *this;
-  }
-
-  inline Composition::Composition(std::string fmt)
-    : arg_no(1)
-  {
-    std::string::size_type b = 0, i = 0;
-  
-    // fill in output with the strings between the %1 %2 %3 etc. and
-    // fill in specs with the positions
-    while (i < fmt.length()) {
-      if (fmt[i] == '%' && i + 1 < fmt.length()) {
-	if (fmt[i + 1] == '%') {	// catch %%
-	  fmt.replace(i, 2, "%");
-	  ++i;
-	}
-	else if (is_number(fmt[i + 1])) { // aha! a spec!
-	  // save string
-	  output.push_back(fmt.substr(b, i - b));
-	
-	  int n = 1;		// number of digits
-	  int spec_no = 0;
-
-	  do {
-	    spec_no += char_to_int(fmt[i + n]);
-	    spec_no *= 10;
-	    ++n;
-	  } while (i + n < fmt.length() && is_number(fmt[i + n]));
-
-	  spec_no /= 10;
-	  output_list::iterator pos = output.end();
-	  --pos;		// safe since we have just inserted a string>
-	
-	  specs.insert(specification_map::value_type(spec_no, pos));
-	
-	  // jump over spec string
-	  i += n;
-	  b = i;
-	}
-	else
-	  ++i;
-      }
-      else
-	++i;
-    }
-  
-    if (i - b > 0)		// add the rest of the string
-      output.push_back(fmt.substr(b, i - b));
-  }
-
-  inline std::string Composition::str() const
-  {
-    // assemble string
-    std::string str;
-  
-    for (output_list::const_iterator i = output.begin(), end = output.end();
-	 i != end; ++i)
-      str += *i;
-  
-    return str;
-  }
-}
-
-// now for the real thing(s)
-namespace String 
-{
-  // a series of functions which accept a format string on the form "text %1
-  // more %2 less %3" and a number of templated parameters and spits out the
-  // composited string
-  template <typename T1>
-  inline std::string compose(const std::string &fmt, const T1 &o1)
-  {
-    StringPrivate::Composition c(fmt);
-    c.arg(o1);
-    return c.str();
-  }
-
-  template <typename T1, typename T2>
-  inline std::string compose(const std::string &fmt,
-			     const T1 &o1, const T2 &o2)
-  {
-    StringPrivate::Composition c(fmt);
-    c.arg(o1).arg(o2);
-    return c.str();
-  }
-
-  template <typename T1, typename T2, typename T3>
-  inline std::string compose(const std::string &fmt,
-			     const T1 &o1, const T2 &o2, const T3 &o3)
-  {
-    StringPrivate::Composition c(fmt);
-    c.arg(o1).arg(o2).arg(o3);
-    return c.str();
-  }
-
-  template <typename T1, typename T2, typename T3, typename T4>
-  inline std::string compose(const std::string &fmt,
-			     const T1 &o1, const T2 &o2, const T3 &o3,
-			     const T4 &o4)
-  {
-    StringPrivate::Composition c(fmt);
-    c.arg(o1).arg(o2).arg(o3).arg(o4);
-    return c.str();
-  }
-
-  template <typename T1, typename T2, typename T3, typename T4, typename T5>
-  inline std::string compose(const std::string &fmt,
-			     const T1 &o1, const T2 &o2, const T3 &o3,
-			     const T4 &o4, const T5 &o5)
-  {
-    StringPrivate::Composition c(fmt);
-    c.arg(o1).arg(o2).arg(o3).arg(o4).arg(o5);
-    return c.str();
-  }
-
-  template <typename T1, typename T2, typename T3, typename T4, typename T5,
-	    typename T6>
-  inline std::string compose(const std::string &fmt,
-			     const T1 &o1, const T2 &o2, const T3 &o3,
-			     const T4 &o4, const T5 &o5, const T6 &o6)
-  {
-    StringPrivate::Composition c(fmt);
-    c.arg(o1).arg(o2).arg(o3).arg(o4).arg(o5).arg(o6);
-    return c.str();
-  }
-
-  template <typename T1, typename T2, typename T3, typename T4, typename T5,
-	    typename T6, typename T7>
-  inline std::string compose(const std::string &fmt,
-			     const T1 &o1, const T2 &o2, const T3 &o3,
-			     const T4 &o4, const T5 &o5, const T6 &o6,
-			     const T7 &o7)
-  {
-    StringPrivate::Composition c(fmt);
-    c.arg(o1).arg(o2).arg(o3).arg(o4).arg(o5).arg(o6).arg(o7);
-    return c.str();
-  }
-
-  template <typename T1, typename T2, typename T3, typename T4, typename T5,
-	    typename T6, typename T7, typename T8>
-  inline std::string compose(const std::string &fmt,
-			     const T1 &o1, const T2 &o2, const T3 &o3,
-			     const T4 &o4, const T5 &o5, const T6 &o6,
-			     const T7 &o7, const T8 &o8)
-  {
-    StringPrivate::Composition c(fmt);
-    c.arg(o1).arg(o2).arg(o3).arg(o4).arg(o5).arg(o6).arg(o7).arg(o8);
-    return c.str();
-  }
-
-  template <typename T1, typename T2, typename T3, typename T4, typename T5,
-	    typename T6, typename T7, typename T8, typename T9>
-  inline std::string compose(const std::string &fmt,
-			     const T1 &o1, const T2 &o2, const T3 &o3,
-			     const T4 &o4, const T5 &o5, const T6 &o6,
-			     const T7 &o7, const T8 &o8, const T9 &o9)
-  {
-    StringPrivate::Composition c(fmt);
-    c.arg(o1).arg(o2).arg(o3).arg(o4).arg(o5).arg(o6).arg(o7).arg(o8).arg(o9);
-    return c.str();
-  }
-
-  template <typename T1, typename T2, typename T3, typename T4, typename T5,
-	    typename T6, typename T7, typename T8, typename T9, typename T10>
-  inline std::string compose(const std::string &fmt,
-			     const T1 &o1, const T2 &o2, const T3 &o3,
-			     const T4 &o4, const T5 &o5, const T6 &o6,
-			     const T7 &o7, const T8 &o8, const T9 &o9,
-			     const T10 &o10)
-  {
-    StringPrivate::Composition c(fmt);
-    c.arg(o1).arg(o2).arg(o3).arg(o4).arg(o5).arg(o6).arg(o7).arg(o8).arg(o9)
-      .arg(o10);
-    return c.str();
-  }
-  
-  template <typename T1, typename T2, typename T3, typename T4, typename T5,
-	    typename T6, typename T7, typename T8, typename T9, typename T10,
-	    typename T11>
-  inline std::string compose(const std::string &fmt,
-			     const T1 &o1, const T2 &o2, const T3 &o3,
-			     const T4 &o4, const T5 &o5, const T6 &o6,
-			     const T7 &o7, const T8 &o8, const T9 &o9,
-			     const T10 &o10, const T11 &o11)
-  {
-    StringPrivate::Composition c(fmt);
-    c.arg(o1).arg(o2).arg(o3).arg(o4).arg(o5).arg(o6).arg(o7).arg(o8).arg(o9)
-      .arg(o10).arg(o11);
-    return c.str();
-  }
-
-  template <typename T1, typename T2, typename T3, typename T4, typename T5,
-	    typename T6, typename T7, typename T8, typename T9, typename T10,
-	    typename T11, typename T12>
-  inline std::string compose(const std::string &fmt,
-			     const T1 &o1, const T2 &o2, const T3 &o3,
-			     const T4 &o4, const T5 &o5, const T6 &o6,
-			     const T7 &o7, const T8 &o8, const T9 &o9,
-			     const T10 &o10, const T11 &o11, const T12 &o12)
-  {
-    StringPrivate::Composition c(fmt);
-    c.arg(o1).arg(o2).arg(o3).arg(o4).arg(o5).arg(o6).arg(o7).arg(o8).arg(o9)
-      .arg(o10).arg(o11).arg(o12);
-    return c.str();
-  }
-
-  template <typename T1, typename T2, typename T3, typename T4, typename T5,
-	    typename T6, typename T7, typename T8, typename T9, typename T10,
-	    typename T11, typename T12, typename T13>
-  inline std::string compose(const std::string &fmt,
-			     const T1 &o1, const T2 &o2, const T3 &o3,
-			     const T4 &o4, const T5 &o5, const T6 &o6,
-			     const T7 &o7, const T8 &o8, const T9 &o9,
-			     const T10 &o10, const T11 &o11, const T12 &o12,
-			     const T13 &o13)
-  {
-    StringPrivate::Composition c(fmt);
-    c.arg(o1).arg(o2).arg(o3).arg(o4).arg(o5).arg(o6).arg(o7).arg(o8).arg(o9)
-      .arg(o10).arg(o11).arg(o12).arg(o13);
-    return c.str();
-  }
-
-  template <typename T1, typename T2, typename T3, typename T4, typename T5,
-	    typename T6, typename T7, typename T8, typename T9, typename T10,
-	    typename T11, typename T12, typename T13, typename T14>
-  inline std::string compose(const std::string &fmt,
-			     const T1 &o1, const T2 &o2, const T3 &o3,
-			     const T4 &o4, const T5 &o5, const T6 &o6,
-			     const T7 &o7, const T8 &o8, const T9 &o9,
-			     const T10 &o10, const T11 &o11, const T12 &o12,
-			     const T13 &o13, const T14 &o14)
-  {
-    StringPrivate::Composition c(fmt);
-    c.arg(o1).arg(o2).arg(o3).arg(o4).arg(o5).arg(o6).arg(o7).arg(o8).arg(o9)
-      .arg(o10).arg(o11).arg(o12).arg(o13).arg(o14);
-    return c.str();
-  }
-
-  template <typename T1, typename T2, typename T3, typename T4, typename T5,
-	    typename T6, typename T7, typename T8, typename T9, typename T10,
-	    typename T11, typename T12, typename T13, typename T14,
-	    typename T15>
-  inline std::string compose(const std::string &fmt,
-			     const T1 &o1, const T2 &o2, const T3 &o3,
-			     const T4 &o4, const T5 &o5, const T6 &o6,
-			     const T7 &o7, const T8 &o8, const T9 &o9,
-			     const T10 &o10, const T11 &o11, const T12 &o12,
-			     const T13 &o13, const T14 &o14, const T15 &o15)
-  {
-    StringPrivate::Composition c(fmt);
-    c.arg(o1).arg(o2).arg(o3).arg(o4).arg(o5).arg(o6).arg(o7).arg(o8).arg(o9)
-      .arg(o10).arg(o11).arg(o12).arg(o13).arg(o14).arg(o15);
-    return c.str();
-  }
-}
-
-
-#endif // STRING_COMPOSE_H
diff --git a/src/util/format.h b/src/util/format.h
index 690121254..d2fe2d0ef 100644
--- a/src/util/format.h
+++ b/src/util/format.h
@@ -20,20 +20,20 @@ namespace Inkscape {
 
 namespace Util {
 
-inline ptr_shared<char> vformat(char const *format, va_list args) {
+inline ptr_shared vformat(char const *format, va_list args) {
     char *temp=g_strdup_vprintf(format, args);
-    ptr_shared<char> result=share_string(temp);
+    ptr_shared result=share_string(temp);
     g_free(temp);
     return result;
 }
 
        // needed since G_GNUC_PRINTF can only be used on a declaration
-       ptr_shared<char> format(char const *format, ...) G_GNUC_PRINTF(1,2);
-inline ptr_shared<char> format(char const *format, ...) {
+       ptr_shared format(char const *format, ...) G_GNUC_PRINTF(1,2);
+inline ptr_shared format(char const *format, ...) {
     va_list args;
 
     va_start(args, format);
-    ptr_shared<char> result=vformat(format, args);
+    ptr_shared result=vformat(format, args);
     va_end(args);
 
     return result;
diff --git a/src/util/makefile.in b/src/util/makefile.in
deleted file mode 100644
index fc4870075..000000000
--- a/src/util/makefile.in
+++ /dev/null
@@ -1,17 +0,0 @@
-# Convenience stub makefile to call the real Makefile.
-
-@SET_MAKE@
-
-OBJEXT = @OBJEXT@
-
-# Explicit so that it's the default rule.
-all:
-	cd .. && $(MAKE) util/all
-
-clean %.a %.$(OBJEXT):
-	cd .. && $(MAKE) util/$@
-
-.PHONY: all clean
-
-.SUFFIXES:
-.SUFFIXES: .a .$(OBJEXT)
diff --git a/src/util/share.cpp b/src/util/share.cpp
index 3cb289b10..d5d93fc75 100644
--- a/src/util/share.cpp
+++ b/src/util/share.cpp
@@ -1,5 +1,6 @@
 /*
- * Inkscape::Util::ptr_shared<T> - like T const *, but stronger
+ * Inkscape::Util::ptr_shared<T> - like T const *, but stronger.
+ * Used to hold c-style strings for objects that are managed by the gc.
  *
  * Authors:
  *   MenTaLguY <mental@rydia.net>
@@ -15,13 +16,13 @@
 namespace Inkscape {
 namespace Util {
 
-ptr_shared<char> share_string(char const *string) {
-    g_return_val_if_fail(string != NULL, share_unsafe<char>(NULL));
+ptr_shared share_string(char const *string) {
+    g_return_val_if_fail(string != NULL, share_unsafe(NULL));
     return share_string(string, std::strlen(string));
 }
 
-ptr_shared<char> share_string(char const *string, std::size_t length) {
-    g_return_val_if_fail(string != NULL, share_unsafe<char>(NULL));
+ptr_shared share_string(char const *string, std::size_t length) {
+    g_return_val_if_fail(string != NULL, share_unsafe(NULL));
     char *new_string=new (GC::ATOMIC) char[length+1];
     std::memcpy(new_string, string, length);
     new_string[length] = 0;
diff --git a/src/util/share.h b/src/util/share.h
index 8f1e7045a..6e5a24d71 100644
--- a/src/util/share.h
+++ b/src/util/share.h
@@ -1,5 +1,6 @@
 /*
- * Inkscape::Util::ptr_shared<T> - like T const *, but stronger
+ * Inkscape::Util::ptr_shared<T> - like T const *, but stronger.
+ * Used to hold c-style strings for objects that are managed by the gc.
  *
  * Authors:
  *   MenTaLguY <mental@rydia.net>
@@ -19,120 +20,84 @@
 namespace Inkscape {
 namespace Util {
 
-template <typename T>
 class ptr_shared {
 public:
-    ptr_shared() : _obj(NULL) {}
 
-    template <typename T1>
-    ptr_shared(ptr_shared<T1> const &other) : _obj(other._obj) {}
+    ptr_shared() : _string(NULL) {}
+        ptr_shared(ptr_shared const &other) : _string(other._string) {}
 
-    T const *pointer() const { return _obj; }
+    operator char const *() const { return _string; }
+    operator bool() const { return _string; }
 
-    template <typename T1>
-    operator T1 const *() const { return _obj; }
+    char const *pointer() const { return _string; }
+    char const &operator[](int i) const { return _string[i]; }
 
-    operator bool() const { return _obj; }
-
-    T const &operator*() const { return *_obj; }
-    T const *operator->() const { return _obj; }
-    T const &operator[](int i) const { return _obj[i]; }
-
-    ptr_shared<T> operator+(int i) const {
-        return share_unsafe(_obj+i);
+    ptr_shared operator+(int i) const {
+        return share_unsafe(_string+i);
     }
-    ptr_shared<T> operator-(int i) const {
-        return share_unsafe(_obj-i);
+    ptr_shared operator-(int i) const {
+        return share_unsafe(_string-i);
     }
-
-    ptr_shared<T> &operator+=(int i) const {
-        _obj += i;
+    //WARNING: No bounds checking in += and -= functions. Moving the pointer
+    //past the end of the string and then back could probably cause the garbage
+    //collector to deallocate the string inbetween, as there's temporary no
+    //valid reference pointing into the allocated space.
+    ptr_shared &operator+=(int i) {
+        _string += i;
         return *this;
     }
-    ptr_shared<T> &operator-=(int i) const {
-        _obj -= i;
+    ptr_shared &operator-=(int i) {
+        _string -= i;
         return *this;
     }
-
-    template <typename T1>
-    std::ptrdiff_t operator-(ptr_shared<T1> const &other) {
-        return _obj - other._obj;
+    std::ptrdiff_t operator-(ptr_shared const &other) {
+        return _string - other._string;
     }
 
-    template <typename T1>
-    ptr_shared<T> &operator=(ptr_shared<T1> const &other) {
-        _obj = other._obj;
+    ptr_shared &operator=(ptr_shared const &other) {
+        _string = other._string;
         return *this;
     }
 
-    template <typename T1>
-    bool operator==(ptr_shared<T1> const &other) const {
-        return _obj == other._obj;
+    bool operator==(ptr_shared const &other) const {
+        return _string == other._string;
     }
-
-    template <typename T1>
-    bool operator!=(ptr_shared<T1> const &other) const {
-        return _obj != other._obj;
+    bool operator!=(ptr_shared const &other) const {
+        return _string != other._string;
     }
-
-    template <typename T1>
-    bool operator>(ptr_shared<T1> const &other) const {
-        return _obj > other._obj;
+    bool operator>(ptr_shared const &other) const {
+        return _string > other._string;
     }
-
-    template <typename T1>
-    bool operator<(ptr_shared<T1> const &other) const {
-        return _obj < other._obj;
-    }
-
-    static ptr_shared<T> share_unsafe(T const *obj) {
-        return ptr_shared<T>(obj);
+    bool operator<(ptr_shared const &other) const {
+        return _string < other._string;
     }
 
-protected:
-    explicit ptr_shared(T const *obj) : _obj(obj) {}
+    friend ptr_shared share_unsafe(char const *string); 
 
 private:
-    T const *_obj;
-};
-
-template <typename T>
-inline ptr_shared<T> share(T const *obj) {
-    return share_unsafe(obj ? new T(*obj) : NULL);
-}
+    ptr_shared(char const *string) : _string(string) {}
+    static ptr_shared share_unsafe(char const *string) {
+        return ptr_shared(string);
+    }
 
-ptr_shared<char> share_string(char const *string);
-ptr_shared<char> share_string(char const *string, std::size_t length);
+    //This class (and code usign it) assumes that it never has to free this
+    //pointer, and that the memory it points to will not be freed as long as a
+    //ptr_shared pointing to it exists.
+    char const *_string;
+};
 
-template <typename T>
-inline ptr_shared<T> reshare(T const *obj) {
-    return ptr_shared<T>::share_unsafe(obj);
-}
+ptr_shared share_string(char const *string);
+ptr_shared share_string(char const *string, std::size_t length);
 
-template <typename T>
-inline ptr_shared<T> share_unsafe(T const *obj) {
-    return ptr_shared<T>::share_unsafe(obj);
+inline ptr_shared share_unsafe(char const *string) {
+    return ptr_shared::share_unsafe(string);
 }
 
-inline ptr_shared<char> share_static_string(char const *string) {
+//TODO: Do we need this function?
+inline ptr_shared share_static_string(char const *string) {
     return share_unsafe(string);
 }
 
-template <typename T1, typename T2>
-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 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 ptr_shared<T1> reinterpret_cast_shared(ptr_shared<T2> const &ref) {
-    return reshare(reinterpret_cast<T1 const *>(ref.pointer()));
-}
-
 }
 }