A policy based reference counting implementation for compound objects

//////////////////////////////////////////
//	strings.hpp
//	generic strings
//

#pragma once
#include "smart.hpp"
#pragma message ("Compiling " __FILE__)


namespace GE_{ namespace stdx{

	namespace strings
	{

		//string traits: available for eventual specializations

		struct traits
		{
			template<class Type>
			static size_t len(const Type* p)
			{
				if(!p) return 0;
				size_t n(0);
				while(!!*p++) n++;
				return n;
			}

			template<class Type>
			static void copy(Type* dest, const Type* src, size_t n=-1)
			{
				while(n-- && !!*src)
					*dest++ = *src++;
			}

			struct base{};
		};

	};


	//class stdx::string: mamage a shared data through a smart pointer

	template<class Type, class traits=strings::traits >
	class string:
		public traits::base
	{
	private:
		typedef std::vector<Type> data_t;
		typedef stdx::statptr<data_t>::strong data_p;
		data_p pData;
		//lets have a shared null string (will simplify a lot the redirections)
		static data_p nullstr() 
		{ 
			static data_p p;
			if(!p)
				p.New()->resize(1);
			return p;
		}
		friend class string;
	public:
		string() { pData = nullstr(); }
		Type* get_buffer(size_t len=-1)
		{
			if(len == -1) len = pData->size();
			if(pData.get_holdcount() >1)
				pData.New(*pData); //clone the vector
			pData->resize(len+1);
			return &(*pData)[0];
		}
		operator const Type*() const { return &(*pData)[0]; }
		bool operator!() const { return !(*pData)[0]; }
		void clear() { pData = nullstr(); }
		size_t len() const { return pData->size()-1; }
		
		string(const string& s) { pData = s.pData; }
		string(const Type* p, size_t n=-1)
		{
			pData = nullstr();
			if(n==-1)
				n = traits::len(p);
            Type* buff = get_buffer(n);
			traits::copy(buff, p, n);
		}
		string(const Type& c, size_t n=1)
		{
			pData.New(n+1, c);
			(*pData)[n] = (*nullstr())[0];
		}

		string& operator=(const string& s) { pData = s.pData; return *this; }
		string& operator+=(const string& s)
		{
			size_t n = len();
			size_t m = s.len();
			Type* buff = get_buffer(m+n);
			traits::copy(buff+n, (const Type*)s, m);
			return *this;
		}
		string operator+(const string& s)
		{	return string(*this)+=s; }

		bool operator==(const string& s) const
		{	return *pData == *s.pData;  }
		bool operator!=(const string& s) const
		{	return *pData != *s.pData;  }
		bool operator<(const string& s) const
		{	return *pData < *s.pData;  }
		bool operator>(const string& s) const
		{	return *pData > *s.pData;  }
		bool operator<=(const string& s) const
		{	return *pData <= *s.pData;  }
		bool operator>=(const string& s) const
		{	return *pData >= *s.pData;  }

		const Type& operator[](size_t n) const 
		{	return (*pData)[n]; }
		string operator()(size_t from, size_t count=-1)
		{
			if(count==-1) count = len()-from;
			return string(&(*pData)[from], count);
		}
		
	};


}}