string.cpp

贡献一份commoncpp2,有兴趣的可以研究一下

		++chars;
		++ind;
	}
	return chars;
}

unsigned String::count(const String &str, size_t ind) const
{
	return count(str.getText(), ind, str.getLength());
}

size_t String::find(const String &str, size_t ind, unsigned instance) const
{
	return find(str.getText(), ind, str.getLength(), instance);
}

size_t String::rfind(const String &str, size_t ind) const
{
	return rfind(str.getText(), ind, str.getLength());
}

int String::compare(const char *cp, size_t len, size_t ind) const
{
	if(!cp)
		cp = "";

	if(ind > getLength())
		return -1;

	if(!len)
		return strcmp(getText() + ind, cp);

	return strncmp(getText() + ind, cp, len);
}

bool String::isEmpty(void) const
{
	char *ptr = getText();

	if(!ptr || !*ptr)
		return true;

	return false;
}

void String::resize(size_t chars)
{
	size_t len = getLength();
	char *ptr;

	if(len >= chars)
		len = chars - 1;

	++len;

	if(!isBig() && chars <= minsize)
		return;

	if(!isBig())
	{
		ptr = getSpace(chars);
		memmove(ptr, content.ministring.text, len); 
		ptr[--len] = 0;
		content.ministring.big = true;
		content.bigstring.text = ptr;
		content.bigstring.length = len;
		setSize(chars);
		return;
	}
	
	if(chars <= minsize && getSize() > slotlimit)
	{
		ptr = getText();
		memmove(content.ministring.text, ptr, len);
		content.ministring.text[--len] = 0;
		content.ministring.big = false;
		content.ministring.length = (unsigned)len;
		delete[] ptr;
		return;
	}

	ptr = getSpace(chars);
	memmove(ptr, getText(), len);
	ptr[--len] = 0;
	clear();
	setSize(chars);
	content.bigstring.length = len;
	content.bigstring.text = ptr;
	content.ministring.big = true;
}

void String::clear(void)
{
	char **next;
	unsigned slot;

	if(!isBig())
		goto end;

	if(!content.bigstring.text)
		goto end; 

	if(getSize() > slotlimit)
	{
		delete[] content.bigstring.text;
		goto end;
	}

	slot = ((unsigned)getSize() - 1) / slotsize;
	next = (char **)content.bigstring.text;
	mutex.enterMutex();
	*next = idx[slot];
	idx[slot] = content.bigstring.text;
	setLength(0);
	content.bigstring.text = NULL;
	mutex.leaveMutex();	
	
end:
	init();
	return;
}	

char *String::getSpace(size_t chars)
{
	unsigned slot;
	char *cp, **next;

	if(chars > slotlimit)
		return new char[chars];

	slot = (unsigned)chars / slotsize;
	mutex.enterMutex();
	if(!pager)
	{
		pager = new MemPager(pagesize);
		idx = (char **)pager->alloc(sizeof(char *) * slotcount);
		memset(idx, 0, sizeof(char *) * slotcount);
	}
	cp = idx[slot];
	if(cp)
	{
		next = (char **)cp;
		idx[slot] = *next;
	}
	else
		cp = (char *)pager->alloc(++slot * slotsize);
	mutex.leaveMutex();
	return cp;
}

const char *String::getIndex(size_t ind) const
{
	const char *dp = getText();

	if(ind > getLength())
		return NULL;

	return (const char *)dp + ind;
}
		
char *String::getText(void) const
{
	if(isBig())
		return (char *)content.bigstring.text;

	return (char *)content.ministring.text;
}

long String::getValue(long def) const
{
	unsigned base = 10;
	char *cp = getText();
	char *ep = 0;
	long val;

	if(!cp)
		return def;

	if(!strnicmp(cp, "0x", 2))
	{
		cp += 2;
		base = 16;
	}

	val = ::strtol(cp, &ep, base);
	if(!ep || *ep)
		return def;
	return val;
}

bool String::getBool(bool def) const
{
	char *cp = getText();

	if(!cp)
		return def;

	if(isdigit(*cp))
	{
		if(!getValue(0))
			return false;
		return true;
	}

	if(!stricmp(cp, "true") || !stricmp(cp, "yes"))
		return true;

	if(!stricmp(cp, "false") || !stricmp(cp, "no"))
		return false;

	return def;
}		
	
const size_t String::getSize(void) const
{
	if(isBig())
		return content.bigstring.size;

	return minsize;
}

void String::setLength(size_t len)
{
	if(isBig())
		content.bigstring.length = len;
	else
		content.ministring.length = (unsigned)len;
}

size_t String::setSize(size_t chars)
{
	if(chars <= minsize && !isBig())
		return minsize;

  if(chars <= slotlimit)
  {
    size_t slotcount = chars / slotsize;
    if((chars % slotsize)!=0) ++slotcount;
    chars = slotcount*slotsize;
  }
	content.bigstring.size = chars;
	return chars;
}

const size_t String::getLength(void) const
{
	if(isBig())
		return content.bigstring.length;

	return content.ministring.length;
}

String operator+(const String &s1, const char c2)
{
	String result(s1);
	result.add(c2);
	return result;
}

String operator+(const String &s1, const String &s2)
{
	String result(s1);
	result.append(s2);
	return result;
}

String operator+(const String &s1, const char *s2)
{
	String result(s1);
	result += s2;
	return result;
}

String operator+(const char *s1, const String &s2)
{
	String result(s1);
	result += s2;
	return result;
}

String operator+(const char c1, const String &s2)
{
	String result(1, c1);
	result += s2;
	return result;
}

bool String::operator<(const String &s1) const
{
        if(compare(s1.getText()) < 0)
                return true;

        return false;
}

bool String::operator<(const char *s1) const
{
        if(compare(s1) < 0)
                return true;

        return false;
}

bool String::operator>(const String &s1) const
{
        if(compare(s1.getText()) > 0)
                return true;

        return false;
}

bool String::operator>(const char *s1) const
{
        if(compare(s1) > 0)
                return true;

        return false;
}

bool String::operator<=(const String &s1) const
{
	if(compare(s1.getText()) <= 0)
		return true;

	return false;
}

bool String::operator<=(const char *s1) const
{
        if(compare(s1) <= 0)
                return true;

        return false;
}

bool String::operator>=(const String &s1) const
{
        if(compare(s1.getText()) >= 0)
                return true;

        return false;
}

bool String::operator>=(const char *s1) const
{
        if(compare(s1) >= 0)
                return true;

        return false;
}

bool String::operator==(const String &s1) const
{
        if(compare(s1.getText()) == 0)
                return true;

        return false;
}

bool String::operator==(const char *s1) const
{
        if(compare(s1) == 0)
                return true;

        return false;
}

bool String::operator!=(const String &s1) const
{
        if(compare(s1.getText()) != 0)
                return true;

        return false;
}

bool String::operator!=(const char *s1) const
{
        if(compare(s1) != 0)
                return true;

        return false;
}

bool String::operator*=(const String &s1) const
{
	return search(s1.getText(), s1.getLength()) != npos;
}

bool String::operator*=(const char *s) const
{
	return search(s) != npos;
}

std::ostream &operator<<(std::ostream &os, const String &str)
{
	os << str.getText();
	return os;
}

void *StringObject::operator new(size_t size) NEW_THROWS
{
	char *base;
	size_t *sp;
	size += sizeof(size_t);

	if(size > String::slotlimit)
		return NULL;

	base = String::getSpace(size);

	if(!base)
		return NULL;

	sp = (size_t *)base;
	*sp = size;
	base += sizeof(size_t);
	return (void *)base;
}	

void StringObject::operator delete(void *ptr)
{
	char **next;
	unsigned slot;
	size_t *size = (size_t *)ptr;
	
	--size;
	ptr = size;

	slot = (unsigned)(((*size) - 1) / String::slotsize);
	next = ((char **)(ptr));
	mutex.enter();
	*next = String::idx[slot];
	String::idx[slot] = (char *)ptr;
	mutex.leave();
}
	
	

std::istream &getline(std::istream &is, String &str, char delim, size_t len)
{
	if(!len)
		len = str.getSize() - 1;

	if(len >= str.getSize())
		str.resize(len + 1);

	char *ptr = str.getText();
	is.getline(ptr, (std::streamsize)len, delim);
	str.setLength(strlen(ptr));
	return is;
}

SString::SString() :
String(), streambuf()
#ifdef  HAVE_OLD_IOSTREAM
,ostream()
#else
,ostream((streambuf *)this)
#endif
{
#ifdef  HAVE_OLD_IOSTREAM
        ostream::init((streambuf *)this);
#endif
}

SString::SString(const SString &from) :
String(from), streambuf()
#ifdef  HAVE_OLD_IOSTREAM
,ostream()
#else
,ostream((streambuf *)this)
#endif
{
#ifdef  HAVE_OLD_IOSTREAM
        ostream::init((streambuf *)this);
#endif
}

SString::~SString()
{
	if(isBig())
		String::clear();
}

int SString::overflow(int c)
{
	String::add((char)(c));
	return c;
}

#ifdef	HAVE_SNPRINTF
int strprintf(String &str, size_t size, const char *format, ...)
{
	va_list args;
	va_start(args, format);
	int rtn;

	if(!size)
		size = str.getSize();

	if(size > str.getSize())
		str.resize(size);

	char *ptr = str.getText();
	str.setLength(0);
	ptr[0] = 0;
	rtn = vsnprintf(ptr, size, format, args);
	str.setLength(strlen(ptr));
	va_end(args);
	return rtn;
}
#endif

#ifdef	CCXX_NAMESPACES
}
#endif

/** EMACS **
 * Local variables:
 * mode: c++
 * c-basic-offset: 8
 * End:
 */