Self-managed hashed strings

StringManager * gSharedStrManager;

typedef SharedString<&gSharedStrManager> shared_str;

int main()
{
    gSharedStrManager = new HashTable;

    shared_str s = "hello";
    shared_str s2 = "there";
    shared_str s3 = "hello";

    // at this point, there are only two entries in the string manager

    return 0;
}

size_t refCount_; //!< How many times this string is shared
//Among other similar instances

virtual void dumpTable(std::ostringstream & os) const = 0; // for debugging: dump whole table to os.

protected:
//...
inline size_t hash(const std::string & str) const;

SharedString::HashTable * gTable;

MAKE_MANAGER_WRAPPER(HashTableWrapper, &gTable)
typedef SharedString::SharedString< HashTableWrapper > shared_str;

#define MAKE_MANAGER_WRAPPER(name, managerPtr) \
	struct name \
	{ \
		static const std::string * AddString(const std::string & str) \
		{ return (*Manager_)->addString(str); } \
		static void DeleteString(const std::string & str) \
		{ (*Manager_)->deleteString(str); } \
		static SharedString::StringManager ** Manager_; \
	}; \
	SharedString::StringManager ** name::Manager_ = (SharedString::StringManager**) managerPtr;

class StringAllocator {
private:
 static InternalAllocator {
   private:
      hash_type hash;
      size_t bytes_allocated;
      //...
   public:
      InternalAllocator();
      const char *Share( const char *sz );
      void Decrease( const char *sz );
      size_t GetBytes( void );
      //...
  };
public:
  StringAllocator();
  //... functions using the internal allocator.
};

template< typename T >
class SharedString {
private:
   T allocator;
   //...
public:
  //operators
};

//There would be no bulk in carrying around an allocator
//Each SharedString class would have its own instance
//of the StringAllocator class, but each instance would
//always reference the internal static allocator
//so you would have a real string sharing mechanism.

//If the user wanted to use the allocator directly,
//he or she could:
void func( void )
{
  StringAllocator sa;
  std::cout << sa.GetBytes() << std::endl;
}

#include <stddef.h>

namespace std
{ 
  using ::ptrdiff_t;
  using ::size_t;
}

David@dhaley ~/dev/lib/shared-string/dist/tmp
$ ls
LICENSE*  README*  build_unix/  build_win32/  doc/  include/  libtest/  make_docs.sh*  shared-str-0_9b.tgz  src/

David@dhaley ~/dev/lib/shared-string/dist/tmp
$  

inline size_t length() const
		{
			return str_->length();
		}

SharedString & operator= (const std::string & rhs)
		{
			// clear the old string
			deleteString();
			// set the new string
			assignString( rhs );

			return *this;
		}

		SharedString & operator= (const SharedString & rhs)
		{
			// clear the old string
			deleteString();
			// set the new string
			assignString( rhs.str_const() );

			return *this;
		}

		SharedString & operator= (const char * rhs)
		{
			deleteString();
			assignString( rhs );

			return *this;
		}

SharedString<Manager> str("Hello");
str = str;