ysstring.cpp

电力故障信息采集,主要是针对南自的保护装置,这个程序用在Linux操作系统下

// YsString.cpp: implementation of the YsString class.
//
//////////////////////////////////////////////////////////////////////

#include "YsString.h"

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

YsString::YsString()
{
	
}

YsString::YsString(const char *pStr)
{
	m_str = pStr;
}

YsString::YsString(char *pStr)
{
	m_str = pStr;
}

YsString::YsString(const YsString &str)
{
	m_str = str.m_str;
}

YsString::~YsString()
{	
}

bool YsString::isEmpty() const
{
	return 0 == length() ;
}

char* YsString::data() const
{
	return (char*)m_str.c_str();
}

char YsString::at(int index) const
{
	if(index >= length())
		return '\0';
	return ((char*)m_str.c_str())[index];	
}

YsString YsString::substr(int beg, int len)
{
	YsString str;
	if(len == 0)
		len = length();
	std::string s=data();
	s=s.substr(beg,len);
	str=s.c_str();
	return str;
}

int YsString::length() const
{
	return m_str.size();
}

YsString YsString::arg(int a, int fieldWidth /*= 0*/, int base /*= 10*/, char fillChar /*= ' '*/)
{
	base=base;	char buf[32];
	memset(buf,0,32);
	sprintf(buf,"%d",a);
	//itoa(a,buf,base);
	YsString str(buf);
	if(fieldWidth>0)
	{
		while(length() < fieldWidth)
		{
			m_str = fillChar +m_str;
		}
	}
	else if(fieldWidth<0)
	{
		fieldWidth = -fieldWidth;
		while(length() < fieldWidth)
		{
			m_str = m_str + fillChar;
		}
	}
	return str;
}

void YsString::clear()
{
	m_str = "";
}

YsString &YsString::operator=(char c)
{
	m_str = c;
	return *this;
}

YsString &YsString::operator=(const YsString &s)
{
	m_str = s.m_str;
	return *this;
}

int YsString::compare(const YsString &str)
{
	return m_str.compare(str.m_str);
}

int YsString::compareNoCase(const YsString &str)
{
	return strcasecmp(m_str.data(),str.m_str.data());
	/*
	std::string s1 = strupr((char *)m_str.data());
	std::string s2 = strupr((char *)str.m_str.data());
	return s1.compare(s2);
	*/
}

int YsString::find(char c, int i /*= 0*/, bool cs /*= true*/)//查找字符,cs是否大小写敏感
{
	YsString cmp;
	cmp=c;
	return find(cmp,i,cs);
}

int YsString::find(YsString s, int i /*= -1*/, bool cs /*= true*/)//查找字符串,cs是否大小写敏感
{
	YsString s1,s2;
	if(cs == false)
	{
		s1=toUpper();
		s2 = s.toUpper();
	}
	else
	{
		s1 = *this;
		s2 = s;
	}
	return s1.m_str.find(s2.m_str,i);
}

int YsString::findRev(char c, int i /*= 0*/, bool cs /*= true*/)//反向查找字符,cs是否大小写敏感
{
	YsString cmp;
	cmp=c;
	return findRev(cmp,i,cs);
}

int YsString::findRev(YsString s, int i /*= -1*/, bool cs /*= true*/)//反向查找字符串,cs是否大小写敏感
{
	if(i == -1)
		i = length();
	YsString s1,s2;
	if(cs == false)
	{
		s1=toUpper();
		s2 = s1.toUpper();
	}
	else
	{
		s1 = *this;
		s2 = s;
	}
	return s1.m_str.find_last_of(s2.m_str, i);
}

bool YsString::operator==(const YsString &s)
{
	return m_str.compare(s.m_str) == 0;
}

bool YsString::operator==(const char *s)
{
	return m_str.compare(s) == 0;
}

bool YsString::operator!=(const YsString &s)
{
	return m_str.compare(s.m_str) != 0;
}

bool YsString::operator!=(const char *s)
{
	return m_str.compare(s) != 0;
}

YsString & YsString::operator+= ( const YsString & other )
{
	m_str = m_str + other.m_str;
	return *this;
}

YsString & YsString::operator+=( char c )
{
	m_str = m_str + c;
	return *this;
}

YsString & YsString::operator+=( char *str )
{
	m_str = m_str + str;
	return *this;
}

YsString & YsString::operator+=(const  char *str )
{
	m_str = m_str + str;
	return *this;
}

YsString YsString::operator+(const YsString &s)
{
	YsString str;
	str = *this;
	str += s;
	return str;
}

YsString YsString::operator+(char * s) 
{
	YsString str;
	str = *this;
	str += s;
	return str;
}

/*
YsString YsString::operator+(char * s, const YsString &s2) 
{
	YsString str;
	str = *this;
	str += s;
	str += s2;
	return str;
}*/

YsString YsString::operator+(char c)
{
	YsString str;
	str = *this;
	str += c;
	return str;
}

YsString YsString::left(int len)
{
	YsString s;
	s.m_str = m_str.substr(0,len);
	return s;
}

YsString YsString::right(int len)
{
	YsString s;
	int i=length()-len;
	if(i<0)
		i=0;
	s.m_str = m_str.substr(i,length()-i);
	return s;
}

YsString YsString::mid(int i, int len /*= -1*/)
{
	YsString s;
	if(len == -1 || len > len - i)
		len = length()-i;
	s.m_str = m_str.substr(i,len);
	return s;
}

YsString YsString::replace ( int pos, int len, const YsString & sDesc )
{
	*this = left(pos) + sDesc + right(length() - pos - len);
	return *this;
}

YsString YsString::replace ( int pos, int len, const char * str)
{
	*this = left(pos) + str + right(length() - pos - len);
	return *this;
}

YsString YsString::replace ( int pos, int len, char c )
{
	*this = left(pos) + c + right(length() - pos - len);
	return *this;
}

YsString YsString::replace ( const YsString &before, const YsString &after, bool cs/*=true*/)//cs: case sensitive
{
	int pos=0;
	while(1)
	{
		pos=find(before,pos,cs);
		if(pos < 0)
			return *this;
		replace(pos,before.length(),after);
		pos += after.length();
	}
	
	return *this;
}

YsString& YsString::sprintf(const char * cformat, ...)
{
	char buf[10240];
	memset(buf,0,10240);
	va_list ap;
	va_start(ap, cformat);
	vsprintf(buf,cformat,ap);
	va_end(ap);
	m_str=buf;
	return *this;
}

YsString YsString::toUpper()
{
	YsString s=*this;
	char *p = (char*)s.m_str.c_str();
	int i,cnt=length();
	for(i=0;i<cnt;i++)
	{
		if(p[i] >= 'a' && p[i] <= 'z')
		{
			p[i] = p[i] + ('A' - 'a');
		}
	}
	return s;
}

YsString YsString::toLower()
{
	YsString s=*this;
	char *p = (char*)s.m_str.c_str();
	int i,cnt=length();
	for(i=0;i<cnt;i++)
	{
		if(p[i] >= 'A' && p[i] <= 'Z')
		{
			p[i] = p[i] + ('a' - 'A');
		}
	}
	return s;	
}

short YsString::toShort(bool * ok)
{
	ok=ok;int v=atoi(m_str.data());
	return (short)v;
}

int YsString::toInt(bool * ok)
{
	ok=ok;int v=atoi(m_str.data());
	return v;
}

long YsString::toLong(bool * ok)
{
	ok=ok;long v=atol(m_str.data());
	return v;
}

unsigned short YsString::toUShort(bool * ok)
{
	ok=ok;return (unsigned short)toShort();
}

unsigned int YsString::toUInt(bool * ok)
{
	return (unsigned int)toInt(ok);
}

unsigned long YsString::toULong(bool * ok)
{
	return (unsigned long)toLong(ok);
}

float YsString::toFloat(bool *ok)
{
	ok=ok;float v=atof(m_str.data());
	return v;
}

double YsString::toDouble(bool *ok)
{
	return (double)toFloat(ok);
}

YsString YsString::upper()
{
	return toUpper();
}
YsString YsString::lower()
{
	return toLower();
}
YsString YsString::stripWhiteSpace()
{
	while(left(1) == " ")
		*this = right(length()-1);
	while(right(1) == " ")
		*this = left(length()-1);
	return *this;
}

YsString YsString::fill(char ch, int size/*=-1*/)
{
	int i,cnt;
	char *p;
	if(size == -1)
	{
		cnt = length();
		p = (char*)m_str.data();
		for(i=0;i<cnt;i++)
		{
			p[i] = ch;
		}
	}
	else
	{
		m_str="";
		for(i=0;i<size;i++)
			m_str += ch;
	}
	return *this;
}