#include <stringmgr.h>

Collaboration diagram for StringMgr:

Public Member Functions
virtual bool	isAlpha (SW_u32 character) const

virtual bool	isDigit (SW_u32 character) const

virtual bool	isLower (SW_u32 character) const

virtual bool	isUpper (SW_u32 character) const

virtual char *	lowerUTF8 (char *text, unsigned int max=0) const

virtual char *	upperLatin1 (char *text, unsigned int max=0) const

virtual char *	upperUTF8 (char *text, unsigned int max=0) const

Static Public Member Functions
static StringMgr *	getSystemStringMgr ()

static bool	hasUTF8Support ()

static void	setSystemStringMgr (StringMgr *newStringMgr)

Protected Member Functions
	StringMgr ()

	StringMgr (const StringMgr &)

virtual bool	supportsUnicode () const

virtual	~StringMgr ()

Static Private Attributes
static StringMgr *	systemStringMgr = 0

Friends
class	__staticsystemStringMgr

Detailed Description

StringMgr provide UTF8 handling This class makes it possible to implement Unicode support on the client-side and not in SWORD itself.

Definition at line 39 of file stringmgr.h.

Constructor & Destructor Documentation

StringMgr::StringMgr ( )

protected

Default constructor. Protected to make instances on user side impossible, because this is a Singleton

Default constructor

Definition at line 166 of file stringmgr.cpp.

166 {

167 }

StringMgr::StringMgr ( const StringMgr & m )

protected

Copy constructor

Definition at line 171 of file stringmgr.cpp.

171 {

172 }

StringMgr::~StringMgr ( )

protectedvirtual

Destructor

Definition at line 176 of file stringmgr.cpp.

176 {

177 }

Member Function Documentation

StringMgr * StringMgr::getSystemStringMgr ( )

static

Returns the global StringMgr handle

Returns: The global string handle

Definition at line 197 of file stringmgr.cpp.

                                          {
     if (!systemStringMgr) {
 #ifdef _ICU_
         systemStringMgr = new ICUStringMgr();
 //      SWLOGI("created default ICUStringMgr");
 #else
         systemStringMgr = new StringMgr();
 //          SWLOGI("created default StringMgr");
 #endif
     }
     
     return systemStringMgr;
 }

static bool StringMgr::hasUTF8Support ( )

inlinestatic

Checks whether Utf8 support is available. Override the function supportsUnicode() to tell whether your implementation has utf8 support.

Returns: True if this implementation provides support for Utf8 handling or false if just latin1 handling is available

Definition at line 58 of file stringmgr.h.

                                         {
         return getSystemStringMgr()->supportsUnicode();
     };

bool StringMgr::isAlpha ( SW_u32 character ) const

virtual

Definition at line 317 of file stringmgr.cpp.

                                               {
     return isalpha(character);
 }

bool StringMgr::isDigit ( SW_u32 character ) const

virtual

Definition at line 314 of file stringmgr.cpp.

                                               {
     return isdigit(character);
 }

bool StringMgr::isLower ( SW_u32 character ) const

virtual

Definition at line 311 of file stringmgr.cpp.

                                               {
     return islower(character);
 }

bool StringMgr::isUpper ( SW_u32 character ) const

virtual

Definition at line 308 of file stringmgr.cpp.

                                               {
     return isupper(character);
 }

char * StringMgr::lowerUTF8	(	char *	t,
		unsigned int	maxlen = `0`
	)		const

virtual

Converts the param to a lower case Utf8 string

Parameters

text	The text encoded in utf8 which should be turned into an upper case string
max	Max buffer size

Returns: text buffer (only for convenience)

This is a fallback method. It should never be called. If UTF8 support is desired, then a UTF8 StringMgr needs to be used.

Here we just do our best.

Converts the param to a lower case UTF8 string

Parameters

t	- The text encoded in utf8 which should be turned into an lower case string

Definition at line 284 of file stringmgr.cpp.

                                                              {
     // try to decide if it's worth trying to tolower.  Do we have more
     // characters which are probably lower latin than not?
     // we still don't use isValidUTF8 optimally. what if we have 1 unicode
     // character in the string?  should we not try to lower any of the string?
     // dunno.  Best solution is to lower all other characters. Don't have
     // time to write that before release.
     long performOp = 0;
     if (!isValidUTF8((unsigned char *)t)) {
         performOp = 1;
     }
     else {
         for (const char *ch = t; *ch; ch++) {
             performOp += (*ch > 0) ? 1 : -1;
         }
     }
 
     if (performOp > 0) {
         return lowerLatin1(t);
     }
 
     return t;
 }

void StringMgr::setSystemStringMgr ( StringMgr * newStringMgr )

static

Sets the global StringMgr handle

Parameters

newStringMgr The new global StringMgr. This pointer will be deleted by this StringMgr

Definition at line 182 of file stringmgr.cpp.

                                                           {
     if (systemStringMgr) 
         delete systemStringMgr;
     
     systemStringMgr = newStringMgr;
 
     // TODO: this is magic. apparently we have to reset the system localemgr upon changing stringmgr.
     // setting system stringmgr should be set before localemgr and not possible to change.
     // rework this design.
     LocaleMgr::getSystemLocaleMgr()->setSystemLocaleMgr(new LocaleMgr());
 }

bool StringMgr::supportsUnicode ( ) const

protectedvirtual

Definition at line 342 of file stringmgr.cpp.

                                       {
     return true; //default impl has no UTF8 support
 }

char * StringMgr::upperLatin1	(	char *	buf,
		unsigned int	maxlen = `0`
	)		const

virtual

Converts the param to an uppercase latin1 string

Parameters

text	The text encoded in latin1 which should be turned into an upper case string
max	Max buffer size

Returns: text buffer (only for convenience)

Converts the param to an uppercase latin1 string

Parameters

The	text encoded in latin1 which should be turned into an upper case string

Definition at line 327 of file stringmgr.cpp.

                                                                  {
     if (!buf)
         return 0;
         
     char *ret = buf;
     bool checkMax = maxlen;
 
     while (*buf && (!checkMax || maxlen--)) {
         *buf = SW_toupper(*buf);
         buf++;
     }
 
     return ret;
 }

char * StringMgr::upperUTF8	(	char *	t,
		unsigned int	maxlen = `0`
	)		const

virtual

Converts the param to an upper case Utf8 string

Parameters

text	The text encoded in utf8 which should be turned into an upper case string
max	Max buffer size

Returns: text buffer (only for convenience)

This is a fallback method. It should never be called. If UTF8 support is desired, then a UTF8 StringMgr needs to be used.

Here we just do our best.

Converts the param to an upper case UTF8 string

Parameters

t	- The text encoded in utf8 which should be turned into an upper case string

Definition at line 223 of file stringmgr.cpp.

                                                              {
 
 #ifndef _ICU_
 
     SWBuf orig = t;
     const unsigned char* from = (unsigned char*)orig.c_str();
     SWBuf text = "";
     std::map<SW_u32, SW_u32>::const_iterator it = toUpperData.end();
     while (*from) {     
         SW_u32 ch = getUniCharFromUTF8(&from, true);
         // should we skip conversion if we run into an invalid UTF8 character?
         // maybe the string isn't intended to be UTF8
         // Right now, if ch is bad, then convert to replacement char
         if (!ch) ch = 0xFFFD;
 
         it = toUpperData.find(ch);
         getUTF8FromUniChar(it == toUpperData.end() ? ch : it->second, &text);
     }
     long len = maxlen ? (text.size() < maxlen ? text.size() : (maxlen - 1)) : 0;
     if (len) memcpy(t, text.c_str(), len);
     t[len] = 0;
 #endif
     return t;
 /* OLD
     // try to decide if it's worth trying to toupper.  Do we have more
     // characters which are probably lower latin than not?
     // we still don't use isValidUTF8 optimally. what if we have 1 unicode
     // character in the string?  should we not try to upper any of the string?
     // dunno.  Best solution is to upper all other characters. Don't have
     // time to write that before release.
 
     long performOp = 0;
     if (!isValidUTF8((unsigned char *)t)) {
         performOp = 1;
     }
     else {
         for (const char *ch = t; *ch; ch++) {
             performOp += (*ch > 0) ? 1 : -1;
         }
     }
 
     if (performOp > 0) {
         return upperLatin1(t);
     }
 */
 
     return t;
 }

Friends And Related Function Documentation

friend class __staticsystemStringMgr

friend

Definition at line 89 of file stringmgr.h.

Member Data Documentation

SWORD_NAMESPACE_START StringMgr * StringMgr::systemStringMgr = 0

staticprivate

Definition at line 41 of file stringmgr.h.

The documentation for this class was generated from the following files:

include/stringmgr.h
src/mgr/stringmgr.cpp

Public Member Functions

Static Public Member Functions

Protected Member Functions

Static Private Attributes

Friends

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

Member Data Documentation