Main Page Packages Namespace List Class Hierarchy Alphabetical List Compound List File List Compound Members File Members Search

JString Class Reference

#include <String.hpp>

List of all members.

Public Methods

JString ()

JString (const char *s)

JString (const char *s, ULONG nBuffer)

JString (const JString &src)

JString (char ch)

JString (char ch, ULONG nRepeat)

JString (JStringData *sd)

virtual ~JString ()

bool OK () const

bool isEmpty () const

bool isFilled () const

void Clear ()

void Empty ()

void FillString (char ch)

void FillBuffer (char ch)

__inline void Display () const

__inline ULONG length ()

__inline ULONG getLength ()

__inline ULONG getAllocLength () const

__inline ULONG getBufferSize () const

__inline int getLockNb () const

__inline bool isLock () const

__inline bool isUnlock () const

JString at (ULONG startpos)

JString at (ULONG startpos, ULONG length)

JString at (const char *s, ULONG startpos)

JString at (const char *s, ULONG startpos, ULONG length)

__inline JString at ()

__inline JString at (const char *s)

__inline JString at (const JString &S)

__inline JString at (const JString &S, ULONG startpos)

__inline JString at (const JString &S, ULONG startpos, ULONG length)

JString & setAt (ULONG nIndex, char ch)

__inline char charAt ()

__inline char charAt (const char *s)

__inline char charAt (const JString &S)

__inline const JString & modifyAt (const JString &S)

__inline const JString & modifyAt (const JString &S, ULONG offset)

__inline const JString & modifyAt (const JString &S, ULONG offset, ULONG length)

__inline const JString & modifyAt (const char *s)

__inline const JString & modifyAt (const char *s, ULONG offset)

__inline const JString & modifyAt (const char *s, ULONG offset, ULONG length)

__inline char getAt (ULONG nIndex) const

__inline char operator[] (long nIndex) const

__inline JString right (ULONG length)

__inline JString left (ULONG length)

__inline JString mid (const char *s, ULONG startpos, ULONG length)

__inline JString mid (const JString &S, ULONG startpos, ULONG length)

__inline JString after (const char *s)

__inline JString after (const char *s, ULONG startpos)

__inline JString after (const char *s, ULONG startpos, ULONG length)

__inline JString before (const char *s)

__inline JString before (const char *s, ULONG startpos)

__inline JString beforeStr (const char *s, ULONG startpos)

__inline JString before (const char *s, ULONG startpos, ULONG length)

JString ltrim (char ch) const

JString rtrim (char ch) const

JString trim (char ch) const

JString trimCharset (const char *charset) const

JString keepCharset (const char *charset) const

__inline JString operator() (ULONG startpos)

__inline JString operator() (ULONG startpos, ULONG length)

__inline JString operator() (const char *s)

__inline JString operator() (const JString &S)

__inline JString operator() (const char *s, ULONG startpos)

__inline JString operator() (const JString &S, ULONG startpos)

__inline JString operator() (const char *s, ULONG startpos, ULONG length)

__inline JString operator() (const JString &S, ULONG startpos, ULONG length)

__inline int compare (const JString &right) const

__inline int compare (const char *right) const

int compare (char right) const

__inline bool operator< (const JString &right) const

__inline bool operator< (const char *right) const

__inline bool operator< (char right) const

__inline bool operator> (const JString &right) const

__inline bool operator> (const char *right) const

__inline bool operator> (char right) const

__inline bool operator<= (const JString &right) const

__inline bool operator<= (const char *right) const

__inline bool operator<= (char right) const

__inline bool operator>= (const JString &right) const

__inline bool operator>= (const char *right) const

__inline bool operator>= (char right) const

__inline bool operator== (const char *right) const

__inline bool operator== (const JString &right) const

__inline bool operator== (char right) const

__inline bool operator!= (const char *right) const

__inline bool operator!= (const JString &right) const

__inline bool operator!= (char right) const

__inline operator char * () const

__inline operator int () const

__inline operator long () const

__inline operator double () const

__inline int parseInt () const

__inline long parseLong () const

__inline double parseDouble () const

char * parseString () const

__inline char * toString () const

__inline char * getText () const

void CopyBeforeWrite ()

const JString & operator= (const JString &s)

const JString & operator= (const char *s)

const JString & operator= (char ch)

void Append (const char *s, ULONG Len)

const JString & operator+= (const JString &s)

const JString & operator+= (const char *s)

const JString & operator+= (char ch)

void MakeUpper ()

void MakeLower ()

void MakeReverse ()

__inline void UCase ()

__inline void LCase ()

__inline void Reverse ()

char * getLower ()

char * getUpper ()

char * getReverse ()

__inline JString & setLower ()

__inline JString & setUpper ()

__inline JString & setReverse ()

long Find (char ch) const

long ReverseFind (char ch) const

__inline long Find (const char *s) const

long Find (const char *s, ULONG offset) const

__inline JString getFind (const char *s)

JString getFind (const char *s, ULONG offset)

__inline long Find (const JString &S) const

__inline long Find (const JString &S, ULONG offset) const

char * getConcatenate (const char *src)

JString & setConcatenate (const char *src)

char * getConcatenateWithLimits (const char *src, ULONG n)

JString & setConcatenateWithLimits (const char *src, ULONG n)

long firstCharFound (const int c)

long lastCharFound (const int c)

int compare (const char *src)

int compareIgnoreCase (const char *src)

int compareUsingLocaleCollate (const char *src)

int compareWithLimits (const char *src, ULONG n)

int compareIgnoreCaseWithLimits (const char *src, ULONG n)

char * copy ()

JString getCopy ()

char * copyWithLimits (ULONG n)

JString getCopyWithLimits (ULONG n)

ULONG getNbCharNotFromCharSet (const char *charset)

JString getDate ()

JString & setDate ()

JString & setTime (ULONG maxSize, const char *format, const struct tm *currTime)

char * duplicate ()

JString duplicateString ()

JString getError (int errnb)

JString & setError (int errnb)

JString getTimeFormat (ULONG maxSize, const char *format, const struct tm *currTime)

JString & setTimeFormat (ULONG maxSize, const char *format, const struct tm *currTime)

JString getTime ()

JString & setTime ()

char * getFillWithChar (const int ch)

JString & setFillWithChar (const int ch)

char * getFillWithChar (const int ch, ULONG n)

JString & setFillWithChar (const int ch, ULONG n)

long locateCharSet (const char *charset)

long locateCharSet (const char *charset, ULONG startAt)

ULONG findCharset (const char *charset)

ULONG findCharset (const char *charset, ULONG startAt)

long findString (const char *s)

long findString (const char *s, ULONG startAt)

double toDouble ()

double toDouble (ULONG startAt)

long toLong ()

long toLong (ULONG base)

long toLong (ULONG startAt, ULONG base)

ULONG toULONG ()

ULONG toULONG (ULONG base)

ULONG toULONG (ULONG startAt, ULONG base)

char * getTransform (const char *src, ULONG n)

JString & setTransform (const char *src, ULONG n)

char * getTokens (const char *delims, ULONG startAt)

JString getStringTokens (const char *delims, ULONG startAt)

char * getMoreTokens (const char *delims)

JString getMoreStringTokens (const char *delims)

__inline void AllocBuffer (ULONG nLen)

__inline void AllocBeforeWrite (ULONG nLen)

__inline char * LockBuffer ()

__inline void UnlockBuffer ()

void FreeExtra ()

char * GetBuffer (ULONG minBufferLength)

__inline void ReleaseBuffer ()

const JString & Add (const JString &S1, const JString &S2, const JString &S3,\const JString &S4, const JString &S5, const JString &S6,\const JString &S7, const JString &S8)

const JString & Add (const JString &S1, const JString &S2, const JString &S3,\const JString &S4, const JString &S5, const JString &S6,\const JString &S7)

const JString & Add (const JString &S1, const JString &S2, const JString &S3,\const JString &S4, const JString &S5, const JString &S6)

const JString & Add (const JString &S1, const JString &S2, const JString &S3,\const JString &S4, const JString &S5)

const JString & Add (const JString &S1, const JString &S2,\const JString &S3, const JString &S4)

const JString & Add (const JString &S1, const JString &S2, const JString &S3)

__inline bool contains (const JString &S, ULONG offset) const

__inline bool contains (const char *s, ULONG offset) const

__inline bool contains (char c, ULONG offset) const

__inline bool contains (const JString &S) const

__inline bool contains (const char *s) const

__inline bool contains (char c) const

__inline const JString & append (const JString &S)

__inline const JString & prepend (const JString &S)

__inline const JString & append (const char *s)

__inline const JString & prepend (const char *s)

__inline const JString & append (char c)

__inline const JString & prepend (char c)

JString ()

JString (const char *s)

JString (const char *s, size_t nBuffer)

JString (const JString &src)

JString (char ch)

JString (char ch, size_t nRepeat)

JString (JStringData *sd)

virtual ~JString ()

bool OK () const

bool isEmpty () const

bool isFilled () const

void Clear ()

void Empty ()

void FillString (char ch)

void FillBuffer (char ch)

void Display () const

size_t length ()

size_t getLength ()

size_t getAllocLength () const

size_t getBufferSize () const

int getLockNb () const

bool isLock () const

bool isUnlock () const

JString at (size_t startpos)

JString at (size_t startpos, size_t length)

JString at (const char *s, size_t startpos)

JString at (const char *s, size_t startpos, size_t length)

JString at ()

JString at (const char *s)

JString at (const JString &S)

JString at (const JString &S, size_t startpos)

JString at (const JString &S, size_t startpos, size_t length)

JString & setAt (size_t nIndex, char ch)

char getAt (size_t nIndex) const

char operator[] (long nIndex) const

JString right (size_t length)

JString left (size_t length)

JString mid (const char *s, size_t startpos, size_t length)

JString mid (const JString &S, size_t startpos, size_t length)

JString ltrim (char ch) const

JString rtrim (char ch) const

JString trim (char ch) const

JString trimCharset (const char *charset) const

JString keepCharset (const char *charset) const

JString operator() (size_t startpos)

JString operator() (size_t startpos, size_t length)

JString operator() (const char *s)

JString operator() (const JString &S)

JString operator() (const char *s, size_t startpos)

JString operator() (const JString &S, size_t startpos)

JString operator() (const char *s, size_t startpos, size_t length)

JString operator() (const JString &S, size_t startpos, size_t length)

int compare (const JString &right) const

int compare (const char *right) const

int compare (char right) const

bool operator< (const JString &right) const

bool operator< (const char *right) const

bool operator< (char right) const

bool operator> (const JString &right) const

bool operator> (const char *right) const

bool operator> (char right) const

bool operator<= (const JString &right) const

bool operator<= (const char *right) const

bool operator<= (char right) const

bool operator>= (const JString &right) const

bool operator>= (const char *right) const

bool operator>= (char right) const

bool operator== (const char *right) const

bool operator== (const JString &right) const

bool operator== (char right) const

bool operator!= (const char *right) const

bool operator!= (const JString &right) const

bool operator!= (char right) const

operator char * () const

operator int () const

operator long () const

operator double () const

int parseInt () const

long parseLong () const

double parseDouble () const

char * parseString () const

char * toString () const

char * getText () const

void CopyBeforeWrite ()

const JString & operator= (const JString &s)

const JString & operator= (const char *s)

const JString & operator= (char ch)

void Append (const char *s, size_t Len)

const JString & operator+= (const JString &s)

const JString & operator+= (const char *s)

const JString & operator+= (char ch)

void MakeUpper ()

void MakeLower ()

void MakeReverse ()

void UCase ()

void LCase ()

void Reverse ()

char * getLower ()

char * getUpper ()

char * getReverse ()

JString & setLower ()

JString & setUpper ()

JString & setReverse ()

JString JString::Reverse (JString &S)

JString JString::UCase (JString &S)

JString JString::LCase (JString &S)

long Find (char ch) const

long ReverseFind (char ch) const

long Find (const char *s) const

long Find (const char *s, size_t offset) const

JString getFind (const char *s)

JString getFind (const char *s, size_t offset)

char * getConcatenate (const char *src)

JString & setConcatenate (const char *src)

char * getConcatenateWithLimits (const char *src, size_t n)

JString & setConcatenateWithLimits (const char *src, size_t n)

long firstCharFound (const int c)

long lastCharFound (const int c)

int compare (const char *src)

int compareIgnoreCase (const char *src)

int compareUsingLocaleCollate (const char *src)

int compareWithLimits (const char *src, size_t n)

int compareIgnoreCaseWithLimits (const char *src, size_t n)

char * copy ()

JString getCopy ()

char * copyWithLimits (size_t n)

JString getCopyWithLimits (size_t n)

size_t getNbCharNotFromCharSet (const char *charset)

JString getDate ()

JString & setDate ()

JString & setTime (size_t maxSize, const char *format, const struct tm *currTime)

char * duplicate ()

JString duplicateString ()

JString getError (int errnb)

JString & setError (int errnb)

JString getTimeFormat (size_t maxSize, const char *format, const struct tm *currTime)

JString & setTimeFormat (size_t maxSize, const char *format, const struct tm *currTime)

JString getTime ()

JString & setTime ()

char * getFillWithChar (const int ch)

JString & setFillWithChar (const int ch)

char * getFillWithChar (const int ch, size_t n)

JString & setFillWithChar (const int ch, size_t n)

long locateCharSet (const char *charset)

long locateCharSet (const char *charset, size_t startAt)

size_t findCharset (const char *charset)

size_t findCharset (const char *charset, size_t startAt)

long findString (const char *s)

long findString (const char *s, size_t startAt)

double toDouble ()

double toDouble (size_t startAt)

long toLong ()

long toLong (size_t base)

long toLong (size_t startAt, size_t base)

ULONG toULONG ()

ULONG toULONG (size_t base)

ULONG toULONG (size_t startAt, size_t base)

char * getTransform (const char *src, size_t n)

JString & setTransform (const char *src, size_t n)

char * getTokens (const char *delims, size_t startAt)

JString getStringTokens (const char *delims, size_t startAt)

char * getMoreTokens (const char *delims)

JString getMoreStringTokens (const char *delims)

void AllocBuffer (size_t nLen)

void AllocBeforeWrite (size_t nLen)

char * LockBuffer ()

void UnlockBuffer ()

void FreeExtra ()

char * GetBuffer (size_t minBufferLength)

void ReleaseBuffer ()

JString ()

JString (const char *s)

JString (const char *s, size_t nBuffer)

JString (const JString &src)

JString (char ch)

JString (char ch, size_t nRepeat)

JString (JStringData *sd)

virtual ~JString ()

bool OK () const

bool isEmpty () const

bool isFilled () const

void Clear ()

void Empty ()

void FillString (char ch)

void FillBuffer (char ch)

__inline void Display () const

__inline size_t length ()

__inline size_t getLength ()

__inline size_t getAllocLength () const

__inline size_t getBufferSize () const

__inline int getLockNb () const

__inline bool isLock () const

__inline bool isUnlock () const

JString at (size_t startpos)

JString at (size_t startpos, size_t length)

JString at (const char *s, size_t startpos)

JString at (const char *s, size_t startpos, size_t length)

__inline JString at ()

__inline JString at (const char *s)

__inline JString at (const JString &S)

__inline JString at (const JString &S, size_t startpos)

__inline JString at (const JString &S, size_t startpos, size_t length)

JString & setAt (size_t nIndex, char ch)

__inline char charAt ()

__inline char charAt (const char *s)

__inline char charAt (const JString &S)

__inline const JString & modifyAt (const JString &S)

__inline const JString & modifyAt (const JString &S, size_t offset)

__inline const JString & modifyAt (const JString &S, size_t offset, size_t length)

__inline const JString & modifyAt (const char *s)

__inline const JString & modifyAt (const char *s, size_t offset)

__inline const JString & modifyAt (const char *s, size_t offset, size_t length)

__inline char getAt (size_t nIndex) const

__inline char operator[] (long nIndex) const

__inline JString right (size_t length)

__inline JString left (size_t length)

__inline JString mid (const char *s, size_t startpos, size_t length)

__inline JString mid (const JString &S, size_t startpos, size_t length)

__inline JString after (const char *s)

__inline JString after (const char *s, size_t startpos)

__inline JString after (const char *s, size_t startpos, size_t length)

__inline JString before (const char *s)

__inline JString before (const char *s, size_t startpos)

__inline JString beforeStr (const char *s, size_t startpos)

__inline JString before (const char *s, size_t startpos, size_t length)

JString ltrim (char ch) const

JString rtrim (char ch) const

JString trim (char ch) const

JString trimCharset (const char *charset) const

JString keepCharset (const char *charset) const

__inline JString operator() (size_t startpos)

__inline JString operator() (size_t startpos, size_t length)

__inline JString operator() (const char *s)

__inline JString operator() (const JString &S)

__inline JString operator() (const char *s, size_t startpos)

__inline JString operator() (const JString &S, size_t startpos)

__inline JString operator() (const char *s, size_t startpos, size_t length)

__inline JString operator() (const JString &S, size_t startpos, size_t length)

__inline int compare (const JString &right) const

__inline int compare (const char *right) const

int compare (char right) const

__inline bool operator< (const JString &right) const

__inline bool operator< (const char *right) const

__inline bool operator< (char right) const

__inline bool operator> (const JString &right) const

__inline bool operator> (const char *right) const

__inline bool operator> (char right) const

__inline bool operator<= (const JString &right) const

__inline bool operator<= (const char *right) const

__inline bool operator<= (char right) const

__inline bool operator>= (const JString &right) const

__inline bool operator>= (const char *right) const

__inline bool operator>= (char right) const

__inline bool operator== (const char *right) const

__inline bool operator== (const JString &right) const

__inline bool operator== (char right) const

__inline bool operator!= (const char *right) const

__inline bool operator!= (const JString &right) const

__inline bool operator!= (char right) const

__inline operator char * () const

__inline operator int () const

__inline operator long () const

__inline operator double () const

__inline int parseInt () const

__inline long parseLong () const

__inline double parseDouble () const

char * parseString () const

__inline char * toString () const

__inline char * getText () const

void CopyBeforeWrite ()

const JString & operator= (const JString &s)

const JString & operator= (const char *s)

const JString & operator= (char ch)

void Append (const char *s, size_t Len)

const JString & operator+= (const JString &s)

const JString & operator+= (const char *s)

const JString & operator+= (char ch)

void MakeUpper ()

void MakeLower ()

void MakeReverse ()

__inline void UCase ()

__inline void LCase ()

__inline void Reverse ()

char * getLower ()

char * getUpper ()

char * getReverse ()

__inline JString & setLower ()

__inline JString & setUpper ()

__inline JString & setReverse ()

long Find (char ch) const

long ReverseFind (char ch) const

__inline long Find (const char *s) const

long Find (const char *s, size_t offset) const

__inline JString getFind (const char *s)

JString getFind (const char *s, size_t offset)

__inline long Find (const JString &S) const

__inline long Find (const JString &S, size_t offset) const

char * getConcatenate (const char *src)

JString & setConcatenate (const char *src)

char * getConcatenateWithLimits (const char *src, size_t n)

JString & setConcatenateWithLimits (const char *src, size_t n)

long firstCharFound (const int c)

long lastCharFound (const int c)

int compareIgnoreCase (const char *src)

int compareUsingLocaleCollate (const char *src)

int compareWithLimits (const char *src, size_t n)

int compareIgnoreCaseWithLimits (const char *src, size_t n)

char * copy ()

JString getCopy ()

char * copyWithLimits (size_t n)

JString getCopyWithLimits (size_t n)

size_t getNbCharNotFromCharSet (const char *charset)

JString getDate ()

JString & setDate ()

JString & setTime (size_t maxSize, const char *format, const struct tm *currTime)

char * duplicate ()

JString duplicateString ()

JString getError (int errnb)

JString & setError (int errnb)

JString getTimeFormat (size_t maxSize, const char *format, const struct tm *currTime)

JString & setTimeFormat (size_t maxSize, const char *format, const struct tm *currTime)

JString getTime ()

JString & setTime ()

char * getFillWithChar (const int ch)

JString & setFillWithChar (const int ch)

char * getFillWithChar (const int ch, size_t n)

JString & setFillWithChar (const int ch, size_t n)

long locateCharSet (const char *charset)

long locateCharSet (const char *charset, size_t startAt)

size_t findCharset (const char *charset)

size_t findCharset (const char *charset, size_t startAt)

long findString (const char *s)

long findString (const char *s, size_t startAt)

double toDouble ()

double toDouble (size_t startAt)

long toLong ()

long toLong (size_t base)

long toLong (size_t startAt, size_t base)

ULONG toULONG ()

ULONG toULONG (size_t base)

ULONG toULONG (size_t startAt, size_t base)

char * getTransform (const char *src, size_t n)

JString & setTransform (const char *src, size_t n)

char * getTokens (const char *delims, size_t startAt)

JString getStringTokens (const char *delims, size_t startAt)

char * getMoreTokens (const char *delims)

JString getMoreStringTokens (const char *delims)

__inline void AllocBuffer (size_t nLen)

__inline void AllocBeforeWrite (size_t nLen)

__inline char * LockBuffer ()

__inline void UnlockBuffer ()

void FreeExtra ()

char * GetBuffer (size_t minBufferLength)

__inline void ReleaseBuffer ()

const JString & Add (const JString &S1, const JString &S2, const JString &S3,\const JString &S4, const JString &S5, const JString &S6,\const JString &S7, const JString &S8)

const JString & Add (const JString &S1, const JString &S2, const JString &S3,\const JString &S4, const JString &S5, const JString &S6,\const JString &S7)

const JString & Add (const JString &S1, const JString &S2, const JString &S3,\const JString &S4, const JString &S5, const JString &S6)

const JString & Add (const JString &S1, const JString &S2, const JString &S3,\const JString &S4, const JString &S5)

const JString & Add (const JString &S1, const JString &S2,\const JString &S3, const JString &S4)

const JString & Add (const JString &S1, const JString &S2, const JString &S3)

__inline bool contains (const JString &S, size_t offset) const

__inline bool contains (const char *s, size_t offset) const

__inline bool contains (char c, size_t offset) const

__inline bool contains (const JString &S) const

__inline bool contains (const char *s) const

__inline bool contains (char c) const

__inline const JString & append (const JString &S)

__inline const JString & prepend (const JString &S)

__inline const JString & append (const char *s)

__inline const JString & prepend (const char *s)

__inline const JString & append (char c)

__inline const JString & prepend (char c)

Private Methods

__inline void Add (const char *s1, const char *s2, ULONG Len1, ULONG Len2)

void Add (const char *s1, const char *s2, ULONG Len1, ULONG Len2, ULONG LenExtra)

void Add (const char *s1=NULL, ULONG Len1=0,\const char *s2=NULL, ULONG Len2=0,\const char *s3=NULL, ULONG Len3=0,\const char *s4=NULL, ULONG Len4=0,\const char *s5=NULL, ULONG Len5=0,\const char *s6=NULL, ULONG Len6=0,\const char *s7=NULL, ULONG Len7=0,\const char *s8=NULL, ULONG Len8=0,\const char *s9=NULL, ULONG Len9=0,\ULONG LenExtra=0)

void Add (const char *s1, const char *s2, size_t Len1, size_t Len2)

__inline void Add (const char *s1, const char *s2, size_t Len1, size_t Len2)

void Add (const char *s1, const char *s2, size_t Len1, size_t Len2, size_t LenExtra)

void Add (const char *s1=NULL, size_t Len1=0,\const char *s2=NULL, size_t Len2=0,\const char *s3=NULL, size_t Len3=0,\const char *s4=NULL, size_t Len4=0,\const char *s5=NULL, size_t Len5=0,\const char *s6=NULL, size_t Len6=0,\const char *s7=NULL, size_t Len7=0,\const char *s8=NULL, size_t Len8=0,\const char *s9=NULL, size_t Len9=0,\size_t LenExtra=0)

Private Attributes

JStringData * pData

friend JSubString

JStringData * pData

JStringData * pData

Friends

ostream & operator<< (ostream &os, const JString &s)

JString operator+ (const JString &s1, const JString &s2)

JString operator+ (const JString &s1, const char *s2)

JString operator+ (const char *s1, const JString &s2)

JString operator+ (const JString &s, char ch)

JString operator+ (char ch, const JString &s)

ostream & operator<< (ostream &os, const JString &s)

JString operator+ (const JString &s1, const JString &s2)

JString operator+ (const JString &s1, const char *s2)

JString operator+ (const char *s1, const JString &s2)

JString operator+ (const JString &s, char ch)

JString operator+ (char ch, const JString &s)

ostream & operator<< (ostream &os, const JString &s)

JString operator+ (const JString &s1, const JString &s2)

JString operator+ (const JString &s1, const char *s2)

JString operator+ (const char *s1, const JString &s2)

JString operator+ (const JString &s, char ch)

JString operator+ (char ch, const JString &s)

Constructor & Destructor Documentation

__inline JString::JString ( )

Constructor, Copy Constructor and Destructor //////////////////////////////////////////////////////////////////////////// Defined in: StrBuild.cpp ////////////////////////////////////////////////////////////////////////////.

Definition at line 10 of file StrBuild.cpp.
Referenced by at(), duplicateString(), getCopy(), getCopyWithLimits(), getDate(), getError(), getFind(), getMoreStringTokens(), getStringTokens(), getTime(), getTimeFormat(), keepCharset(), ltrim(), rtrim(), trim(), and trimCharset().

00011 : pData( strNull ) { }

__inline JString::JString ( const char * s )

Definition at line 21 of file StrBuild.cpp.
00022 { 00023 if ( s != NULL && *s != NULL ) { 00024 pData = new JStringData( s ); 00025 } else { 00026 pData = strNull; 00027 } 00028 }

__inline JString::JString ( const char * s,

ULONG nBuffer

)

Definition at line 44 of file StrBuild.cpp.
00045 { 00046 if ( nBuffer < 1 ) { 00047 pData = strNull; 00048 } else { 00049 pData = new JStringData( s, nBuffer ); 00050 } 00051 }

__inline JString::JString ( const JString & src )

Definition at line 61 of file StrBuild.cpp.
00062 : pData( src.pData ) 00063 { 00064 pData->Inc(); 00065 }

__inline JString::JString ( char ch )

Definition at line 53 of file StrBuild.cpp.
00054 : pData( new JStringData( ch, 1 ) ) { }

__inline JString::JString ( char ch,

ULONG nRepeat

)

Definition at line 56 of file StrBuild.cpp.
00057 : pData( new JStringData( ch, nRepeat ) ) { }

__inline JString::JString ( JStringData * sd )

Definition at line 13 of file StrBuild.cpp.
00014 : pData( sd ) 00015 { 00016 if ( sd == NULL ) { 00017 pData = strNull; 00018 } 00019 }

__inline JString::~JString ( ) [virtual]

Definition at line 68 of file StrBuild.cpp.
00068 { 00069 00070 #ifdef __J2K__DEBUG 00071 printf("\nDelete JString[%s]\n", pData->data ); 00072 #endif 00073 00074 pData->Dec(); 00075 }

JString::JString ( )

Constructor, Copy Constructor and Destructor //////////////////////////////////////////////////////////////////////////// Defined in: StrBuild.cpp ////////////////////////////////////////////////////////////////////////////.

JString::JString ( const char * s )

__inline JString::JString ( const char * s,

size_t nBuffer

)

Definition at line 39 of file StrBuild.cpp.
00040 : pData( new JStringData( s, nBuffer ) ) { }

JString::JString ( const JString & src )

JString::JString ( char ch )

__inline JString::JString ( char ch,

size_t nRepeat

)

Definition at line 45 of file StrBuild.cpp.
00046 : pData( new JStringData( ch, nRepeat ) ) { }

JString::JString ( JStringData * sd )

virtual JString::~JString ( ) [virtual]

JString::JString ( const char * s )

JString::JString ( const char * s,

size_t nBuffer

)

JString::JString ( const JString & src )

JString::JString ( char ch )

JString::JString ( char ch,

size_t nRepeat

)

JString::JString ( JStringData * sd )

virtual JString::~JString ( ) [virtual]

Member Function Documentation

const JString& JString::Add ( const JString & S1,

const JString & S2,

const JString & S3

)

const JString& JString::Add ( const JString & S1,

const JString & S2,

\const JString & S3,

const JString & S4

)

const JString& JString::Add ( const JString & S1,

const JString & S2,

const JString & S3,

\const JString & S4,

const JString & S5

)

const JString& JString::Add ( const JString & S1,

const JString & S2,

const JString & S3,

\const JString & S4,

const JString & S5,

const JString & S6

)

const JString& JString::Add ( const JString & S1,

const JString & S2,

const JString & S3,

\const JString & S4,

const JString & S5,

const JString & S6,

\const JString & S7

)

void JString::Add ( const char * s1 = NULL,

size_t Len1 = 0,

\const char * s2 = NULL,

size_t Len2 = 0,

\const char * s3 = NULL,

size_t Len3 = 0,

\const char * s4 = NULL,

size_t Len4 = 0,

\const char * s5 = NULL,

size_t Len5 = 0,

\const char * s6 = NULL,

size_t Len6 = 0,

\const char * s7 = NULL,

size_t Len7 = 0,

\const char * s8 = NULL,

size_t Len8 = 0,

\const char * s9 = NULL,

size_t Len9 = 0,

\size_t LenExtra = 0

) [private]

Extra stuff for compatibility with the widely used Linux String class ///////////////////////////////////////////////////////////////////////////// Defined in: StrLinux.cpp (NOT FULLY SUPPORTED YET) /////////////////////////////////////////////////////////////////////////////.

Definition at line 8 of file StrLinux.cpp.
00018 { 00019 // -- Modify THIS JString Object. 00020 00021 // Take care of NULL JString parameters, if any. 00022 if ( s1 == NULL || *s1 == '\0' ) { Len1 = 0; } 00023 if ( s2 == NULL || *s2 == '\0' ) { Len2 = 0; } 00024 if ( s3 == NULL || *s3 == '\0' ) { Len3 = 0; } 00025 if ( s4 == NULL || *s4 == '\0' ) { Len4 = 0; } 00026 if ( s5 == NULL || *s5 == '\0' ) { Len5 = 0; } 00027 if ( s6 == NULL || *s6 == '\0' ) { Len6 = 0; } 00028 if ( s7 == NULL || *s7 == '\0' ) { Len7 = 0; } 00029 if ( s8 == NULL || *s8 == '\0' ) { Len8 = 0; } 00030 if ( s9 == NULL || *s9 == '\0' ) { Len9 = 0; } 00031 00032 size_t newLen = Len1 + Len2 + Len3 + Len4 + Len5 + Len6 + Len7 + Len8 + Len9; 00033 00034 // Don't delete now, since memcpy will occur 00035 // in the case we delete ourself before copy ! 00036 JStringData* sd = pData; 00037 00038 if ( newLen > 0 ) { 00039 00040 pData = new JStringData( newLen + LenExtra ); 00041 00042 size_t pos = 0; 00043 00044 if ( Len1 > 0 ) { memcpy( pData->data + pos, s1, Len1 ); pos += Len1; } 00045 if ( Len2 > 0 ) { memcpy( pData->data + pos, s2, Len2 ); pos += Len2; } 00046 if ( Len3 > 0 ) { memcpy( pData->data + pos, s3, Len3 ); pos += Len3; } 00047 if ( Len4 > 0 ) { memcpy( pData->data + pos, s4, Len4 ); pos += Len4; } 00048 if ( Len5 > 0 ) { memcpy( pData->data + pos, s5, Len5 ); pos += Len5; } 00049 if ( Len6 > 0 ) { memcpy( pData->data + pos, s6, Len6 ); pos += Len6; } 00050 if ( Len7 > 0 ) { memcpy( pData->data + pos, s7, Len7 ); pos += Len7; } 00051 if ( Len8 > 0 ) { memcpy( pData->data + pos, s8, Len8 ); pos += Len8; } 00052 if ( Len9 > 0 ) { memcpy( pData->data + pos, s9, Len9 ); pos += Len9; } 00053 00054 pData->length = newLen; 00055 pData->data[ newLen ] = '\0'; 00056 00057 /* 00058 This Null ending is needed since the last string 00059 might not be ended by '\0' or in case the copy 00060 doesn't go up to Zero. To be checked! 00061 00062 i.e. If we pass a 'char c' as &c instead of a char* s = { c, 0 } 00063 */ 00064 00065 } else { // strNull 00066 pData = strNull; 00067 } 00068 00069 sd->Dec(); // Now you can suicide, we don't care. 00070 }

void JString::Add ( const char * s1,

const char * s2,

size_t Len1,

size_t Len2,

size_t LenExtra

) [private]

Concatenation of JStrings /// "operator+" is done as friend functions for simplicity /// There are five variants: /// JString + JString /// JString + char /// JString + const char* /// char + JString /// const char* + JString /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////.

Definition at line 53 of file StrAdd.cpp.
00055 { 00056 // -- Modify THIS JString Object. 00057 00058 // Take care of NULL JString parameters, if any. 00059 if ( s1 == NULL || *s2 == (char)NULL ) { Len1 = 0; } 00060 if ( s2 == NULL || *s2 == (char)NULL ) { Len2 = 0; } 00061 00062 size_t newLen = Len1 + Len2; 00063 00064 // Don't delete now, since memcpy will occur 00065 // in the case we delete ourself before copy ! 00066 JStringData* sd = pData; 00067 00068 pData = new JStringData( newLen + LenExtra ); 00069 00070 // Will fill this String with '\0' 00071 00072 if ( Len1 > 0 ) { memcpy( pData->data, s1, Len1 ); } 00073 if ( Len2 > 0 ) { memcpy( pData->data + Len1, s2, Len2 ); } 00074 00075 pData->length = newLen; 00076 pData->data[ newLen ] = '\0'; 00077 00078 /* 00079 This Null ending is needed since the last string 00080 might not be ended by '\0' or in case the copy 00081 doesn't go up to Zero. To be checked! 00082 */ 00083 00084 sd->Dec(); // Now you can suicide, we don't care. 00085 }

__inline void JString::Add ( const char * s1,

const char * s2,

size_t Len1,

size_t Len2

) [private]

JString Addition //////////////////////////////////////////////////////////////////////////// Defined in: StrAdd.cpp ////////////////////////////////////////////////////////////////////////////.

const JString & JString::Add ( const JString & S1,

const JString & S2,

const JString & S3

)

Definition at line 131 of file StrLinux.cpp.
00132 { 00133 Add( pData->data, pData->length, S1.pData->data, S1.pData->length, \ 00134 S2.pData->data, S2.pData->length, \ 00135 S3.pData->data, S3.pData->length ); 00136 00137 return *this; 00138 }

const JString& JString::Add ( const JString & S1,

const JString & S2,

\const JString & S3,

const JString & S4

)

const JString& JString::Add ( const JString & S1,

const JString & S2,

const JString & S3,

\const JString & S4,

const JString & S5

)

const JString & JString::Add ( const JString & S1,

const JString & S2,

const JString & S3,

\const JString & S4,

const JString & S5,

const JString & S6

)

Definition at line 99 of file StrLinux.cpp.
00101 { 00102 Add( pData->data, pData->length, S1.pData->data, S1.pData->length, \ 00103 S2.pData->data, S2.pData->length, \ 00104 S3.pData->data, S3.pData->length, S4.pData->data, S4.pData->length, \ 00105 S5.pData->data, S5.pData->length, S6.pData->data, S6.pData->length ); 00106 00107 return *this; 00108 }

const JString & JString::Add ( const JString & S1,

const JString & S2,

const JString & S3,

\const JString & S4,

const JString & S5,

const JString & S6,

\const JString & S7

)

Definition at line 86 of file StrLinux.cpp.
00089 { 00090 Add( pData->data, pData->length, S1.pData->data, S1.pData->length, \ 00091 S2.pData->data, S2.pData->length, \ 00092 S3.pData->data, S3.pData->length, S4.pData->data, S4.pData->length, \ 00093 S5.pData->data, S5.pData->length, S6.pData->data, S6.pData->length, \ 00094 S7.pData->data, S7.pData->length ); 00095 00096 return *this; 00097 }

const JString & JString::Add ( const JString & S1,

const JString & S2,

const JString & S3,

\const JString & S4,

const JString & S5,

const JString & S6,

\const JString & S7,

const JString & S8

)

Definition at line 72 of file StrLinux.cpp.
00075 { 00076 Add( pData->data, pData->length, S1.pData->data, S1.pData->length, \ 00077 S2.pData->data, S2.pData->length, \ 00078 S3.pData->data, S3.pData->length, S4.pData->data, S4.pData->length, \ 00079 S5.pData->data, S5.pData->length, S6.pData->data, S6.pData->length, \ 00080 S7.pData->data, S7.pData->length, S8.pData->data, S8.pData->length, 0 ); 00081 00082 return *this; 00083 }

void JString::Add ( const char * s1 = NULL,

ULONG Len1 = 0,

\const char * s2 = NULL,

ULONG Len2 = 0,

\const char * s3 = NULL,

ULONG Len3 = 0,

\const char * s4 = NULL,

ULONG Len4 = 0,

\const char * s5 = NULL,

ULONG Len5 = 0,

\const char * s6 = NULL,

ULONG Len6 = 0,

\const char * s7 = NULL,

ULONG Len7 = 0,

\const char * s8 = NULL,

ULONG Len8 = 0,

\const char * s9 = NULL,

ULONG Len9 = 0,

\ULONG LenExtra = 0

) [private]

Extra stuff for compatibility with the widely used Linux String class ///////////////////////////////////////////////////////////////////////////// Defined in: StrLinux.cpp (NOT FULLY SUPPORTED YET) /////////////////////////////////////////////////////////////////////////////.

Definition at line 8 of file StrLinux.cpp.
00018 { 00019 // -- Modify THIS JString Object. 00020 00021 // Take care of NULL JString parameters, if any. 00022 if ( s1 == NULL || *s1 == '\0' ) { Len1 = 0; } 00023 if ( s2 == NULL || *s2 == '\0' ) { Len2 = 0; } 00024 if ( s3 == NULL || *s3 == '\0' ) { Len3 = 0; } 00025 if ( s4 == NULL || *s4 == '\0' ) { Len4 = 0; } 00026 if ( s5 == NULL || *s5 == '\0' ) { Len5 = 0; } 00027 if ( s6 == NULL || *s6 == '\0' ) { Len6 = 0; } 00028 if ( s7 == NULL || *s7 == '\0' ) { Len7 = 0; } 00029 if ( s8 == NULL || *s8 == '\0' ) { Len8 = 0; } 00030 if ( s9 == NULL || *s9 == '\0' ) { Len9 = 0; } 00031 00032 ULONG newLen = Len1 + Len2 + Len3 + Len4 + Len5 + Len6 + Len7 + Len8 + Len9; 00033 00034 // Don't delete now, since memcpy will occur 00035 // in the case we delete ourself before copy ! 00036 JStringData* sd = pData; 00037 00038 if ( newLen > 0 ) { 00039 00040 pData = new JStringData( newLen + LenExtra ); 00041 00042 ULONG pos = 0; 00043 00044 if ( Len1 > 0 ) { memcpy( pData->data + pos, s1, Len1 ); pos += Len1; } 00045 if ( Len2 > 0 ) { memcpy( pData->data + pos, s2, Len2 ); pos += Len2; } 00046 if ( Len3 > 0 ) { memcpy( pData->data + pos, s3, Len3 ); pos += Len3; } 00047 if ( Len4 > 0 ) { memcpy( pData->data + pos, s4, Len4 ); pos += Len4; } 00048 if ( Len5 > 0 ) { memcpy( pData->data + pos, s5, Len5 ); pos += Len5; } 00049 if ( Len6 > 0 ) { memcpy( pData->data + pos, s6, Len6 ); pos += Len6; } 00050 if ( Len7 > 0 ) { memcpy( pData->data + pos, s7, Len7 ); pos += Len7; } 00051 if ( Len8 > 0 ) { memcpy( pData->data + pos, s8, Len8 ); pos += Len8; } 00052 if ( Len9 > 0 ) { memcpy( pData->data + pos, s9, Len9 ); pos += Len9; } 00053 00054 pData->length = newLen; 00055 pData->data[ newLen ] = '\0'; 00056 00057 /* 00058 This Null ending is needed since the last string 00059 might not be ended by '\0' or in case the copy 00060 doesn't go up to Zero. To be checked! 00061 00062 i.e. If we pass a 'char c' as &c instead of a char* s = { c, 0 } 00063 */ 00064 00065 } else { // strNull 00066 pData = strNull; 00067 } 00068 00069 sd->Dec(); // Now you can suicide, we don't care. 00070 }

void JString::Add ( const char * s1,

const char * s2,

ULONG Len1,

ULONG Len2,

ULONG LenExtra

) [private]

Concatenation of JStrings /// "operator+" is done as friend functions for simplicity /// There are five variants: /// JString + JString /// JString + char /// JString + const char* /// char + JString /// const char* + JString /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////.

Definition at line 53 of file StrAdd.cpp.
00055 { 00056 // -- Modify THIS JString Object. 00057 00058 // Take care of NULL JString parameters, if any. 00059 if ( s1 == NULL || *s2 == (char)NULL ) { Len1 = 0; } 00060 if ( s2 == NULL || *s2 == (char)NULL ) { Len2 = 0; } 00061 00062 ULONG newLen = Len1 + Len2; 00063 00064 00065 // Don't delete now, since memcpy will occur 00066 // in the case we delete ourself before copy ! 00067 JStringData* sd = pData; 00068 00069 if ( newLen > 0 ) { 00070 pData = new JStringData( newLen + LenExtra ); 00071 00072 if ( Len1 > 0 ) { memcpy( pData->data, s1, Len1); } 00073 if ( Len2 > 0 ) { memcpy( pData->data + Len1, s2, Len2); } 00074 00075 pData->length = newLen; 00076 pData->data[ newLen ] = '\0'; 00077 00078 /* 00079 This Null ending is needed since the last string 00080 might not be ended by '\0' or in case the copy 00081 doesn't go up to Zero. To be checked! 00082 */ 00083 00084 } else { // strNull 00085 pData = strNull; 00086 } 00087 00088 sd->Dec(); // Now you can suicide, we don't care. 00089 }

__inline void JString::Add ( const char * s1,

const char * s2,

ULONG Len1,

ULONG Len2

) [private]

JString Addition //////////////////////////////////////////////////////////////////////////// Defined in: StrAdd.cpp ////////////////////////////////////////////////////////////////////////////.

Definition at line 43 of file StrAdd.inl.
Referenced by Add(), Append(), append(), cat(), operator+(), and prepend().

00045 { 00046 Add( s1, s2, Len1, Len2, 0 ); 00047 }

__inline void JString::AllocBeforeWrite ( size_t nLen )

__inline void JString::AllocBeforeWrite ( size_t Len ) [inline]

Definition at line 42 of file StrExtra.cpp.
00042 { 00043 if ( pData == strNull || pData->nbRefs > 1 || Len > pData->bufferSize ) { 00044 pData->Dec(); 00045 pData = new JStringData( Len ); 00046 } 00047 }

__inline void JString::AllocBeforeWrite ( ULONG Len )

Definition at line 42 of file StrExtra.cpp.
00042 { 00043 if ( pData == strNull || pData->nbRefs > 1 || Len > pData->bufferSize ) { 00044 pData->Dec(); 00045 pData = new JStringData( Len ); 00046 } 00047 }

__inline void JString::AllocBuffer ( size_t nLen )

Unlock/Lock Buffer turn Ref counting on/off (MFC JString compatible) /// AND everything else related to Buffer and Allocation... //////////////////////////////////////////////////////////////////////////// Defined in: StrExtra.cpp (NOT FULLY SUPPORTED YET) ////////////////////////////////////////////////////////////////////////////.

__inline void JString::AllocBuffer ( size_t Len ) [inline]

Unlock/Lock Buffer turn Ref counting on/off (MFC JString compatible) /// AND everything else related to Buffer and Allocation... //////////////////////////////////////////////////////////////////////////// Defined in: StrExtra.cpp (NOT FULLY SUPPORTED YET) ////////////////////////////////////////////////////////////////////////////.
I didn't know the term "external usage". What does that mean ? That users of the class can use these methods but implementer are forbidden to ?
No, it comes from CString, it means that users are able to screw up the char* as they want.
"External usage of internal privates..."
Definition at line 37 of file StrExtra.cpp.
00037 { 00038 pData->Dec(); 00039 pData = new JStringData( Len ); 00040 }

__inline void JString::AllocBuffer ( ULONG Len )

Unlock/Lock Buffer turn Ref counting on/off (MFC JString compatible) /// AND everything else related to Buffer and Allocation... //////////////////////////////////////////////////////////////////////////// Defined in: StrExtra.cpp (NOT FULLY SUPPORTED YET) ////////////////////////////////////////////////////////////////////////////.
I didn't know the term "external usage". What does that mean ? That users of the class can use these methods but implementer are forbidden to ?
No, it comes from CString, it means that users are able to screw up the char* as they want.
"External usage of internal privates..."
Definition at line 37 of file StrExtra.cpp.
00037 { 00038 pData->Dec(); 00039 pData = new JStringData( Len ); 00040 }

void JString::Append ( const char * s,

size_t Len

)

JString Concatenation //////////////////////////////////////////////////////////////////////////// Defined in: StrAdd.cpp ////////////////////////////////////////////////////////////////////////////.

Definition at line 96 of file StrAdd.cpp.
00096 { 00097 00098 if ( s == NULL || *s == (char)NULL ) return; // Nothing to do, so Return. 00099 00100 size_t newSize = pData->length + Len; 00101 00102 if ( pData == strNull || pData->nbRefs > 1 || newSize > pData->bufferSize ) 00103 { 00104 00105 //////////////////////////////////////////////////////////////////////////// 00106 /// If the buffer is too small, or if we have a width mismatch, /// 00107 /// or if THIS points to strNull then we must allocate a new buffer /// 00108 /// (Worst Case) /// 00109 //////////////////////////////////////////////////////////////////////////// 00110 Add(pData->data, s, pData->length, Len ); // Add() call Dec() already ! 00111 00112 } else { 00113 00114 //////////////////////////////////////////////////////////////////////////// 00115 /// If the buffer is big enough, append the new JString to the buffer. /// 00116 /// (Best Case) /// 00117 //////////////////////////////////////////////////////////////////////////// 00118 memcpy( (pData->data + pData->length), s, Len); 00119 00120 assert( (pData->length + Len ) <= (pData->bufferSize) ); 00121 pData->length = newSize; 00122 pData->data[ pData->length ] = '\0'; 00123 } 00124 }

void JString::Append ( const char * s,

ULONG Len

)

JString Concatenation //////////////////////////////////////////////////////////////////////////// Defined in: StrAdd.cpp ////////////////////////////////////////////////////////////////////////////.

Definition at line 100 of file StrAdd.cpp.
Referenced by operator+=().

00100 { 00101 00102 if ( s == NULL || *s == (char)NULL ) return; // Nothing to do, so Return. 00103 00104 ULONG newSize = pData->length + Len; 00105 00106 if ( pData == strNull || pData->nbRefs > 1 || newSize > pData->bufferSize ) 00107 { 00108 00109 //////////////////////////////////////////////////////////////////////////// 00110 /// If the buffer is too small, or if we have a width mismatch, /// 00111 /// or if THIS points to strNull then we must allocate a new buffer /// 00112 /// (Worst Case) /// 00113 //////////////////////////////////////////////////////////////////////////// 00114 Add(pData->data, s, pData->length, Len ); // Add() call Dec() already ! 00115 00116 } else { 00117 00118 //////////////////////////////////////////////////////////////////////////// 00119 /// If the buffer is big enough, append the new JString to the buffer. /// 00120 /// (Best Case) /// 00121 //////////////////////////////////////////////////////////////////////////// 00122 memcpy( (pData->data + pData->length), s, Len); 00123 00124 assert( (pData->length + Len ) <= (pData->bufferSize) ); 00125 pData->length = newSize; 00126 pData->data[ pData->length ] = '\0'; 00127 } 00128 }

void JString::Clear ( )

void JString::Clear ( )

Definition at line 16 of file StrTools.cpp.
00016 { 00017 if ( pData == strNull ) return; 00018 if ( pData->nbRefs == 1 && pData->lock == 0 ) { 00019 pData->Clear( '\0' ); 00020 } else { 00021 pData->Dec(); 00022 pData = strNull; 00023 } 00024 }

void JString::CopyBeforeWrite ( )

JString Assignment //////////////////////////////////////////////////////////////////////////// Defined in: StrAdd.cpp ////////////////////////////////////////////////////////////////////////////.

Definition at line 26 of file StrAdd.cpp.
Referenced by MakeLower(), MakeReverse(), MakeUpper(), modifyAt(), and setAt().

00026 { 00027 if ( pData == strNull || pData->nbRefs > 1 || pData->lock != 0 ) { 00028 JStringData* sd = pData; 00029 pData = new JStringData( *sd ); 00030 sd->Dec(); 00031 } 00032 00033 #ifdef __J2K__DEBUG 00034 else { 00035 printf("Data is unique, so no copy was made !\n"); 00036 } 00037 #endif 00038 00039 }

__inline void JString::Display ( ) const

void JString::Display ( ) const [inline]

__inline void JString::Display ( ) const

Definition at line 37 of file StrTools.inl.
00037 { 00038 cout << pData->data; 00039 }

void JString::Empty ( )

void JString::Empty ( )

Definition at line 7 of file StrTools.cpp.
00007 { 00008 if ( pData == strNull ) return; 00009 if ( pData->length == 0 ) return; 00010 00011 // Okay like that, for Lock and Sharing. 00012 pData->Dec(); 00013 pData = strNull; 00014 }

void JString::FillBuffer ( char ch )

void JString::FillBuffer ( char ch )

Definition at line 45 of file StrTools.cpp.
00045 { 00046 register ULONG i = 0; 00047 if ( pData->bufferSize < 1 ) return; 00048 if ( pData->nbRefs == 1 && pData != strNull && pData->lock == 0 ) { 00049 for( ; i < pData->bufferSize; i++ ) { 00050 pData->data[i] = ch; 00051 } 00052 } else { 00053 JStringData* sd = pData; 00054 pData = new JStringData( ch, pData->bufferSize, pData->bufferSize ); 00055 sd->Dec(); 00056 } 00057 pData->length = pData->bufferSize; 00058 pData->data[pData->length] = '\0'; 00059 }

void JString::FillString ( char ch )

void JString::FillString ( char ch )

Definition at line 26 of file StrTools.cpp.
00026 { 00027 register ULONG i = 0; 00028 if ( pData->length < 1 ) return; 00029 if ( pData->nbRefs == 1 && pData != strNull && pData->lock == 0 ) { 00030 for( ; i < pData->length; i++ ) { 00031 pData->data[i] = ch; 00032 } 00033 for( i = pData->length; i <= pData->bufferSize; i++ ) { 00034 pData->data[i] = '\0'; 00035 } 00036 } else { 00037 ULONG nRepeat = pData->length; 00038 JStringData* sd = pData; 00039 pData = new JStringData(ch, pData->length, pData->bufferSize ); 00040 sd->Dec(); 00041 } 00042 pData->data[pData->length] = '\0'; 00043 }

__inline long JString::Find ( const JString & S,

size_t sz

) const

Definition at line 17 of file StrFind.inl.
00018 { 00019 return Find( S.parseString(), sz ); 00020 }

__inline long JString::Find ( const JString & S ) const

long JString::Find ( const char * s,

size_t offset

) const

__inline long JString::Find ( const char * s ) const

long JString::Find ( char ch ) const

Search/Find/ReverseFind function (QuickBasic Compatible) //////////////////////////////////////////////////////////////////////////// Defined in: StrFind.cpp ////////////////////////////////////////////////////////////////////////////.

long JString::Find ( const char * s,

size_t offset

) const

Definition at line 12 of file StrFind.cpp.
00012 { 00013 if ( s == NULL ) return (-1); // If null then -1 00014 if ( offset >= pData->length ) return (-1); 00015 char* p = pData->data + offset; 00016 char* s2 = strstr(p, s); 00017 return ( (s2 == NULL) ? (long)(-1) : (long)(s2 - p) ); 00018 }

long JString::Find ( const char * s ) const [inline]

__inline long JString::Find ( const JString & S,

ULONG sz

) const

Definition at line 17 of file StrFind.inl.
00018 { 00019 return Find( S.parseString(), sz ); 00020 }

__inline long JString::Find ( const JString & S ) const

Definition at line 12 of file StrFind.inl.
00013 { 00014 return Find( S.parseString(), 0 ); 00015 }

long JString::Find ( const char * s,

ULONG offset

) const

Definition at line 12 of file StrFind.cpp.
00012 { 00013 if ( s == NULL ) return (-1); // If null then -1 00014 if ( offset >= pData->length ) return (-1); 00015 char* p = pData->data + offset; 00016 char* s2 = strstr(p, s); 00017 return ( (s2 == NULL) ? (long)(-1) : (long)(s2 - p) ); 00018 }

__inline long JString::Find ( const char * s ) const

Definition at line 41 of file StrFind.inl.
00041 { 00042 return Find( s, 0 ); 00043 }

__inline long JString::Find ( char ch ) const

Search/Find/ReverseFind function (QuickBasic Compatible) //////////////////////////////////////////////////////////////////////////// Defined in: StrFind.cpp ////////////////////////////////////////////////////////////////////////////.

Definition at line 22 of file StrFind.inl.
Referenced by Find(), after(), before(), beforeStr(), contains(), and modifyAt().

00022 { 00023 // find first single character 00024 // return -1 if not found and index otherwise 00025 for( ULONG l = 0; l < pData->length; l++ ) { 00026 if ( pData->data[l] == ch ) return l; 00027 } 00028 return (-1); 00029 }

void JString::FreeExtra ( )

void JString::FreeExtra ( )

ANDREA ***************************************************.
After calling ReleaseBuffer the string object is pointing to an istance of JStringData that has been destroyed.
NO? Unless the user delete it ? I should check maybe for pData == NULL ?
This means that when the string object will be destroyed too it will call Dec() on a dead object. This means undefined behaviour.
hmmm.
Definition at line 130 of file StrExtra.cpp.
00130 { 00131 if (pData == strNull ) return; 00132 if (pData->length <= 0 ) { 00133 pData->Dec(); 00134 pData = strNull; 00135 return; 00136 } 00137 00138 if (pData->length < pData->bufferSize) { 00139 JStringData* pOldData = pData; 00140 pData = new JStringData( pOldData->data, pOldData->length ); 00141 pOldData->Dec(); 00142 } 00143 }

char* JString::GetBuffer ( size_t minBufferLength )

char * JString::GetBuffer ( size_t minBuf )

Definition at line 53 of file StrExtra.cpp.
00053 { 00054 00055 if (pData == strNull) { 00056 return ""; 00057 } 00058 00059 /** ANDREA *************************************************** 00060 00061 We are ignoring the minBuf parameter. Is this the intended 00062 behaviour ? This surprises me. It means that 00063 00064 char *b=s.GetBuffer(100); 00065 // Now i've a pointer to 100 chars (minimum) 00066 // or may be not if the string was initially empty. 00067 00068 If it's empty then you get nothing, maybe I could provide an empty bigger ?! 00069 00070 *************************************************************/ 00071 00072 if (pData->lock != 0) { // Already locked ! 00073 pData->lock++; 00074 return pData->data; 00075 } 00076 00077 /** ANDREA *************************************************** 00078 00079 Here we ignored the minBuf parameter. Is this correct ? 00080 This surprises me even more. 00081 00082 char *b=s.GetBuffer(100); 00083 // Now i've a pointer to 100 chars (minimum) 00084 // or may be less if someone got the buffer too 00085 // before me and asked for a smaller minimum size. 00086 00087 If it's lock it's lock. 00088 It's not expected behavior. 00089 00090 *************************************************************/ 00091 00092 if ( pData->nbRefs > 1 || minBuf > pData->bufferSize) { 00093 // We have to create a new buffer 00094 if ( minBuf < pData->length ) { 00095 minBuf = pData->length; 00096 } 00097 00098 JStringData* pOldData = pData; 00099 pData = new JStringData( pData->data, minBuf ); 00100 pOldData->Dec(); 00101 } 00102 00103 pData->lock = 1; 00104 00105 // return a pointer to the character storage for this JString 00106 return pData->data; 00107 }

char * JString::GetBuffer ( ULONG minBuf )

Definition at line 53 of file StrExtra.cpp.
Referenced by LockBuffer().

00053 { 00054 00055 if (pData == strNull) { 00056 return ""; 00057 } 00058 00059 /** ANDREA *************************************************** 00060 00061 We are ignoring the minBuf parameter. Is this the intended 00062 behaviour ? This surprises me. It means that 00063 00064 char *b=s.GetBuffer(100); 00065 // Now i've a pointer to 100 chars (minimum) 00066 // or may be not if the string was initially empty. 00067 00068 If it's empty then you get nothing, maybe I could provide an empty bigger ?! 00069 00070 *************************************************************/ 00071 00072 if (pData->lock != 0) { // Already locked ! 00073 pData->lock++; 00074 return pData->data; 00075 } 00076 00077 /** ANDREA *************************************************** 00078 00079 Here we ignored the minBuf parameter. Is this correct ? 00080 This surprises me even more. 00081 00082 char *b=s.GetBuffer(100); 00083 // Now i've a pointer to 100 chars (minimum) 00084 // or may be less if someone got the buffer too 00085 // before me and asked for a smaller minimum size. 00086 00087 If it's lock it's lock. 00088 It's not expected behavior. 00089 00090 *************************************************************/ 00091 00092 if ( pData->nbRefs > 1 || minBuf > pData->bufferSize) { 00093 // We have to create a new buffer 00094 if ( minBuf < pData->length ) { 00095 minBuf = pData->length; 00096 } 00097 00098 JStringData* pOldData = pData; 00099 pData = new JStringData( pData->data, minBuf ); 00100 pOldData->Dec(); 00101 } 00102 00103 pData->lock = 1; 00104 00105 // return a pointer to the character storage for this JString 00106 return pData->data; 00107 }

JString JString::JString::LCase ( JString & S ) [inline]

Definition at line 271 of file String.hpp.
00271 { 00272 JString temp( S ); 00273 temp.MakeLower(); 00274 return temp; 00275 }

JString JString::JString::Reverse ( JString & S ) [inline]

Definition at line 259 of file String.hpp.
00259 { 00260 JString temp( S ); 00261 temp.MakeReverse(); 00262 return temp; 00263 }

JString JString::JString::UCase ( JString & S ) [inline]

Definition at line 265 of file String.hpp.
00265 { 00266 JString temp( S ); 00267 temp.MakeUpper(); 00268 return temp; 00269 }

__inline void JString::LCase ( )

void JString::LCase ( ) [inline]

__inline void JString::LCase ( )

Definition at line 14 of file StrMorph.cpp.
00014 { 00015 MakeLower(); 00016 }

__inline char* JString::LockBuffer ( )

char* JString::LockBuffer ( ) [inline]

__inline char * JString::LockBuffer ( )

Definition at line 145 of file StrExtra.cpp.
00145 { 00146 return GetBuffer( 0 ); 00147 }

void JString::MakeLower ( )

__inline void JString::MakeLower ( )

Definition at line 27 of file StrMorph.cpp.
Referenced by JString::LCase(), LCase(), LCase(), and setLower().

00027 { 00028 CopyBeforeWrite(); 00029 strlwr(pData->data); 00030 }

void JString::MakeReverse ( )

__inline void JString::MakeReverse ( )

Definition at line 32 of file StrMorph.cpp.
Referenced by JString::Reverse(), Reverse(), Reverse(), and setReverse().

00032 { 00033 CopyBeforeWrite(); 00034 strrev(pData->data); 00035 }

void JString::MakeUpper ( )

Upper/Lower/Reverse Conversion (QuickBasic Compatible) //////////////////////////////////////////////////////////////////////////// Defined in: StrTools.cpp ////////////////////////////////////////////////////////////////////////////.

__inline void JString::MakeUpper ( )

Upper/Lower/Reverse Conversion (QuickBasic Compatible) //////////////////////////////////////////////////////////////////////////// Defined in: StrTools.cpp ////////////////////////////////////////////////////////////////////////////.

Definition at line 22 of file StrMorph.cpp.
Referenced by JString::UCase(), UCase(), UCase(), and setUpper().

00022 { 00023 CopyBeforeWrite(); 00024 strupr(pData->data); 00025 }

bool JString::OK ( ) const

Simple Attributes & Operations... //////////////////////////////////////////////////////////////////////////// Defined in: StrTools.cpp ////////////////////////////////////////////////////////////////////////////.
I can reassure you that your code is not boring at all. It's full of surprises...
(it was a joke)
Definition at line 71 of file StrTools.cpp.
Referenced by SubString::OK().

00072 { 00073 if ( pData != NULL ) { 00074 if ( pData->length > pData->bufferSize ) { 00075 printf( "ERROR in JString: JString length > buffer" ); 00076 return FALSE; 00077 } 00078 if ( pData->data == "" ) { 00079 printf( "data = empty" ); 00080 } 00081 00082 if ( pData->data[ pData->length ] != 0 ) { 00083 printf( "ERROR in JString: JString not NULL terminated" ); 00084 return FALSE; 00085 } 00086 00087 if ( pData->data[ pData->bufferSize ] != 0 ) { 00088 printf( "ERROR in JString: JString Buffer not NULL terminated" ); 00089 return FALSE; 00090 } 00091 00092 if ( pData->length != strlen( pData->data ) ) { 00093 printf( "ERROR in JString: Length is not equal to strlen( data )" ); 00094 return FALSE; 00095 } 00096 00097 if ( pData->bufferSize < strlen( pData->data ) ) { 00098 printf( "ERROR in JString: Buffer Size is lower than strlen( data )" ); 00099 return FALSE; 00100 } 00101 } else { 00102 printf( "ERROR in JString: pData is NULL" ); 00103 return FALSE; 00104 } 00105 00106 #ifndef __J2K__QUIET 00107 printf("OK!\n"); 00108 #endif 00109 00110 return TRUE; 00111 }

__inline void JString::ReleaseBuffer ( )

void JString::ReleaseBuffer ( ) [inline]

__inline void JString::ReleaseBuffer ( )

ANDREA ***************************************************.
Here we ignored the minBuf parameter. Is this correct ? This surprises me even more.
char *b=s.GetBuffer(100); Now i've a pointer to 100 chars (minimum) or may be less if someone got the buffer too before me and asked for a smaller minimum size.
If it's lock it's lock. It's not expected behavior.
Definition at line 109 of file StrExtra.cpp.
Referenced by UnlockBuffer().

00109 { 00110 if (pData == strNull) return; 00111 pData->lock--; 00112 pData->Dec(); // Destroy the object, if NO Lock ! 00113 00114 /** ANDREA *************************************************** 00115 00116 After calling ReleaseBuffer the string object is pointing 00117 to an istance of JStringData that has been destroyed. 00118 00119 NO? Unless the user delete it ? 00120 I should check maybe for pData == NULL ? 00121 00122 This means that when the string object will be destroyed 00123 too it will call Dec() on a dead object. 00124 This means undefined behaviour. 00125 00126 hmmm. 00127 *************************************************************/ 00128 }

__inline void JString::Reverse ( )

void JString::Reverse ( ) [inline]

__inline void JString::Reverse ( )

Definition at line 18 of file StrMorph.cpp.
00018 { 00019 MakeReverse(); 00020 }

long JString::ReverseFind ( char ch ) const

__inline long JString::ReverseFind ( char ch ) const

Definition at line 31 of file StrFind.inl.
00031 { 00032 // find last single character 00033 // return -1 if not found and index otherwise 00034 00035 for( ULONG l = (pData->length - 1); l >= 0; l-- ) { 00036 if ( pData->data[l] == ch ) return ( pData->length - l - 1 ); 00037 } 00038 return (-1); 00039 }

__inline void JString::UCase ( )

void JString::UCase ( ) [inline]

__inline void JString::UCase ( )

Aliases.

Definition at line 10 of file StrMorph.cpp.
00010 { 00011 MakeUpper(); 00012 }

__inline void JString::UnlockBuffer ( )

void JString::UnlockBuffer ( ) [inline]

__inline void JString::UnlockBuffer ( )

Definition at line 149 of file StrExtra.cpp.
00149 { 00150 ReleaseBuffer(); // The object is Destroy, if NO Lock ! 00151 /** ANDREA *************************************************** 00152 00153 No... the JStringData object is destroyed; not the object. 00154 This generates a serious double-destroy problem or a may 00155 be more subtle memory overwrite: normally good debug memory 00156 handlers can detect a simple double destruction, but if the 00157 memory is reallocated to some other object then you're just 00158 going to access some raw memory considering it a JStringData 00159 object. Even worse there is an high probability that the 00160 memory area will be allocated to just another JStringData 00161 object with even more subtle long-term effects. 00162 00163 And your wonderful "safety checks" are probably going to 00164 further delay the discovery of such problems probably 00165 several millions instructions after this bug gave its bite. 00166 00167 But if you got your A+ in the meanwhile... 00168 00169 00170 Let me think about it again, it comes from CString ( MFC lib ) 00171 it not a safe feature, but I wanted to be compatible... hmmm. 00172 *************************************************************/ 00173 }

__inline JString JString::after ( const char * s,

size_t startpos,

size_t length

)

Definition at line 164 of file StringAt.inl.
00164 { 00165 if ( s == NULL || *s == '\0' ) return *this; 00166 long where = Find( (char*)(s + startpos), (size_t)0 ); 00167 if ( where >= 0 ) 00168 { 00169 return at( (size_t)where + startpos + 1, length ); 00170 } else { 00171 return *this; 00172 } 00173 }

__inline JString JString::after ( const char * s,

size_t startpos

)

Definition at line 153 of file StringAt.inl.
00153 { 00154 if ( s == NULL || *s == '\0' ) return *this; 00155 long where = Find( (char*)(s + startpos), (size_t)0 ); 00156 if ( where >= 0 ) 00157 { 00158 return at( (size_t)where + startpos ); 00159 } else { 00160 return *this; 00161 } 00162 }

__inline JString JString::after ( const char * s )

__inline JString JString::after ( const char * s,

ULONG startpos,

ULONG length

)

__inline JString JString::after ( const char * s,

ULONG startpos

)

__inline JString JString::after ( const char * s )

Definition at line 142 of file StringAt.inl.
00142 { 00143 if ( s == NULL || *s == '\0' ) return *this; 00144 long where = Find( s, (size_t)0 ); 00145 if ( where >= 0 ) 00146 { 00147 return at( (size_t)where ); 00148 } else { 00149 return *this; 00150 } 00151 }

__inline const JString& JString::append ( char c )

__inline const JString& JString::append ( const char * s )

__inline const JString& JString::append ( const JString & S )

__inline const JString & JString::append ( char c )

Definition at line 206 of file StrLinux.cpp.
00207 { 00208 if ( c != '\0' ) { 00209 Add( pData->data, &c, pData->length, 1 ); 00210 } 00211 return *this; 00212 }

__inline const JString & JString::append ( const char * s )

Definition at line 187 of file StrLinux.cpp.
00188 { 00189 if ( s != NULL && *s != '\0' ) { 00190 Add( pData->data, s, pData->length, strlen( s ) ); 00191 } 00192 return *this; 00193 }

__inline const JString & JString::append ( const JString & S )

Definition at line 175 of file StrLinux.cpp.
00176 { 00177 Add( pData->data, S.pData->data, pData->length, S.pData->length ); 00178 return *this; 00179 }

__inline JString JString::at ( const JString & S,

size_t startpos,

size_t length

)

__inline JString JString::at ( const JString & S,

size_t startpos

)

__inline JString JString::at ( const JString & S )

__inline JString JString::at ( const char * s )

__inline JString JString::at ( )

JString JString::at ( const char * s,

size_t startpos,

size_t length

)

JString JString::at ( const char * s,

size_t startpos

)

JString JString::at ( size_t startpos,

size_t length

)

__inline JString JString::at ( const JString & S,

size_t startpos,

size_t length

) [inline]

Definition at line 42 of file StringAt.inl.
00042 { 00043 return at( S.pData->data, startpos, length ); 00044 }

__inline JString JString::at ( const JString & S,

size_t startpos

) [inline]

Definition at line 38 of file StringAt.inl.
00038 { 00039 return at( S.pData->data, startpos ); 00040 }

JString JString::at ( const JString & S ) [inline]

JString JString::at ( const char * s ) [inline]

JString JString::at ( ) [inline]

JString JString::at ( const char * s,

size_t startpos,

size_t length

)

Definition at line 25 of file StringAt.cpp.
00025 { 00026 if ( (long)startpos == -1 ) return JString(); 00027 if ( (long)length == -1 ) length = pData->length; 00028 if ( startpos+length > pData->length ) return JString(); 00029 const char* r = pData->data + startpos; 00030 char* r2 = strstr( r, s ); 00031 00032 JStringData* sd = new JStringData( r2, length ); 00033 00034 /* 00035 char* c = new char[ length + 1 ]; 00036 memcpy( c, r2, length ); 00037 c[length] = '\0'; 00038 */ 00039 00040 return JString( sd ); 00041 }

JString JString::at ( const char * s,

size_t startpos

)

Definition at line 18 of file StringAt.cpp.
00018 { 00019 if ( (long)startpos == -1 ) return JString(); 00020 if ( startpos > pData->length ) return JString(); 00021 const char* r = pData->data + startpos; 00022 return JString( strstr( r, s ) ); 00023 }

JString JString::at ( size_t startpos,

size_t length

)

Definition at line 43 of file StringAt.cpp.
00043 { 00044 if ( (long)startpos == -1 ) return JString(); 00045 if ( (long)length == -1 ) length = pData->length; 00046 if ( startpos > pData->length ) return JString(); 00047 const char* r = pData->data + startpos; 00048 00049 /* 00050 char* c = new char[ length + 1 ]; 00051 memcpy( c, r, length ); 00052 c[length] = '\0'; 00053 return JString( c ); 00054 */ 00055 00056 JStringData* sd = new JStringData( r, length ); 00057 return JString( sd ); 00058 00059 /** ANDREA *************************************************** 00060 00061 This is leaking memory. The temporary buffer you allocated 00062 will be abandoned on the free store after having been 00063 used to create the JString object. 00064 00065 What !? 00066 Oh I see ! =) 00067 00068 *************************************************************/ 00069 }

JString JString::at ( size_t startpos )

At X do this... //////////////////////////////////////////////////////////////////////////// Defined in: JStringAt.cpp ////////////////////////////////////////////////////////////////////////////.

Definition at line 11 of file StringAt.cpp.
00011 { 00012 if ( (long)startpos == -1 ) return JString(); 00013 if ( startpos > pData->length ) return JString(); 00014 const char* r = pData->data + startpos; 00015 return JString( r ); 00016 }

__inline JString JString::at ( const JString & S,

ULONG startpos,

ULONG length

)

__inline JString JString::at ( const JString & S,

ULONG startpos

)

__inline JString JString::at ( const JString & S )

Definition at line 36 of file StringAt.inl.
00036 { return at( S.pData->data, 0 ); }

__inline JString JString::at ( const char * s )

Definition at line 35 of file StringAt.inl.
00035 { return at( s, 0 ); }

__inline JString JString::at ( )

Definition at line 33 of file StringAt.inl.
Referenced by after(), at(), before(), beforeStr(), charAt(), left(), mid(), operator()(), and right().

00033 { return JString( *this ); } // get a copy

JString JString::at ( const char * s,

ULONG startpos,

ULONG length

)

Definition at line 25 of file StringAt.cpp.
00025 { 00026 if ( (long)startpos == -1 ) return JString(); 00027 if ( (long)length == -1 ) length = pData->length; 00028 if ( startpos > pData->length ) return JString(); 00029 if ( length > pData->length ) return JString(); 00030 if ( startpos+length > pData->length ) return JString(); 00031 const char* r = pData->data + startpos; 00032 char* r2 = strstr( r, s ); 00033 00034 00035 // JStringData( char* s, ULONG nBuffer ) 00036 JStringData* sd = new JStringData( r2, length ); 00037 00038 return JString( sd ); 00039 }

JString JString::at ( const char * s,

ULONG startpos

)

Definition at line 18 of file StringAt.cpp.
00018 { 00019 if ( (long)startpos == -1 ) return JString(); 00020 if ( startpos > pData->length ) return JString(); 00021 const char* r = pData->data + startpos; 00022 return JString( strstr( r, s ) ); 00023 }

JString JString::at ( ULONG startpos,

ULONG length

)

Definition at line 41 of file StringAt.cpp.
00041 { 00042 if ( (long)startpos == -1 ) return JString(); 00043 if ( (long)length == -1 ) length = pData->length; 00044 if ( startpos > pData->length ) return JString(); 00045 const char* r = pData->data + startpos; 00046 00047 JStringData* sd = new JStringData( r, length ); 00048 return JString( sd ); 00049 00050 /** ANDREA *************************************************** 00051 00052 This is leaking memory. The temporary buffer you allocated 00053 will be abandoned on the free store after having been 00054 used to create the JString object. 00055 00056 What !? 00057 Oh I see ! =) 00058 I use JStringData to avoid that. 00059 00060 *************************************************************/ 00061 }

JString JString::at ( ULONG startpos )

At X do this... //////////////////////////////////////////////////////////////////////////// Defined in: JStringAt.cpp ////////////////////////////////////////////////////////////////////////////.

Definition at line 11 of file StringAt.cpp.
00011 { 00012 if ( (long)startpos == -1 ) return JString(); 00013 if ( startpos > pData->length ) return JString(); 00014 const char* r = pData->data + startpos; 00015 return JString( r ); 00016 }

__inline JString JString::before ( const char * s,

size_t startpos,

size_t length

)

Definition at line 211 of file StringAt.inl.
00211 { 00212 if ( s == NULL || *s == '\0' ) return *this; 00213 long where = Find( s + startpos, (size_t)0 ); 00214 if ( where >= 0 ) 00215 { 00216 long ini = where - (long)length; 00217 if ( ini < 0 ) ini = 0; 00218 return at( (size_t)ini , (size_t)where ); 00219 } else { 00220 return *this; 00221 } 00222 }

__inline JString JString::before ( const char * s,

size_t startpos

)

Definition at line 189 of file StringAt.inl.
00189 { 00190 if ( s == NULL || *s == '\0' ) return *this; 00191 long where = Find( s + startpos, 0 ); 00192 if ( where >= 0 ) 00193 { 00194 return at( (size_t)0, (size_t)where ); 00195 } else { 00196 return *this; 00197 } 00198 }

__inline JString JString::before ( const char * s )

__inline JString JString::before ( const char * s,

ULONG startpos,

ULONG length

)

__inline JString JString::before ( const char * s,

ULONG startpos

)

__inline JString JString::before ( const char * s )

Definition at line 175 of file StringAt.inl.
00175 { 00176 if ( s == NULL || *s == '\0' ) return *this; 00177 long where = Find( s, (size_t)0 ); 00178 if ( where >= 0 ) 00179 { 00180 return at( (size_t)0, (size_t)where ); 00181 } else { 00182 return *this; 00183 } 00184 }

__inline JString JString::beforeStr ( const char * s,

size_t startpos

)

Definition at line 200 of file StringAt.inl.
00200 { 00201 if ( s == NULL || *s == '\0' ) return *this; 00202 long where = Find( s + startpos, (size_t)0 ); 00203 if ( where >= 0 ) 00204 { 00205 return at( startpos, (size_t)where ); 00206 } else { 00207 return *this; 00208 } 00209 }

__inline JString JString::beforeStr ( const char * s,

ULONG startpos

)

__inline char JString::charAt ( const JString & S )

__inline char JString::charAt ( const char * s )

__inline char JString::charAt ( )

__inline char JString::charAt ( const JString & S )

Definition at line 47 of file StringAt.inl.
00047 { 00048 JString temp = at( S.pData->data, (size_t)0, (size_t)1 ); 00049 register char c = temp.pData->data[0]; 00050 temp.pData->Dec(); 00051 return c; 00052 }

__inline char JString::charAt ( const char * s )

Definition at line 40 of file StringAt.inl.
00040 { 00041 JString temp = at( s, (size_t)0, (size_t)1 ); 00042 register char c = temp.pData->data[0]; 00043 temp.pData->Dec(); 00044 return c; 00045 }

__inline char JString::charAt ( )

Definition at line 33 of file StringAt.inl.
00033 { 00034 JString temp = at( (size_t)0, (size_t)1 ); 00035 register char c = temp.pData->data[0]; 00036 temp.pData->Dec(); 00037 return c; 00038 }

int JString::compare ( char right ) const

__inline int JString::compare ( const char * right ) const

int JString::compare ( const char * src )

int JString::compare ( char right ) const

int JString::compare ( const char * right ) const [inline]

int JString::compare ( const JString & right ) const [inline]

Compare utilities... //////////////////////////////////////////////////////////////////////////// Defined in: StrComp.cpp ////////////////////////////////////////////////////////////////////////////.

int JString::compare ( const char * src )

Definition at line 55 of file StrANSI.cpp.
00055 { 00056 return strcmp( pData->data, src ); 00057 }

int JString::compare ( char r ) const

Definition at line 8 of file StrComp.cpp.
00008 { 00009 if ( pData == strNull && r == 0 ) return 0; 00010 register char c = pData->data[0]; 00011 if ( c > r ) return 1; 00012 if ( c < r ) return (-1); 00013 if ( c == r && pData->length == 1 ) return 0; 00014 return (-1); 00015 }

__inline int JString::compare ( const char * r ) const

Definition at line 15 of file StrComp.inl.
00015 { 00016 if ( pData == strNull && ( r == "" || r == NULL ) ) return 0; 00017 return strcmp( pData->data, r ); 00018 }

__inline int JString::compare ( const JString & right ) const

Compare utilities... //////////////////////////////////////////////////////////////////////////// Defined in: StrComp.cpp ////////////////////////////////////////////////////////////////////////////.

Definition at line 10 of file StrComp.inl.
Referenced by DBase::CompareID(), operator!=(), operator<(), operator<=(), operator==(), operator>(), and operator>=().

00010 { 00011 if ( pData == right.pData ) return 0; 00012 return strcmp( pData->data, right.pData->data ); 00013 }

int JString::compareIgnoreCase ( const char * src )

int JString::compareIgnoreCase ( const char * src )

Definition at line 59 of file StrANSI.cpp.
00059 { 00060 00061 #if defined(__sun) || defined(__SUN__) 00062 return strcasecmp( pData->data, src ); 00063 #else 00064 return strcmpi( pData->data, src ); 00065 #endif 00066 00067 // return stricmp( pData->data, src ); 00068 }

int JString::compareIgnoreCaseWithLimits ( const char * src,

size_t n

)

int JString::compareIgnoreCaseWithLimits ( const char * src,

size_t n

)

Definition at line 191 of file StrANSI.cpp.
00191 { 00192 #if defined(__sun) || defined(__SUN__) 00193 return strncasecmp( pData->data, src, n ); 00194 #else 00195 return strnicmp( pData->data, src, n ); 00196 #endif 00197 }

int JString::compareIgnoreCaseWithLimits ( const char * src,

ULONG n

)

Definition at line 187 of file StrANSI.cpp.
00187 { 00188 #if defined(__sun) || defined(__SUN__) 00189 return strncasecmp( pData->data, src, n ); 00190 #else 00191 return strnicmp( pData->data, src, n ); 00192 #endif 00193 }

int JString::compareUsingLocaleCollate ( const char * src )

int JString::compareUsingLocaleCollate ( const char * src )

Definition at line 70 of file StrANSI.cpp.
00070 { 00071 return strcoll( pData->data, src ); // Useless, if extern "C" or "C++" 00072 }

int JString::compareWithLimits ( const char * src,

size_t n

)

int JString::compareWithLimits ( const char * src,

size_t n

)

Definition at line 187 of file StrANSI.cpp.
00187 { 00188 return strncmp( pData->data, src, n ); 00189 }

int JString::compareWithLimits ( const char * src,

ULONG n

)

Definition at line 183 of file StrANSI.cpp.
00183 { 00184 return strncmp( pData->data, src, n ); 00185 }

__inline bool JString::contains ( char c ) const

__inline bool JString::contains ( const char * s ) const

__inline bool JString::contains ( const JString & S ) const

__inline bool JString::contains ( char c,

size_t offset

) const

Definition at line 152 of file StrLinux.cpp.
00153 { 00154 return( Find( c, offset ) >= 0 ); 00155 }

__inline bool JString::contains ( const char * s,

size_t offset

) const

Definition at line 147 of file StrLinux.cpp.
00148 { 00149 return( Find( s, offset ) >= 0 ); 00150 }

__inline bool JString::contains ( const JString & S,

size_t offset

) const

Definition at line 142 of file StrLinux.cpp.
00143 { 00144 return( Find( S, offset ) >= 0 ); 00145 }

__inline bool JString::contains ( char c ) const

Definition at line 167 of file StrLinux.cpp.
00168 { 00169 return( Find( c, 0 ) >= 0 ); 00170 }

__inline bool JString::contains ( const char * s ) const

Definition at line 162 of file StrLinux.cpp.
00163 { 00164 return( Find( s, 0 ) >= 0 ); 00165 }

__inline bool JString::contains ( const JString & S ) const

Definition at line 157 of file StrLinux.cpp.
00158 { 00159 return( Find( S, 0 ) >= 0 ); 00160 }

__inline bool JString::contains ( char c,

ULONG offset

) const

Definition at line 152 of file StrLinux.cpp.
00153 { 00154 return( Find( c, offset ) >= 0 ); 00155 }

__inline bool JString::contains ( const char * s,

ULONG offset

) const

Definition at line 147 of file StrLinux.cpp.
00148 { 00149 return( Find( s, offset ) >= 0 ); 00150 }

__inline bool JString::contains ( const JString & S,

ULONG offset

) const

Definition at line 142 of file StrLinux.cpp.
00143 { 00144 return( Find( S, offset ) >= 0 ); 00145 }

char* JString::copy ( )

char * JString::copy ( )

Definition at line 74 of file StrANSI.cpp.
00074 { 00075 char* dst = new char[ pData->length + 1 ]; 00076 return strcpy( dst, pData->data ); 00077 }

char* JString::copyWithLimits ( size_t n )

char * JString::copyWithLimits ( size_t n )

Definition at line 199 of file StrANSI.cpp.
00199 { 00200 char* dst = new char[ pData->length + 1 ]; 00201 return strncpy( dst, pData->data, n ); 00202 }

char * JString::copyWithLimits ( ULONG n )

Definition at line 195 of file StrANSI.cpp.
00195 { 00196 char* dst = new char[ pData->length + 1 ]; 00197 return strncpy( dst, pData->data, n ); 00198 }

char* JString::duplicate ( )

char * JString::duplicate ( )

Definition at line 113 of file StrANSI.cpp.
00113 { 00114 return strdup( pData->data ); 00115 }

JString JString::duplicateString ( )

JString JString::duplicateString ( )

Definition at line 117 of file StrANSI.cpp.
00117 { 00118 return JString( strdup( pData->data ) ); 00119 }

size_t JString::findCharset ( const char * charset,

size_t startAt

)

size_t JString::findCharset ( const char * charset )

size_t JString::findCharset ( const char * charset,

size_t startAt

)

Definition at line 256 of file StrANSI.cpp.
00256 { 00257 if ( startAt >= pData->length ) return 0; 00258 char* p = pData->data + startAt; 00259 return strspn( p, charset ); 00260 }

size_t JString::findCharset ( const char * charset )

ULONG JString::findCharset ( const char * charset,

ULONG startAt

)

Definition at line 252 of file StrANSI.cpp.
00252 { 00253 if ( startAt >= pData->length ) return 0; 00254 char* p = pData->data + startAt; 00255 return strspn( p, charset ); 00256 }

size_t JString::findCharset ( const char * charset )

Definition at line 247 of file StrANSI.cpp.
00247 { 00248 return findCharset( charset, 0 ); 00249 }

long JString::findString ( const char * s,

size_t startAt

)

long JString::findString ( const char * s )

long JString::findString ( const char * s,

size_t startAt

)

Definition at line 267 of file StrANSI.cpp.
00267 { 00268 if ( startAt >= pData->length ) return 0; 00269 char* p = pData->data + startAt; 00270 char* f = strstr( p, s ); 00271 return (long)( f - pData->data ); 00272 }

long JString::findString ( const char * s )

long JString::findString ( const char * s,

ULONG startAt

)

Definition at line 263 of file StrANSI.cpp.
00263 { 00264 if ( startAt >= pData->length ) return 0; 00265 char* p = pData->data + startAt; 00266 char* f = strstr( p, s ); 00267 return (long)( f - pData->data ); 00268 }

long JString::findString ( const char * s )

Definition at line 258 of file StrANSI.cpp.
00258 { 00259 return findString( s, 0 ); 00260 }

long JString::firstCharFound ( const int c )

long JString::firstCharFound ( const int c )

Definition at line 31 of file StrANSI.cpp.
00031 { 00032 if ( pData->data == NULL ) return (-1); 00033 // Direct (Forward search) 00034 char* where = strchr( pData->data, c ); 00035 if ( where == NULL ) return (-1); 00036 00037 // e.g. 0xfff10 -= 0xfff00 => position 0x10 00038 long w = (long)where; 00039 w -= (long)pData->data; 00040 return w; 00041 }

__inline size_t JString::getAllocLength ( ) const

size_t JString::getAllocLength ( ) const [inline]

__inline size_t JString::getAllocLength ( ) const

Definition at line 29 of file StrTools.inl.
00029 { 00030 return pData->bufferSize; 00031 }

__inline char JString::getAt ( size_t nIndex ) const

__inline char JString::getAt ( size_t index ) const [inline]

Definition at line 24 of file StringAt.inl.
00024 { 00025 if ( (long)index == -1 ) return (char)NULL; 00026 if ( index >= pData->length ) { 00027 return (char)NULL; 00028 } 00029 00030 return pData->data[ index ]; 00031 }

__inline char JString::getAt ( ULONG nIndex ) const

Referenced by operator[]().

__inline size_t JString::getBufferSize ( ) const

size_t JString::getBufferSize ( ) const [inline]

__inline size_t JString::getBufferSize ( ) const

Definition at line 33 of file StrTools.inl.
00033 { 00034 return pData->bufferSize; 00035 }

char * JString::getConcatenate ( const char * src )

Every function str* from ANSI definition //////////////////////////////////////////////////////////////////////////// Defined in: StrANSI.cpp ////////////////////////////////////////////////////////////////////////////.

Definition at line 7 of file StrANSI.cpp.
00008 { 00009 ULONG newLen = pData->length + strlen( src ) + 1; 00010 char* buffer = new char[ newLen ]; 00011 strcpy( buffer, pData->data ); 00012 strcat( buffer, src ); 00013 buffer[ newLen ] = '\0'; // Safety Net. 00014 return buffer; 00015 }

char* JString::getConcatenateWithLimits ( const char * src,

size_t n

)

char * JString::getConcatenateWithLimits ( const char * src,

size_t n

)

Definition at line 166 of file StrANSI.cpp.
00166 { 00167 size_t newLen = pData->length + n + 1; 00168 char* buffer = new char[ newLen ]; 00169 strcpy( buffer, pData->data ); 00170 strncat( buffer, src, n ); 00171 buffer[ newLen ] = '\0'; // Safety Net. 00172 return buffer; 00173 }

char * JString::getConcatenateWithLimits ( const char * src,

ULONG n

)

Definition at line 162 of file StrANSI.cpp.
00162 { 00163 ULONG newLen = pData->length + n + 1; 00164 char* buffer = new char[ newLen ]; 00165 strcpy( buffer, pData->data ); 00166 strncat( buffer, src, n ); 00167 buffer[ newLen ] = '\0'; // Safety Net. 00168 return buffer; 00169 }

JString JString::getCopy ( )

JString JString::getCopy ( )

Definition at line 79 of file StrANSI.cpp.
00079 { 00080 JStringData* sd = new JStringData( pData->length ); 00081 strcpy( sd->data, pData->data ); 00082 return JString( sd ); 00083 }

JString JString::getCopyWithLimits ( size_t n )

JString JString::getCopyWithLimits ( size_t n )

Definition at line 204 of file StrANSI.cpp.
00204 { 00205 JStringData* sd = new JStringData( pData->length ); 00206 strncpy( sd->data, pData->data, n ); 00207 return JString( sd ); 00208 }

JString JString::getCopyWithLimits ( ULONG n )

Definition at line 200 of file StrANSI.cpp.
00200 { 00201 JStringData* sd = new JStringData( pData->length ); 00202 strncpy( sd->data, pData->data, n ); 00203 return JString( sd ); 00204 }

JString JString::getDate ( )

JString JString::getDate ( )

Definition at line 89 of file StrANSI.cpp.
00089 { // MM/DD/YY format (not Y2K complient !) 00090 JStringData* sd = new JStringData( 9 ); 00091 _strdate( sd->data ); 00092 return JString( sd ); 00093 }

JString JString::getError ( int errnb )

JString JString::getError ( int errnb )

Definition at line 121 of file StrANSI.cpp.
00121 { 00122 char* err = strerror( errnb ); 00123 return JString( err ); 00124 }

char* JString::getFillWithChar ( const int ch,

size_t n

)

char* JString::getFillWithChar ( const int ch )

char * JString::getFillWithChar ( const int ch,

size_t n

)

Definition at line 219 of file StrANSI.cpp.
00219 { 00220 size_t newLen = pData->length + 1; 00221 char* buffer = new char[ newLen ]; 00222 strcpy( buffer, pData->data ); 00223 strnset( buffer, ch, n ); 00224 buffer[ newLen ] = '\0'; // Safety Net. 00225 return buffer; 00226 }

char* JString::getFillWithChar ( const int ch )

char * JString::getFillWithChar ( const int ch,

ULONG n

)

Definition at line 215 of file StrANSI.cpp.
00215 { 00216 ULONG newLen = pData->length + 1; 00217 char* buffer = new char[ newLen ]; 00218 strcpy( buffer, pData->data ); 00219 strnset( buffer, ch, n ); 00220 buffer[ newLen ] = '\0'; // Safety Net. 00221 return buffer; 00222 }

char * JString::getFillWithChar ( const int ch )

Definition at line 206 of file StrANSI.cpp.
00206 { 00207 return getFillWithChar( ch, pData->length ); 00208 } // Same as strset()

JString JString::getFind ( const char * s,

size_t offset

)

__inline JString JString::getFind ( const char * s )

JString JString::getFind ( const char * s,

size_t offset

)

Definition at line 20 of file StrFind.cpp.
00020 { 00021 // On error return Null String 00022 if ( s == NULL ) return JString(); 00023 if ( offset >= pData->length ) return JString(); 00024 char* p = pData->data + offset; 00025 char* s2 = strstr(p, s); 00026 if ( s2 == NULL ) { 00027 return JString(); 00028 } 00029 00030 size_t sz = pData->length - (size_t)(s2 - p); 00031 return JString( (char*)(s2 - p), sz ); 00032 }

JString JString::getFind ( const char * s ) [inline]

JString JString::getFind ( const char * s,

ULONG offset

)

Definition at line 20 of file StrFind.cpp.
00020 { 00021 // On error return Null String 00022 if ( s == NULL ) return JString(); 00023 if ( offset >= pData->length ) return JString(); 00024 char* p = pData->data + offset; 00025 char* s2 = strstr(p, s); 00026 if ( s2 == NULL ) { 00027 return JString(); 00028 } 00029 00030 ULONG sz = pData->length - (ULONG)(s2 - p); 00031 return JString( (char*)(s2 - p), sz ); 00032 }

__inline JString JString::getFind ( const char * s )

Definition at line 45 of file StrFind.inl.
00045 { 00046 return getFind( s, 0 ); 00047 }

__inline size_t JString::getLength ( )

size_t JString::getLength ( ) [inline]

__inline size_t JString::getLength ( )

Definition at line 24 of file StrTools.inl.
00024 { 00025 pData->length = strlen( pData->data ); 00026 return pData->length; 00027 }

__inline int JString::getLockNb ( ) const

int JString::getLockNb ( ) const [inline]

__inline int JString::getLockNb ( ) const

Definition at line 7 of file StrTools.inl.
00007 { 00008 return pData->lock; 00009 }

char* JString::getLower ( )

__inline char * JString::getLower ( )

Definition at line 41 of file StrMorph.cpp.
00041 { 00042 return strlwr( strdup( pData->data ) ); 00043 }

JString JString::getMoreStringTokens ( const char * delims )

JString JString::getMoreStringTokens ( const char * delims )

Definition at line 352 of file StrANSI.cpp.
00352 { 00353 return JString( strtok( NULL, delims ) ); 00354 }

char* JString::getMoreTokens ( const char * delims )

char * JString::getMoreTokens ( const char * delims )

Definition at line 339 of file StrANSI.cpp.
00339 { 00340 return strtok( NULL, delims ); 00341 }

size_t JString::getNbCharNotFromCharSet ( const char * charset )

size_t JString::getNbCharNotFromCharSet ( const char * charset )

Definition at line 85 of file StrANSI.cpp.
00085 { 00086 return strcspn( pData->data, charset ); 00087 }

char* JString::getReverse ( )

__inline char * JString::getReverse ( )

Definition at line 45 of file StrMorph.cpp.
00045 { 00046 return strrev( strdup( pData->data ) ); 00047 }

JString JString::getStringTokens ( const char * delims,

size_t startAt

)

JString JString::getStringTokens ( const char * delims,

size_t startAt

)

Definition at line 344 of file StrANSI.cpp.
00344 { 00345 if ( startAt >= pData->length ) return JString(); 00346 char* p = pData->data + startAt; 00347 char* buffer = strdup( p ); 00348 char* f = strtok( buffer, delims ); 00349 return JString( f ); 00350 }

JString JString::getStringTokens ( const char * delims,

ULONG startAt

)

Definition at line 343 of file StrANSI.cpp.
00344 { 00345 if ( startAt >= pData->length ) return JString(); 00346 char* p = pData->data + startAt; 00347 char* buffer = strdup( p ); 00348 char* f = strtok( buffer, delims ); 00349 return JString( f ); 00350 }

__inline char* JString::getText ( ) const

char* JString::getText ( ) const [inline]

__inline char * JString::getText ( ) const

Definition at line 90 of file StrMorph.cpp.
00090 { 00091 return parseString(); 00092 }

JString JString::getTime ( )

JString JString::getTime ( )

Definition at line 148 of file StrANSI.cpp.
00148 { // HH:MM:SS (24h) 00149 JStringData* sd = new JStringData( 8 ); 00150 _strtime( sd->data ); 00151 return JString( sd ); 00152 }

JString JString::getTimeFormat ( size_t maxSize,

const char * format,

const struct tm * currTime

)

JString JString::getTimeFormat ( size_t maxSize,

const char * format,

const struct tm * currTime

)

Definition at line 136 of file StrANSI.cpp.
00137 { 00138 JStringData* sd = new JStringData( maxSize ); 00139 strftime( sd->data, maxSize, format, currTime ); 00140 return JString( sd ); 00141 }

JString JString::getTimeFormat ( ULONG maxSize,

const char * format,

const struct tm * currTime

)

Definition at line 132 of file StrANSI.cpp.
00133 { 00134 JStringData* sd = new JStringData( maxSize ); 00135 strftime( sd->data, maxSize, format, currTime ); 00136 return JString( sd ); 00137 }

char* JString::getTokens ( const char * delims,

size_t startAt

)

char * JString::getTokens ( const char * delims,

size_t startAt

)

Definition at line 332 of file StrANSI.cpp.
00332 { 00333 if ( startAt >= pData->length ) return NULL; 00334 char* p = pData->data + startAt; 00335 char* buffer = strdup( p ); 00336 char* f = strtok( buffer, delims ); 00337 return f; 00338 }

char * JString::getTokens ( const char * delims,

ULONG startAt

)

Definition at line 330 of file StrANSI.cpp.
00331 { 00332 if ( startAt >= pData->length ) return NULL; 00333 char* p = pData->data + startAt; 00334 char* buffer = strdup( p ); 00335 char* f = strtok( buffer, delims ); 00336 return f; 00337 }

char* JString::getTransform ( const char * src,

size_t n

)

char * JString::getTransform ( const char * src,

size_t n

)

Definition at line 312 of file StrANSI.cpp.
00312 { 00313 size_t newLen = pData->length + n + 1; 00314 char* buffer = new char[ newLen ]; 00315 strcpy( buffer, pData->data ); 00316 strxfrm( buffer, src, n ); 00317 buffer[ newLen ] = '\0'; // Safety Net. 00318 return buffer; 00319 }

char * JString::getTransform ( const char * src,

ULONG n

)

Definition at line 308 of file StrANSI.cpp.
00309 { 00310 ULONG newLen = pData->length + n + 1; 00311 char* buffer = new char[ newLen ]; 00312 strcpy( buffer, pData->data ); 00313 strxfrm( buffer, src, n ); 00314 buffer[ newLen ] = '\0'; // Safety Net. 00315 return buffer; 00316 }

char* JString::getUpper ( )

__inline char * JString::getUpper ( )

Definition at line 37 of file StrMorph.cpp.
00037 { 00038 return strupr( strdup( pData->data ) ); 00039 }

bool JString::isEmpty ( ) const

__inline bool JString::isEmpty ( ) const

Definition at line 41 of file StrTools.inl.
Referenced by isFilled().

00041 { 00042 if ( pData == strNull ) return TRUE; 00043 if ( pData->length == 0 ) return TRUE; 00044 if ( pData->data == "" ) return TRUE; 00045 if ( pData->data == NULL ) return TRUE; 00046 if ( pData == NULL ) return TRUE; 00047 return FALSE; 00048 }

bool JString::isFilled ( ) const

__inline bool JString::isFilled ( ) const

Definition at line 50 of file StrTools.inl.
00050 { 00051 return !( isEmpty() ); 00052 }

__inline bool JString::isLock ( ) const

bool JString::isLock ( ) const [inline]

__inline bool JString::isLock ( ) const

Definition at line 11 of file StrTools.inl.
00011 { 00012 return (pData->lock != 0); 00013 }

__inline bool JString::isUnlock ( ) const

bool JString::isUnlock ( ) const [inline]

__inline bool JString::isUnlock ( ) const

Definition at line 15 of file StrTools.inl.
00015 { 00016 return (pData->lock == 0); 00017 }

JString JString::keepCharset ( const char * charset ) const

JString JString::keepCharset ( const char * charset ) const

Definition at line 153 of file StringAt.cpp.
00153 { 00154 // find first single character 00155 // return -1 if not found and index otherwise 00156 JStringData* sd = new JStringData( pData->length ); 00157 00158 // char* s = new char[ pData->length + 1 ]; 00159 00160 ULONG p = 0; 00161 ULONG l = 0; 00162 ULONG m = 0; 00163 ULONG mc = strlen( charset ); 00164 BOOL found = FALSE; 00165 00166 for( l = 0; l < pData->length; l++ ) { 00167 found = FALSE; 00168 for( m = 0; m < mc; m++ ) { 00169 if ( pData->data[l] == charset[m] ) { 00170 found == TRUE; 00171 m = mc; 00172 } 00173 } 00174 00175 if ( found == TRUE ) { // Only change from trim 00176 sd->data[ p++ ] = pData->data[l]; 00177 } 00178 } 00179 00180 if ( p == 0 ) { 00181 delete sd; 00182 return JString(); 00183 } 00184 00185 sd->data[ p ] = '\0'; 00186 return JString( sd ); 00187 }

long JString::lastCharFound ( const int c )

long JString::lastCharFound ( const int c )

Definition at line 43 of file StrANSI.cpp.
00043 { 00044 if ( pData->data == NULL) return (-1); 00045 // Reverse (Backward search) 00046 char* where = strrchr( pData->data, c ); 00047 if ( where == NULL ) return (-1); 00048 00049 // e.g. 0xfff10 -= 0xfff00 => position 0x10 00050 long w = (long)where; 00051 w -= (long)pData->data; 00052 return w; 00053 }

__inline JString JString::left ( size_t length )

__inline JString JString::left ( size_t length ) [inline]

Definition at line 50 of file StringAt.inl.
00050 { 00051 return at( (size_t)0, length ); 00052 }

__inline JString JString::left ( ULONG length )

__inline size_t JString::length ( )

size_t JString::length ( ) [inline]

__inline size_t JString::length ( )

Definition at line 19 of file StrTools.inl.
Referenced by JSubString::JSubString(), String::_gsub(), String::after(), String::at(), String::before(), cat(), common_prefix(), common_suffix(), compare(), SubString::contains(), String::contains(), String::del(), String::elem(), fcompare(), String::freq(), String::from(), String::gsub(), String::index(), join(), String::lastchar(), String::matches(), SubString::operator=(), String::operator[](), String::prepend(), replicate(), split(), and String::through().

00019 { 00020 pData->length = strlen( pData->data ); 00021 return pData->length; 00022 }

long JString::locateCharSet ( const char * charset,

size_t startAt

)

long JString::locateCharSet ( const char * charset )

long JString::locateCharSet ( const char * charset,

size_t startAt

)

Definition at line 244 of file StrANSI.cpp.
00244 { 00245 if ( startAt >= pData->length ) return -1; 00246 char* p = pData->data + startAt; 00247 char* f = strpbrk( p, charset ); 00248 return (long)( f - pData->data ); 00249 }

long JString::locateCharSet ( const char * charset )

long JString::locateCharSet ( const char * charset,

ULONG startAt

)

Definition at line 240 of file StrANSI.cpp.
00240 { 00241 if ( startAt >= pData->length ) return -1; 00242 char* p = pData->data + startAt; 00243 char* f = strpbrk( p, charset ); 00244 return (long)( f - pData->data ); 00245 }

long JString::locateCharSet ( const char * charset )

Definition at line 235 of file StrANSI.cpp.
00235 { 00236 return locateCharSet( charset, 0 ); 00237 }

JString JString::ltrim ( char ch ) const

ANDREA ***************************************************.
If I remember correctly 'Mid' is an l-value in QuickBasic. You can write statements like
mid(a$,2,3)="Hello!!!"
both r-value and l-value.
I implement ONLY the r-value version:
A$ = "hello" print mid$(A$, 2, 3)

__inline JString JString::ltrim ( char ch ) const

ANDREA ***************************************************.
If I remember correctly 'Mid' is an l-value in QuickBasic. You can write statements like
mid(a$,2,3)="Hello!!!"
both r-value and l-value.
I implement ONLY the r-value version:
A$ = "hello" print mid$(A$, 2, 3)
Definition at line 62 of file StringAt.inl.
00062 { 00063 // find first single character 00064 // return -1 if not found and index otherwise 00065 for( size_t l = 0; l < pData->length; l++ ) { 00066 if ( pData->data[l] == ch ) return JString( pData->data+l ); 00067 } 00068 return JString(); 00069 }

__inline JString JString::mid ( const JString & S,

size_t startpos,

size_t length

)

__inline JString JString::mid ( const char * s,

size_t startpos,

size_t length

)

__inline JString JString::mid ( const JString & S,

size_t startpos,

size_t length

) [inline]

Definition at line 54 of file StringAt.inl.
00054 { 00055 return at( S.pData->data, startpos, length ); 00056 }

__inline JString JString::mid ( const char * s,

size_t startpos,

size_t length

) [inline]

Definition at line 58 of file StringAt.inl.
00058 { 00059 return at( s, startpos, length ); 00060 }

__inline JString JString::mid ( const JString & S,

ULONG startpos,

ULONG length

)

__inline JString JString::mid ( const char * s,

ULONG startpos,

ULONG length

)

__inline const JString & JString::modifyAt ( const char * s,

size_t offset,

size_t length

)

Definition at line 79 of file StringAt.inl.
00080 { 00081 if ( s == NULL || *s == '\0' ) return *this; 00082 00083 long where = Find( s, offset ); 00084 00085 if ( where >= 0 ) 00086 { 00087 // -- Modify THIS JString Object. 00088 00089 JStringData* sd = pData; 00090 00091 size_t l = strlen( s ); 00092 long len = (long)length; 00093 00094 if ( length > l || length == 0 ) len = l; 00095 00096 long delta = (long)length - (long)offset - len; 00097 00098 if ( delta >= 0 ) { // No buffer increase 00099 CopyBeforeWrite(); 00100 memcpy( pData->data + where, s, len ); 00101 00102 pData->data[ pData->length ] = '\0'; 00103 00104 } else { 00105 size_t newLen = sd->length - delta; 00106 pData = new JStringData( sd->data, newLen ); // It's -(delta < 0) give us a + 00107 memcpy( pData->data + where, s, len ); 00108 00109 pData->length = newLen; 00110 pData->data[ newLen ] = '\0'; 00111 00112 /* 00113 This Null ending is needed since the last string 00114 might not be ended by '\0' or in case the copy 00115 doesn't go up to Zero. To be checked! 00116 */ 00117 00118 sd->Dec(); // Suicide we don't care. 00119 } 00120 } 00121 00122 return *this; 00123 }

__inline const JString & JString::modifyAt ( const char * s,

size_t offset

)

Definition at line 74 of file StringAt.inl.
00075 { 00076 return modifyAt( s, offset, (size_t)0 ); 00077 }

__inline const JString& JString::modifyAt ( const char * s )

__inline const JString & JString::modifyAt ( const JString & S,

size_t offset,

size_t length

)

Definition at line 64 of file StringAt.inl.
00065 { 00066 return modifyAt( S.pData->data, offset, S.pData->length ); 00067 }

__inline const JString & JString::modifyAt ( const JString & S,

size_t offset

)

Definition at line 59 of file StringAt.inl.
00060 { 00061 return modifyAt( S.pData->data, offset, S.pData->length ); 00062 }

__inline const JString& JString::modifyAt ( const JString & S )

__inline const JString& JString::modifyAt ( const char * s,

ULONG offset,

ULONG length

)

__inline const JString& JString::modifyAt ( const char * s,

ULONG offset

)

__inline const JString & JString::modifyAt ( const char * s )

Definition at line 69 of file StringAt.inl.
00070 { 00071 return modifyAt( s, (size_t)0, (size_t)0 ); 00072 }

__inline const JString& JString::modifyAt ( const JString & S,

ULONG offset,

ULONG length

)

__inline const JString& JString::modifyAt ( const JString & S,

ULONG offset

)

__inline const JString & JString::modifyAt ( const JString & S )

Definition at line 54 of file StringAt.inl.
Referenced by modifyAt().

00055 { 00056 return modifyAt( S.pData->data, (size_t)0, S.pData->length ); 00057 }

__inline JString::operator char * ( ) const

Parsing and Casting utilities... //////////////////////////////////////////////////////////////////////////// Defined in: StrMorph.cpp ////////////////////////////////////////////////////////////////////////////.

JString::operator char * ( ) const [inline]

Parsing and Casting utilities... //////////////////////////////////////////////////////////////////////////// Defined in: StrMorph.cpp ////////////////////////////////////////////////////////////////////////////.

__inline JString::operator double ( ) const

JString::operator double ( ) const [inline]

__inline JString::operator double ( ) const

Definition at line 109 of file StrMorph.cpp.
00109 { 00110 return parseDouble(); 00111 }

__inline JString::operator int ( ) const

JString::operator int ( ) const [inline]

__inline JString::operator int ( ) const

Definition at line 101 of file StrMorph.cpp.
00101 { 00102 return parseInt(); 00103 }

__inline JString::operator long ( ) const

JString::operator long ( ) const [inline]

__inline JString::operator long ( ) const

Definition at line 105 of file StrMorph.cpp.
00105 { 00106 return parseLong(); 00107 }

__inline bool JString::operator!= ( char right ) const

__inline bool JString::operator!= ( const JString & right ) const

__inline bool JString::operator!= ( const char * right ) const

bool JString::operator!= ( char right ) const [inline]

bool JString::operator!= ( const JString & right ) const [inline]

bool JString::operator!= ( const char * right ) const [inline]

__inline bool JString::operator!= ( char right ) const

Definition at line 89 of file StrComp.inl.
00089 { 00090 return ( compare(right) != 0 ); 00091 }

__inline bool JString::operator!= ( const JString & right ) const

Definition at line 81 of file StrComp.inl.
00081 { 00082 return ( compare(right) != 0 ); 00083 }

__inline bool JString::operator!= ( const char * right ) const

Definition at line 85 of file StrComp.inl.
00085 { 00086 return ( compare(right) != 0 ); 00087 }

__inline JString JString::operator() ( const JString & S,

size_t startpos,

size_t length

)

__inline JString JString::operator() ( const char * s,

size_t startpos,

size_t length

)

__inline JString JString::operator() ( const JString & S,

size_t startpos

)

__inline JString JString::operator() ( const char * s,

size_t startpos

)

__inline JString JString::operator() ( const JString & S )

__inline JString JString::operator() ( const char * s )

__inline JString JString::operator() ( size_t startpos,

size_t length

)

__inline JString JString::operator() ( size_t startpos )

__inline JString JString::operator() ( const JString & S,

size_t startpos,

size_t length

) [inline]

Definition at line 94 of file StringAt.inl.
00094 { 00095 return at( S.pData->data, startpos, length ); 00096 }

__inline JString JString::operator() ( const char * s,

size_t startpos,

size_t length

) [inline]

Definition at line 90 of file StringAt.inl.
00090 { 00091 return at( s, startpos, length ); 00092 }

__inline JString JString::operator() ( const JString & S,

size_t startpos

) [inline]

Definition at line 86 of file StringAt.inl.
00086 { 00087 return at( S.pData->data, startpos ); 00088 }

__inline JString JString::operator() ( const char * s,

size_t startpos

) [inline]

Definition at line 82 of file StringAt.inl.
00082 { 00083 return at( s, startpos ); 00084 }

JString JString::operator() ( const JString & S ) [inline]

JString JString::operator() ( const char * s ) [inline]

__inline JString JString::operator() ( size_t startpos,

size_t length

) [inline]

Definition at line 74 of file StringAt.inl.
00074 { 00075 return at( startpos, length ); 00076 }

__inline JString JString::operator() ( size_t startpos ) [inline]

Definition at line 78 of file StringAt.inl.
00078 { return at( startpos ); }

__inline JString JString::operator() ( const JString & S,

ULONG startpos,

ULONG length

)

__inline JString JString::operator() ( const char * s,

ULONG startpos,

ULONG length

)

__inline JString JString::operator() ( const JString & S,

ULONG startpos

)

__inline JString JString::operator() ( const char * s,

ULONG startpos

)

__inline JString JString::operator() ( const JString & S )

Definition at line 80 of file StringAt.inl.
00080 { return at( S.pData->data, 0 ); }

__inline JString JString::operator() ( const char * s )

Definition at line 79 of file StringAt.inl.
00079 { return at( s, 0 ); }

__inline JString JString::operator() ( ULONG startpos,

ULONG length

)

__inline JString JString::operator() ( ULONG startpos )

const JString& JString::operator+= ( char ch )

const JString& JString::operator+= ( const char * s )

const JString& JString::operator+= ( const JString & s )

const JString& JString::operator+= ( char ch )

const JString& JString::operator+= ( const char * s )

const JString& JString::operator+= ( const JString & s )

__inline const JString & JString::operator+= ( char ch )

Definition at line 32 of file StrAdd.inl.
00032 { 00033 char tmp[2] = { ch, '\0' }; 00034 Append( tmp, 1 ); 00035 return *this; 00036 }

__inline const JString & JString::operator+= ( const char * s )

Definition at line 23 of file StrAdd.inl.
00023 { 00024 ULONG Len = 0; 00025 if ( s != NULL && *s != (char)NULL ) { 00026 Len = strlen( s ); 00027 } 00028 Append( s, Len ); 00029 return *this; 00030 }

__inline const JString & JString::operator+= ( const JString & S1 )

Definition at line 38 of file StrAdd.inl.
00038 { 00039 Append( S1.pData->data, S1.pData->length ); 00040 return *this; 00041 }

__inline bool JString::operator< ( char right ) const

__inline bool JString::operator< ( const char * right ) const

__inline bool JString::operator< ( const JString & right ) const

bool JString::operator< ( char right ) const [inline]

bool JString::operator< ( const char * right ) const [inline]

bool JString::operator< ( const JString & right ) const [inline]

__inline bool JString::operator< ( char right ) const

Definition at line 29 of file StrComp.inl.
00029 { 00030 return ( compare(right) < 0 ); 00031 }

__inline bool JString::operator< ( const char * right ) const

Definition at line 25 of file StrComp.inl.
00025 { 00026 return ( compare(right) < 0 ); 00027 }

__inline bool JString::operator< ( const JString & right ) const

Definition at line 21 of file StrComp.inl.
00021 { 00022 return ( compare(right) < 0 ); 00023 }

__inline bool JString::operator<= ( char right ) const

__inline bool JString::operator<= ( const char * right ) const

__inline bool JString::operator<= ( const JString & right ) const

bool JString::operator<= ( char right ) const [inline]

bool JString::operator<= ( const char * right ) const [inline]

bool JString::operator<= ( const JString & right ) const [inline]

__inline bool JString::operator<= ( char right ) const

Definition at line 53 of file StrComp.inl.
00053 { 00054 return ( compare(right) <= 0 ); 00055 }

__inline bool JString::operator<= ( const char * right ) const

Definition at line 49 of file StrComp.inl.
00049 { 00050 return ( compare(right) <= 0 ); 00051 }

__inline bool JString::operator<= ( const JString & right ) const

Definition at line 45 of file StrComp.inl.
00045 { 00046 return ( compare(right) <= 0 ); 00047 }

const JString& JString::operator= ( char ch )

const JString& JString::operator= ( const char * s )

const JString& JString::operator= ( const JString & s )

const JString& JString::operator= ( char ch )

const JString& JString::operator= ( const char * s )

const JString& JString::operator= ( const JString & s )

const JString & JString::operator= ( char ch )

Definition at line 172 of file StrAdd.cpp.
00172 { 00173 JStringData* sd = pData; 00174 00175 if ( ch == '\0' || ch == (char)NULL ) { 00176 pData = strNull; 00177 } else { 00178 pData = new JStringData( ch, 1 ); 00179 } 00180 00181 // Possible case, we assign a char of ourself. 00182 sd->Dec(); 00183 return *this; 00184 }

const JString & JString::operator= ( const char * s )

Assignment operators: /// All assign a new value to the JString object: /// (a) first see, if the buffer is big enough /// (b) if enough room, copy on top of old buffer, set size and type /// (c) otherwise free old JString data, and create a new one /// /// All routines return the new JString (but as a 'const JString&') /// this way, assigning it again will cause a copy ! /// e.g.: s1 = s2 = "hi there". /// /// There are three variants: /// JString + JString /// JString + char /// JString + const char* /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////.

Definition at line 160 of file StrAdd.cpp.
00160 { 00161 if ( s == NULL || *s == (char)NULL ) { // Case EMPTY 00162 if ( pData != NULL ) pData->Dec(); 00163 pData = strNull; 00164 } else { // Case FILLED 00165 JStringData* sd = pData; 00166 pData = new JStringData( s ); 00167 sd->Dec(); 00168 } 00169 return *this; 00170 }

const JString & JString::operator= ( const JString & src )

Definition at line 130 of file StrAdd.cpp.
00130 { 00131 if ( this != &src && pData != src.pData ) { 00132 JStringData* sd = pData; 00133 pData = src.pData; 00134 src.pData->Inc(); 00135 00136 // Possible case, we assign a JString part of ourself. 00137 sd->Dec(); 00138 } 00139 return *this; 00140 }

__inline bool JString::operator== ( char right ) const

__inline bool JString::operator== ( const JString & right ) const

__inline bool JString::operator== ( const char * right ) const

bool JString::operator== ( char right ) const [inline]

bool JString::operator== ( const JString & right ) const [inline]

bool JString::operator== ( const char * right ) const [inline]

__inline bool JString::operator== ( char right ) const

Definition at line 77 of file StrComp.inl.
00077 { 00078 return ( compare(right) == 0 ); 00079 }

__inline bool JString::operator== ( const JString & right ) const

Definition at line 69 of file StrComp.inl.
00069 { 00070 return ( compare(right) == 0 ); 00071 }

__inline bool JString::operator== ( const char * right ) const

Definition at line 73 of file StrComp.inl.
00073 { 00074 return ( compare(right) == 0 ); 00075 }

__inline bool JString::operator> ( char right ) const

__inline bool JString::operator> ( const char * right ) const

__inline bool JString::operator> ( const JString & right ) const

bool JString::operator> ( char right ) const [inline]

bool JString::operator> ( const char * right ) const [inline]

bool JString::operator> ( const JString & right ) const [inline]

__inline bool JString::operator> ( char right ) const

Definition at line 41 of file StrComp.inl.
00041 { 00042 return ( compare(right) > 0 ); 00043 }

__inline bool JString::operator> ( const char * right ) const

Definition at line 37 of file StrComp.inl.
00037 { 00038 return ( compare(right) > 0 ); 00039 }

__inline bool JString::operator> ( const JString & right ) const

Definition at line 33 of file StrComp.inl.
00033 { 00034 return ( compare(right) > 0 ); 00035 }

__inline bool JString::operator>= ( char right ) const

__inline bool JString::operator>= ( const char * right ) const

__inline bool JString::operator>= ( const JString & right ) const

bool JString::operator>= ( char right ) const [inline]

bool JString::operator>= ( const char * right ) const [inline]

bool JString::operator>= ( const JString & right ) const [inline]

__inline bool JString::operator>= ( char right ) const

Definition at line 65 of file StrComp.inl.
00065 { 00066 return ( compare(right) >= 0 ); 00067 }

__inline bool JString::operator>= ( const char * right ) const

Definition at line 61 of file StrComp.inl.
00061 { 00062 return ( compare(right) >= 0 ); 00063 }

__inline bool JString::operator>= ( const JString & right ) const

Definition at line 57 of file StrComp.inl.
00057 { 00058 return ( compare(right) >= 0 ); 00059 }

__inline char JString::operator[] ( long nIndex ) const

char JString::operator[] ( long nIndex ) const [inline]

__inline char JString::operator[] ( long index ) const

ANDREA ***************************************************.
This module defines a few inline and a few regular methods. How do you think one can use it ? including a .cpp (so recompiling all the functions every time) ?
Definition at line 19 of file StringAt.inl.
00019 { 00020 if ( index < 0 ) return (char)NULL; 00021 return getAt( (size_t)index ); 00022 }

__inline double JString::parseDouble ( ) const

double JString::parseDouble ( ) const [inline]

__inline double JString::parseDouble ( ) const

Definition at line 74 of file StrMorph.cpp.
Referenced by operator double().

00074 { 00075 return atof( pData->data ); 00076 }

__inline int JString::parseInt ( ) const

int JString::parseInt ( ) const [inline]

__inline int JString::parseInt ( ) const

Definition at line 66 of file StrMorph.cpp.
Referenced by operator int().

00066 { 00067 return atoi( pData->data ); 00068 }

__inline long JString::parseLong ( ) const

long JString::parseLong ( ) const [inline]

__inline long JString::parseLong ( ) const

Definition at line 70 of file StrMorph.cpp.
Referenced by operator long().

00070 { 00071 return atol( pData->data ); 00072 }

char* JString::parseString ( ) const

__inline char * JString::parseString ( ) const

Definition at line 78 of file StrMorph.cpp.
Referenced by Find(), getText(), operator char *(), and toString().

00078 { 00079 if ( pData == &strNull ) { 00080 return ""; 00081 } else { 00082 return strdup( pData->data ); 00083 } 00084 }

__inline const JString& JString::prepend ( char c )

__inline const JString& JString::prepend ( const char * s )

__inline const JString& JString::prepend ( const JString & S )

__inline const JString & JString::prepend ( char c )

Definition at line 214 of file StrLinux.cpp.
00215 { 00216 if ( c != '\0' ) { 00217 Add( &c, pData->data, 1, pData->length ); 00218 } 00219 return *this; 00220 }

__inline const JString & JString::prepend ( const char * s )

Definition at line 195 of file StrLinux.cpp.
00196 { 00197 if ( s != NULL && *s != '\0' ) { 00198 Add( s, pData->data, strlen( s ), pData->length ); 00199 } 00200 return *this; 00201 }

__inline const JString & JString::prepend ( const JString & S )

Definition at line 181 of file StrLinux.cpp.
00182 { 00183 Add( S.pData->data, pData->data, S.pData->length, pData->length ); 00184 return *this; 00185 }

__inline JString JString::right ( size_t length )

__inline JString JString::right ( size_t length ) [inline]

Definition at line 46 of file StringAt.inl.
00046 { 00047 return at( pData->length - length, length ); 00048 }

__inline JString JString::right ( ULONG length )

JString JString::rtrim ( char ch ) const

JString JString::rtrim ( char ch ) const

Definition at line 73 of file StringAt.cpp.
00073 { 00074 // find first single character 00075 // return -1 if not found and index otherwise 00076 for( ULONG l = pData->length - 1; l >= 0; l-- ) { 00077 if ( pData->data[l] == ch ) { 00078 const char* r = pData->data + l; 00079 ULONG length = (ULONG)(pData->length) - l; 00080 00081 JStringData* sd = new JStringData( r, length ); 00082 /* 00083 char* c = new char[ length + 1 ]; 00084 memcpy( c, r, length ); 00085 c[length] = '\0'; 00086 return JString( c ); 00087 */ 00088 return JString( sd ); 00089 } 00090 } 00091 return JString(); 00092 }

JString& JString::setAt ( size_t nIndex,

char ch

)

JString & JString::setAt ( size_t index,

char ch

)

ANDREA ***************************************************.
This is leaking memory. The temporary buffer you allocated will be abandoned on the free store after having been used to create the JString object.
What !? Oh I see ! =)
Definition at line 71 of file StringAt.cpp.
00071 { 00072 if ( (long)index == -1 ) return *this; 00073 if (index > pData->length) { 00074 index = pData->length; 00075 } 00076 CopyBeforeWrite(); 00077 pData->data[index] = ch; 00078 return *this; 00079 }

JString & JString::setAt ( ULONG index,

char ch

)

ANDREA ***************************************************.
This is leaking memory. The temporary buffer you allocated will be abandoned on the free store after having been used to create the JString object.
What !? Oh I see ! =) I use JStringData to avoid that.
Definition at line 63 of file StringAt.cpp.
00063 { 00064 if ( (long)index == -1 ) return *this; 00065 if (index > pData->length) { 00066 index = pData->length; 00067 } 00068 CopyBeforeWrite(); 00069 pData->data[index] = ch; 00070 return *this; 00071 }

JString& JString::setConcatenate ( const char * src )

JString & JString::setConcatenate ( const char * src )

Definition at line 17 of file StrANSI.cpp.
00018 { 00019 if ( src == NULL ) return *this; 00020 ULONG newLen = pData->length + strlen(src); 00021 JStringData* sd = new JStringData( pData->data, newLen ); 00022 JStringData* bsd = pData; // Late delete 00023 pData = sd; 00024 strcat( pData->data, src ); 00025 pData->data[ newLen ] = '\0'; // Safety Net. 00026 pData->length = strlen( sd->data ); 00027 bsd->Dec(); 00028 return ( *this ); 00029 }

JString& JString::setConcatenateWithLimits ( const char * src,

size_t n

)

JString & JString::setConcatenateWithLimits ( const char * src,

size_t n

)

Definition at line 175 of file StrANSI.cpp.
00175 { 00176 if ( src == NULL ) return *this; 00177 size_t newLen = pData->length + n; 00178 JStringData* sd = new JStringData( pData->data, newLen ); 00179 pData->Dec(); 00180 pData = sd; 00181 strncat( pData->data, src, n ); 00182 pData->data[ newLen ] = '\0'; // Safety Net. 00183 pData->length = strlen( sd->data ); 00184 return ( *this ); 00185 }

JString & JString::setConcatenateWithLimits ( const char * src,

ULONG n

)

Definition at line 171 of file StrANSI.cpp.
00171 { 00172 if ( src == NULL ) return *this; 00173 ULONG newLen = pData->length + n; 00174 JStringData* sd = new JStringData( pData->data, newLen ); 00175 pData->Dec(); 00176 pData = sd; 00177 strncat( pData->data, src, n ); 00178 pData->data[ newLen ] = '\0'; // Safety Net. 00179 pData->length = strlen( sd->data ); 00180 return ( *this ); 00181 }

JString& JString::setDate ( )

JString & JString::setDate ( )

Definition at line 95 of file StrANSI.cpp.
00095 { // MM/DD/YY format (not Y2K complient !) 00096 JStringData* sd = new JStringData( 9 ); 00097 _strdate( sd->data ); 00098 pData->Dec(); 00099 pData = sd; 00100 return ( *this ); 00101 }

JString& JString::setError ( int errnb )

JString & JString::setError ( int errnb )

Definition at line 126 of file StrANSI.cpp.
00126 { 00127 char* err = strerror( errnb ); 00128 // this = new JString( err ); // To Be FIXED 00129 return ( *this ); 00130 }

JString& JString::setFillWithChar ( const int ch,

size_t n

)

JString& JString::setFillWithChar ( const int ch )

JString & JString::setFillWithChar ( const int ch,

size_t n

)

Definition at line 228 of file StrANSI.cpp.
00228 { 00229 size_t newLen = pData->length; 00230 JStringData* sd = new JStringData( pData->data, newLen ); 00231 pData->Dec(); 00232 pData = sd; 00233 strnset( pData->data, ch, n ); 00234 pData->data[ newLen ] = '\0'; // Safety Net. 00235 pData->length = strlen( sd->data ); 00236 return ( *this ); 00237 }

JString& JString::setFillWithChar ( const int ch )

JString & JString::setFillWithChar ( const int ch,

ULONG n

)

Definition at line 224 of file StrANSI.cpp.
00224 { 00225 ULONG newLen = pData->length; 00226 JStringData* sd = new JStringData( pData->data, newLen ); 00227 pData->Dec(); 00228 pData = sd; 00229 strnset( pData->data, ch, n ); 00230 pData->data[ newLen ] = '\0'; // Safety Net. 00231 pData->length = strlen( sd->data ); 00232 return ( *this ); 00233 }

JString & JString::setFillWithChar ( const int ch )

Definition at line 210 of file StrANSI.cpp.
00210 { 00211 return setFillWithChar( ch, pData->length ); 00212 } // Same as strset()

__inline JString& JString::setLower ( )

JString& JString::setLower ( ) [inline]

__inline JString & JString::setLower ( )

Definition at line 54 of file StrMorph.cpp.
00054 { 00055 MakeLower(); 00056 return *this; 00057 }

__inline JString& JString::setReverse ( )

JString& JString::setReverse ( ) [inline]

__inline JString & JString::setReverse ( )

Definition at line 59 of file StrMorph.cpp.
00059 { 00060 MakeReverse(); 00061 return *this; 00062 }

JString& JString::setTime ( )

JString& JString::setTime ( size_t maxSize,

const char * format,

const struct tm * currTime

)

JString& JString::setTime ( )

JString & JString::setTime ( size_t maxSize,

const char * format,

const struct tm * currTime

)

Definition at line 104 of file StrANSI.cpp.
00106 { 00107 JStringData* sd = new JStringData( maxSize ); 00108 strftime( sd->data, maxSize, format, currTime ); 00109 pData->Dec(); 00110 pData = sd; 00111 return ( *this ); 00112 }

JString & JString::setTime ( )

Definition at line 154 of file StrANSI.cpp.
00154 { // HH:MM:SS (24h) 00155 JStringData* sd = new JStringData( 8 ); 00156 _strtime( sd->data ); 00157 pData->Dec(); 00158 pData = sd; 00159 return ( *this ); 00160 }

JString & JString::setTime ( ULONG maxSize,

const char * format,

const struct tm * currTime

)

Definition at line 103 of file StrANSI.cpp.
00105 { 00106 JStringData* sd = new JStringData( maxSize ); 00107 strftime( sd->data, maxSize, format, currTime ); 00108 pData->Dec(); 00109 pData = sd; 00110 return ( *this ); 00111 }

JString& JString::setTimeFormat ( size_t maxSize,

const char * format,

const struct tm * currTime

)

JString & JString::setTimeFormat ( size_t maxSize,

const char * format,

const struct tm * currTime

)

Definition at line 143 of file StrANSI.cpp.
00144 { 00145 JStringData* sd = new JStringData( maxSize ); 00146 strftime( sd->data, maxSize, format, currTime ); 00147 pData->Dec(); 00148 pData = sd; 00149 return ( *this ); 00150 }

JString & JString::setTimeFormat ( ULONG maxSize,

const char * format,

const struct tm * currTime

)

Definition at line 139 of file StrANSI.cpp.
00140 { 00141 JStringData* sd = new JStringData( maxSize ); 00142 strftime( sd->data, maxSize, format, currTime ); 00143 pData->Dec(); 00144 pData = sd; 00145 return ( *this ); 00146 }

JString& JString::setTransform ( const char * src,

size_t n

)

JString & JString::setTransform ( const char * src,

size_t n

)

Definition at line 321 of file StrANSI.cpp.
00321 { 00322 size_t newLen = pData->length + n; 00323 JStringData* sd = new JStringData( pData->data, newLen ); 00324 pData->Dec(); 00325 pData = sd; 00326 strxfrm( pData->data, src, n ); 00327 pData->data[ newLen ] = '\0'; // Safety Net. 00328 pData->length = strlen( sd->data ); 00329 return ( *this ); 00330 }

JString & JString::setTransform ( const char * src,

ULONG n

)

Definition at line 318 of file StrANSI.cpp.
00319 { 00320 ULONG newLen = pData->length + n; 00321 JStringData* sd = new JStringData( pData->data, newLen ); 00322 pData->Dec(); 00323 pData = sd; 00324 strxfrm( pData->data, src, n ); 00325 pData->data[ newLen ] = '\0'; // Safety Net. 00326 pData->length = strlen( sd->data ); 00327 return ( *this ); 00328 }

__inline JString& JString::setUpper ( )

JString& JString::setUpper ( ) [inline]

__inline JString & JString::setUpper ( )

Definition at line 49 of file StrMorph.cpp.
00049 { 00050 MakeUpper(); 00051 return *this; 00052 }

double JString::toDouble ( size_t startAt )

double JString::toDouble ( )

double JString::toDouble ( size_t startAt )

Definition at line 278 of file StrANSI.cpp.
00278 { 00279 if ( startAt >= pData->length ) return 0; 00280 char* p = pData->data + startAt; 00281 return strtod( p, NULL ); 00282 }

double JString::toDouble ( )

double JString::toDouble ( ULONG startAt )

Definition at line 274 of file StrANSI.cpp.
00274 { 00275 if ( startAt >= pData->length ) return 0; 00276 char* p = pData->data + startAt; 00277 return strtod( p, NULL ); 00278 }

double JString::toDouble ( )

Definition at line 270 of file StrANSI.cpp.
00270 { 00271 return toDouble( 0 ); 00272 }

long JString::toLong ( size_t startAt,

size_t base

)

long JString::toLong ( size_t base )

long JString::toLong ( )

long JString::toLong ( size_t startAt,

size_t base

)

Definition at line 292 of file StrANSI.cpp.
00292 { 00293 if ( startAt >= pData->length ) return 0; 00294 char* p = pData->data + startAt; 00295 return strtol( p, NULL, base ); 00296 }

long JString::toLong ( size_t base )

Definition at line 288 of file StrANSI.cpp.
00288 { 00289 return toLong( 0, base ); // No OffSet, Base chosen 00290 }

long JString::toLong ( )

long JString::toLong ( ULONG startAt,

ULONG base

)

Definition at line 288 of file StrANSI.cpp.
00288 { 00289 if ( startAt >= pData->length ) return 0; 00290 char* p = pData->data + startAt; 00291 return strtol( p, NULL, base ); 00292 }

long JString::toLong ( ULONG base )

Definition at line 284 of file StrANSI.cpp.
00284 { 00285 return toLong( 0, base ); // No OffSet, Base chosen 00286 }

long JString::toLong ( )

Definition at line 280 of file StrANSI.cpp.
Referenced by toLong().

00280 { 00281 return toLong( 0, 10 ); // No OffSet, Decimal 00282 }

__inline char* JString::toString ( ) const

char* JString::toString ( ) const [inline]

__inline char * JString::toString ( ) const

Definition at line 86 of file StrMorph.cpp.
00086 { 00087 return parseString(); 00088 }

ULONG JString::toULONG ( size_t startAt,

size_t base

)

ULONG JString::toULONG ( size_t base )

ULONG JString::toULONG ( )

ULONG JString::toULONG ( size_t startAt,

size_t base

)

Definition at line 306 of file StrANSI.cpp.
00306 { 00307 if ( startAt >= pData->length ) return 0; 00308 char* p = pData->data + startAt; 00309 return strtoul( p, NULL, base ); 00310 }

ULONG JString::toULONG ( size_t base )

Definition at line 302 of file StrANSI.cpp.
00302 { 00303 return toULONG( 0, base ); // No OffSet, Base chosen 00304 }

ULONG JString::toULONG ( )

ULONG JString::toULONG ( ULONG startAt,

ULONG base

)

Definition at line 302 of file StrANSI.cpp.
00302 { 00303 if ( startAt >= pData->length ) return 0; 00304 char* p = pData->data + startAt; 00305 return strtoul( p, NULL, base ); 00306 }

ULONG JString::toULONG ( ULONG base )

Definition at line 298 of file StrANSI.cpp.
00298 { 00299 return toULONG( 0, base ); // No OffSet, Base chosen 00300 }

ULONG JString::toULONG ( )

Definition at line 294 of file StrANSI.cpp.
Referenced by toULONG().

00294 { 00295 return toULONG( 0, 10 ); // No OffSet, Decimal 00296 }

JString JString::trim ( char ch ) const

JString JString::trim ( char ch ) const

Definition at line 94 of file StringAt.cpp.
00094 { 00095 // find first single character 00096 // return -1 if not found and index otherwise 00097 00098 JStringData* sd = new JStringData( pData->length ); 00099 00100 // char* s = new char[ pData->length + 1 ]; 00101 00102 ULONG p = 0; 00103 for( ULONG l = 0; l < pData->length; l++ ) { 00104 if ( pData->data[l] != ch ) { 00105 sd->data[ p++ ] = pData->data[l]; 00106 } 00107 } 00108 if ( p == 0 ) { 00109 delete sd; 00110 return JString(); 00111 } 00112 00113 sd->data[ p ] = '\0'; 00114 return JString( sd ); 00115 }

JString JString::trimCharset ( const char * charset ) const

JString JString::trimCharset ( const char * charset ) const

Definition at line 117 of file StringAt.cpp.
00117 { 00118 // find first single character 00119 // return -1 if not found and index otherwise 00120 00121 JStringData* sd = new JStringData( pData->length ); 00122 // char* s = new char[ pData->length + 1 ]; 00123 00124 ULONG p = 0; 00125 ULONG l = 0; 00126 ULONG m = 0; 00127 ULONG mc = strlen( charset ); 00128 BOOL found = FALSE; 00129 00130 for( l = 0; l < pData->length; l++ ) { 00131 found = FALSE; 00132 for( m = 0; m < mc; m++ ) { 00133 if ( pData->data[l] == charset[m] ) { 00134 found == TRUE; 00135 m = mc; 00136 } 00137 } 00138 00139 if ( found == FALSE ) { 00140 sd->data[ p++ ] = pData->data[l]; 00141 } 00142 } 00143 00144 if ( p == 0 ) { 00145 delete sd; 00146 return JString(); 00147 } 00148 00149 sd->data[ p ] = '\0'; 00150 return JString( sd ); 00151 }

Friends And Related Function Documentation

JString operator+ ( char c,

const JString & S2

) [friend]

Definition at line 268 of file StrAdd.cpp.
00268 { 00269 JString* s = new JString(); // JStringData = &strNull 00270 char s1[2] = { c, '\0' }; 00271 00272 if ( c == '\0' || c == (char)NULL ) { // No addition needed 00273 s->pData = S2.pData; // s1 is NULL, assign S2 00274 } else if ( S2.pData == strNull ) { 00275 s->pData = new JStringData( c ); // Only s1 is not NULL 00276 } else { // Normal Addition, None are NULL 00277 s->Add( s1, S2.pData->data, 1, S2.pData->length ); 00278 } 00279 00280 assert( s->pData->data[s->pData->length] == '\0'); 00281 00282 return *s; 00283 }

JString operator+ ( const JString & S1,

char c

) [friend]

Definition at line 251 of file StrAdd.cpp.
00251 { 00252 JString* s = new JString(); // JStringData = &strNull 00253 char s2[2] = { c, '\0' }; 00254 00255 if ( c == '\0' || c == (char)NULL ) { // No addition needed 00256 s->pData = S1.pData; 00257 } else if ( S1.pData == strNull ) { 00258 s->pData = new JStringData( c ); // Only s2 is not NULL 00259 } else { // Normal Addition, None are NULL 00260 S1.pData->data[ S1.pData->length ] = '\0'; // Safety feature 00261 s->Add( S1.pData->data, s2, S1.pData->length, 1 ); 00262 } 00263 00264 assert( s->pData->data[s->pData->length] == '\0'); 00265 return *s; 00266 }

JString operator+ ( const char * s1,

const JString & S2

) [friend]

Definition at line 234 of file StrAdd.cpp.
00234 { 00235 JString* s = new JString(); // JStringData = &strNull 00236 00237 if ( s1 == NULL || *s1 == (char)NULL ) { // No addition needed 00238 s->pData = S2.pData; // s1 is NULL, assign S2 00239 } else if ( S2.pData == strNull ) { 00240 s->pData = new JStringData( s1 ); // Only s1 is not NULL 00241 } else { // Normal Addition, None are NULL 00242 ULONG Len = strlen( s1 ); 00243 s->Add( s1, S2.pData->data, Len, S2.pData->length ); 00244 } 00245 00246 assert( s->pData->data[s->pData->length] == '\0'); 00247 00248 return *s; 00249 }

JString operator+ ( const JString & S1,

const char * s2

) [friend]

Definition at line 216 of file StrAdd.cpp.
00216 { 00217 JString* s = new JString(); // JStringData = &strNull 00218 00219 if ( s2 == NULL || *s2 == (char)NULL ) { // No addition needed 00220 s->pData = S1.pData; 00221 } else if ( S1.pData == strNull ) { 00222 s->pData = new JStringData( s2 ); // Only s2 is not NULL 00223 } else { // Normal Addition, None are NULL 00224 S1.pData->data[ S1.pData->length ] = '\0'; // Safety feature 00225 00226 ULONG Len = strlen( s2 ); 00227 s->Add( S1.pData->data, s2, S1.pData->length, Len ); 00228 } 00229 00230 assert( s->pData->data[s->pData->length] == '\0'); 00231 return *s; 00232 }

JString operator+ ( const JString & S1,

const JString & S2

) [friend]

Definition at line 186 of file StrAdd.cpp.
00186 { 00187 JString* s = new JString(); // JStringData = &strNull 00188 00189 if ( S1.pData == strNull ) { 00190 // S1.pData->Dec(); // Not Needed, NO decrement on Null 00191 s->pData = S2.pData; // S1 is NULL, assign S2. 00192 00193 S2.pData->Inc(); 00194 00195 // Inc() & Dec() checks for strNull and don't increase or decrease it 00196 00197 } else if ( S2.pData == strNull ) { 00198 // S2.pData->Dec(); // Not Needed, NO decrement on Null 00199 s->pData = S1.pData; // S2 is NULL, assign S1. 00200 S1.pData->Inc(); 00201 } else { // Normal Addition, None are NULL 00202 00203 // Will change this == 's', 00204 // it works since 's' call it's own function ! 00205 S1.pData->data[ S1.pData->length ] = '\0'; // Safety feature 00206 S2.pData->data[ S2.pData->length ] = '\0'; // Safety feature 00207 00208 s->Add( S1.pData->data, S2.pData->data, 00209 S1.pData->length, S2.pData->length ); 00210 } 00211 00212 assert( s->pData->data[s->pData->length] == '\0'); 00213 return *s; 00214 }

ostream& operator<< ( ostream & os,

const JString & s

) [friend]

Stream utilities... ////////////////////////////////////////////////////////////////////////////.

Definition at line 213 of file String.hpp.
00213 { 00214 return os << s.pData->data; 00215 }

ostream& operator<< ( ostream & os,

const JString & s

) [friend]

Stream utilities... ////////////////////////////////////////////////////////////////////////////.

Definition at line 190 of file String.hpp.
00190 { 00191 return os << s.pData->data; 00192 }

ostream& operator<< ( ostream & os,

const JString & s

) [friend]

Stream utilities... ////////////////////////////////////////////////////////////////////////////.

Definition at line 215 of file String.hpp.
00215 { 00216 return os << s.pData->data; 00217 }

Member Data Documentation

friend JString::JSubString [private]

Definition at line 497 of file String.hpp.

JStringData* JString::pData [private]

Definition at line 494 of file String.hpp.

JStringData* JString::pData [private]

Definition at line 429 of file String.hpp.

JStringData* JString::pData [private]

Definition at line 495 of file String.hpp.
Referenced by Add(), append(), at(), charAt(), mid(), modifyAt(), operator()(), operator+(), operator+=(), operator<<(), operator=(), and prepend().

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

C:/temp/src/j2k/Deprecated/old_18mar_diff/Str14dec/String.hpp
C:/temp/src/j2k/Deprecated/old_18mar_diff/String/String.hpp
C:/temp/src/j2k/Fred/String/String.hpp
C:/temp/src/j2k/Deprecated/old_18mar_diff/Str14dec/StrAdd.cpp
C:/temp/src/j2k/Deprecated/old_18mar_diff/Str14dec/StrAdd.inl
C:/temp/src/j2k/Deprecated/old_18mar_diff/Str14dec/StrANSI.cpp
C:/temp/src/j2k/Deprecated/old_18mar_diff/Str14dec/StrBuild.cpp
C:/temp/src/j2k/Deprecated/old_18mar_diff/Str14dec/StrBuild.inl
C:/temp/src/j2k/Deprecated/old_18mar_diff/Str14dec/StrExtra.cpp
C:/temp/src/j2k/Deprecated/old_18mar_diff/Str14dec/StrFind.cpp
C:/temp/src/j2k/Deprecated/old_18mar_diff/Str14dec/StrFind.inl
C:/temp/src/j2k/Deprecated/old_18mar_diff/Str14dec/StringAt.cpp
C:/temp/src/j2k/Deprecated/old_18mar_diff/Str14dec/StrLinux.cpp
C:/temp/src/j2k/Deprecated/old_18mar_diff/Str14dec/StrTools.cpp
C:/temp/src/j2k/Deprecated/old_18mar_diff/Str14dec/StrTools.inl
C:/temp/src/j2k/Deprecated/old_18mar_diff/String/StrAdd.cpp
C:/temp/src/j2k/Deprecated/old_18mar_diff/String/StrAdd.inl
C:/temp/src/j2k/Deprecated/old_18mar_diff/String/StrBuild.cpp
C:/temp/src/j2k/Deprecated/old_18mar_diff/String/StrBuild.inl
C:/temp/src/j2k/Deprecated/old_18mar_diff/String/StrComp.cpp
C:/temp/src/j2k/Deprecated/old_18mar_diff/String/StrComp.inl
C:/temp/src/j2k/Deprecated/old_18mar_diff/String/StrFind.inl
C:/temp/src/j2k/Deprecated/old_18mar_diff/String/StringAt.cpp
C:/temp/src/j2k/Deprecated/old_18mar_diff/String/StringAt.inl
C:/temp/src/j2k/Deprecated/old_18mar_diff/String/StrMorph.cpp
C:/temp/src/j2k/Fred/String/StrAdd.cpp
C:/temp/src/j2k/Fred/String/StrAdd.inl
C:/temp/src/j2k/Fred/String/StrANSI.cpp
C:/temp/src/j2k/Fred/String/StrBuild.cpp
C:/temp/src/j2k/Fred/String/StrBuild.inl
C:/temp/src/j2k/Fred/String/StrComp.cpp
C:/temp/src/j2k/Fred/String/StrComp.inl
C:/temp/src/j2k/Fred/String/StrExtra.cpp
C:/temp/src/j2k/Fred/String/StrFind.cpp
C:/temp/src/j2k/Fred/String/StrFind.inl
C:/temp/src/j2k/Fred/String/StringAt.cpp
C:/temp/src/j2k/Fred/String/StringAt.inl
C:/temp/src/j2k/Fred/String/StrLinux.cpp
C:/temp/src/j2k/Fred/String/StrMorph.cpp
C:/temp/src/j2k/Fred/String/StrMorph.inl
C:/temp/src/j2k/Fred/String/StrTools.cpp
C:/temp/src/j2k/Fred/String/StrTools.inl

Generated on Sun Oct 14 18:49:03 2001 for Standard J2K Library by