Gray C++ Libraries  0.0.2
A set of C++ libraries for MSVC, GNU on Windows, WinCE, Linux
Public Member Functions | Protected Member Functions | Protected Attributes | Static Protected Attributes | Friends | List of all members
Gray::CStringT< _TYPE_CH > Class Template Reference

#include <cString.h>

Inheritance diagram for Gray::CStringT< _TYPE_CH >:
Gray::cStringT< LOGCHAR_t > Gray::cStringT< IniChar_t > Gray::cStringT< wchar_t > Gray::cStringT< GChar_t > Gray::cStringT< char > Gray::cStringT< FILECHAR_t > Gray::cFilePath

Public Member Functions

 CStringT () noexcept
 
 CStringT (const wchar_t *pwText)
 
 CStringT (const wchar_t *pwText, StrLen_t iLenMax)
 
 CStringT (const char *pszStr)
 
 CStringT (const char *pszStr, StrLen_t iLenMax)
 
 CStringT (const THIS_t &ref) noexcept
 
 CStringT (THIS_t &&ref) noexcept
 
 ~CStringT ()
 
CStringData * GetData () const noexcept
 
const _TYPE_CH * GetString () const noexcept
 
bool isValidString () const noexcept
 
bool IsEmpty () const noexcept
 
StrLen_t GetLength () const noexcept
 
void Empty ()
 
const _TYPE_CH & ReferenceAt (StrLen_t nIndex) const
 
_TYPE_CH GetAt (StrLen_t nIndex) const
 
void SetAt (StrLen_t nIndex, _TYPE_CH ch)
 
_TYPE_CH * GetBuffer (StrLen_t iMinLength)
 
void ReleaseBuffer (StrLen_t nNewLength=k_StrLen_UNK)
 
const THIS_t & operator= (const THIS_t &ref)
 
const THIS_t & operator= (THIS_t &&ref)
 
void AssignLenT (const _TYPE_CH *pszStr, StrLen_t iLenMax)
 
void AssignLen (const char *pszStr, StrLen_t iSizeMax=StrT::k_LEN_MAX)
 
const THIS_t & operator= (const char *pStr)
 
void AssignLen (const wchar_t *pwText, StrLen_t iSizeMax=StrT::k_LEN_MAX)
 
const THIS_t & operator= (const wchar_t *pStr)
 
void FormatV (const _TYPE_CH *pszStr, va_list args)
 
void _cdecl Format (const _TYPE_CH *pszStr,...)
 
COMPARE_t Compare (const _TYPE_CH *pszStr) const
 
COMPARE_t CompareNoCase (const _TYPE_CH *pszStr) const
 
void MakeUpper ()
 
void MakeLower ()
 
THIS_t Left (StrLen_t nCount) const
 
THIS_t Right (StrLen_t nCount) const
 
THIS_t Mid (StrLen_t nFirst, StrLen_t nCount=StrT::k_LEN_MAX) const
 
void TrimRight ()
 
void TrimLeft ()
 
StrLen_t Find (_TYPE_CH ch, StrLen_t nPosStart=0) const
 
_TYPE_CH operator[] (StrLen_t nIndex) const
 
const _TYPE_CH & operator[] (StrLen_t nIndex)
 
 operator const _TYPE_CH * () const
 
StrLen_t Insert (StrLen_t nIndex, _TYPE_CH ch)
 
const THIS_t & operator+= (_TYPE_CH ch)
 
StrLen_t Insert (StrLen_t nIndex, const _TYPE_CH *pszStr, StrLen_t iLenCat)
 
StrLen_t Insert (StrLen_t nIndex, const _TYPE_CH *pszStr)
 
const THIS_t & operator+= (const _TYPE_CH *psz)
 
void Assign (const THIS_t &str)
 
void Assign (const wchar_t *pwText)
 
void Assign (const char *pszStr)
 
void AssignLen (const wchar_t *pwStr, StrLen_t iLenMax)
 
void AssignLen (const char *pszStr, StrLen_t iLenMax)
 
void Assign (const wchar_t *pwStr)
 
void Assign (const char *pszStr)
 
void AssignLen (const char *pszStr, StrLen_t iLenMax)
 
void AssignLen (const wchar_t *pwStr, StrLen_t iLenMax)
 
void Assign (const wchar_t *pwStr)
 
void Assign (const char *pszStr)
 

Protected Member Functions

void Init () noexcept
 
void EmptyValid ()
 
void AssignFirst (const THIS_t &s) noexcept
 
void AllocBuffer (StrLen_t iStrLength)
 
void CopyBeforeWrite ()
 
const char m_Nil
 
const wchar_t m_Nil
 

Protected Attributes

_TYPE_CH * m_pchData
 

Static Protected Attributes

static const _TYPE_CH m_Nil
 

Friends

bool operator== (const THIS_t &str1, const _TYPE_CH *str2)((void) 0)
 
bool operator!= (const THIS_t &str1, const _TYPE_CH *str2)((void) 0)
 

Detailed Description

template<typename _TYPE_CH = char>
class Gray::CStringT< _TYPE_CH >

Mimic the MFC ATL::CStringT<> functionality.

Constructor & Destructor Documentation

◆ CStringT() [1/7]

template<typename _TYPE_CH = char>
Gray::CStringT< _TYPE_CH >::CStringT ( )
inlinenoexcept

◆ CStringT() [2/7]

template<typename _TYPE_CH = char>
Gray::CStringT< _TYPE_CH >::CStringT ( const wchar_t *  pwText)
inline

? Init and convert UNICODE is needed.

◆ CStringT() [3/7]

template<typename _TYPE_CH = char>
Gray::CStringT< _TYPE_CH >::CStringT ( const wchar_t *  pwText,
StrLen_t  iLenMax 
)
inline

◆ CStringT() [4/7]

template<typename _TYPE_CH = char>
Gray::CStringT< _TYPE_CH >::CStringT ( const char *  pszStr)
inline

Init and convert UNICODE is needed.

◆ CStringT() [5/7]

template<typename _TYPE_CH = char>
Gray::CStringT< _TYPE_CH >::CStringT ( const char *  pszStr,
StrLen_t  iLenMax 
)
inline

◆ CStringT() [6/7]

template<typename _TYPE_CH = char>
Gray::CStringT< _TYPE_CH >::CStringT ( const THIS_t &  ref)
inlinenoexcept

◆ CStringT() [7/7]

template<typename _TYPE_CH = char>
Gray::CStringT< _TYPE_CH >::CStringT ( THIS_t &&  ref)
inlinenoexcept

Move constructor

◆ ~CStringT()

template<typename _TYPE_CH = char>
Gray::CStringT< _TYPE_CH >::~CStringT ( )
inline

Member Function Documentation

◆ AllocBuffer()

template<typename _TYPE_CH >
void Gray::CStringT< _TYPE_CH >::AllocBuffer ( StrLen_t  iStrLength)
protected

Dynamic allocate a buffer to hold the string.

  • iNewLength = chars not including null

◆ Assign() [1/7]

template<typename _TYPE_CH = char>
void Gray::CStringT< _TYPE_CH >::Assign ( const char *  pszStr)

◆ Assign() [2/7]

void Gray::CStringT< char >::Assign ( const char *  pszStr)

◆ Assign() [3/7]

void Gray::CStringT< wchar_t >::Assign ( const char *  pszStr)

Convert UTF8 to unicode

◆ Assign() [4/7]

template<typename _TYPE_CH = char>
void Gray::CStringT< _TYPE_CH >::Assign ( const THIS_t &  str)
inline

◆ Assign() [5/7]

void Gray::CStringT< char >::Assign ( const wchar_t *  pwStr)

Convert unicode to UTF8

◆ Assign() [6/7]

void Gray::CStringT< wchar_t >::Assign ( const wchar_t *  pwStr)

◆ Assign() [7/7]

template<typename _TYPE_CH = char>
void Gray::CStringT< _TYPE_CH >::Assign ( const wchar_t *  pwText)

◆ AssignFirst()

template<typename _TYPE_CH = char>
void Gray::CStringT< _TYPE_CH >::AssignFirst ( const THIS_t &  s)
inlineprotectednoexcept

◆ AssignLen() [1/6]

void Gray::CStringT< char >::AssignLen ( const char *  pszStr,
StrLen_t  iLenMax 
)

◆ AssignLen() [2/6]

void Gray::CStringT< wchar_t >::AssignLen ( const char *  pszStr,
StrLen_t  iLenMax 
)

Convert UTF8 to unicode iLenMax = STRMAX = _countof(StrT::k_LEN_MAX)-1 default

◆ AssignLen() [3/6]

template<typename _TYPE_CH = char>
void Gray::CStringT< _TYPE_CH >::AssignLen ( const char *  pszStr,
StrLen_t  iSizeMax = StrT::k_LEN_MAX 
)

◆ AssignLen() [4/6]

void Gray::CStringT< char >::AssignLen ( const wchar_t *  pwStr,
StrLen_t  iLenMax 
)

Convert UNICODE to UTF8 iLenMax = _countof(StrT::k_LEN_MAX)-1 default iLenMax = max chars, not including null ! NOT sizeof() or _countof() like StrT::CopyLen

◆ AssignLen() [5/6]

void Gray::CStringT< wchar_t >::AssignLen ( const wchar_t *  pwStr,
StrLen_t  iLenMax 
)

◆ AssignLen() [6/6]

template<typename _TYPE_CH = char>
void Gray::CStringT< _TYPE_CH >::AssignLen ( const wchar_t *  pwText,
StrLen_t  iSizeMax = StrT::k_LEN_MAX 
)

◆ AssignLenT()

template<typename _TYPE_CH >
void Gray::CStringT< _TYPE_CH >::AssignLenT ( const _TYPE_CH *  pszStr,
StrLen_t  iLenMax 
)

Copy pszStr into this string. iLenMax = max chars, not including null ! NOT sizeof() or _countof() like StrT::CopyLen DEBUG_MSG(( "cString:Assign" ));

Note
What if pszStr is in the current string?
DO NOT ASSUME pszStr is terminated string!! DONT CALL StrT::Len

◆ Compare()

template<typename _TYPE_CH = char>
COMPARE_t Gray::CStringT< _TYPE_CH >::Compare ( const _TYPE_CH *  pszStr) const
inline

◆ CompareNoCase()

template<typename _TYPE_CH = char>
COMPARE_t Gray::CStringT< _TYPE_CH >::CompareNoCase ( const _TYPE_CH *  pszStr) const
inline

◆ CopyBeforeWrite()

template<typename _TYPE_CH >
void Gray::CStringT< _TYPE_CH >::CopyBeforeWrite
protected

We are about to modify/change this. so make sure we don't interfere with other refs. Dupe this string. This might not be thread safe ! if we start with 1 ref we may make another before we are done !

◆ Empty()

template<typename _TYPE_CH = char>
void Gray::CStringT< _TYPE_CH >::Empty ( )
inline

◆ EmptyValid()

template<typename _TYPE_CH = char>
void Gray::CStringT< _TYPE_CH >::EmptyValid ( )
inlineprotected

◆ Find()

template<typename _TYPE_CH >
StrLen_t Gray::CStringT< _TYPE_CH >::Find ( _TYPE_CH  ch,
StrLen_t  nPosStart = 0 
) const

◆ Format()

template<typename _TYPE_CH = char>
void _cdecl Gray::CStringT< _TYPE_CH >::Format ( const _TYPE_CH *  pszStr,
  ... 
)
inline

use the normal sprintf() style.

Note
Use StrArg<GChar_t>(s) for safe "%s" args.

◆ FormatV()

template<typename _TYPE_CH >
void Gray::CStringT< _TYPE_CH >::FormatV ( const _TYPE_CH *  pszStr,
va_list  args 
)

_vsntprintf use the normal sprintf() style.

◆ GetAt()

template<typename _TYPE_CH = char>
_TYPE_CH Gray::CStringT< _TYPE_CH >::GetAt ( StrLen_t  nIndex) const
inline

◆ GetBuffer()

template<typename _TYPE_CH >
_TYPE_CH * Gray::CStringT< _TYPE_CH >::GetBuffer ( StrLen_t  iMinLength)

like MFC GetBufferSetLength also iMinLength = not including null

◆ GetData()

template<typename _TYPE_CH = char>
CStringData* Gray::CStringT< _TYPE_CH >::GetData ( ) const
inlinenoexcept

like MFC

◆ GetLength()

template<typename _TYPE_CH = char>
StrLen_t Gray::CStringT< _TYPE_CH >::GetLength ( ) const
inlinenoexcept
Returns
Number of chars. (not necessarily bytes)

◆ GetString()

template<typename _TYPE_CH = char>
const _TYPE_CH* Gray::CStringT< _TYPE_CH >::GetString ( ) const
inlinenoexcept

like MFC

◆ Init()

template<typename _TYPE_CH = char>
void Gray::CStringT< _TYPE_CH >::Init ( )
inlineprotectednoexcept

◆ Insert() [1/3]

template<typename _TYPE_CH >
StrLen_t Gray::CStringT< _TYPE_CH >::Insert ( StrLen_t  nIndex,
_TYPE_CH  ch 
)
Returns
New length.

◆ Insert() [2/3]

template<typename _TYPE_CH = char>
StrLen_t Gray::CStringT< _TYPE_CH >::Insert ( StrLen_t  nIndex,
const _TYPE_CH *  pszStr 
)
inline

◆ Insert() [3/3]

template<typename _TYPE_CH >
StrLen_t Gray::CStringT< _TYPE_CH >::Insert ( StrLen_t  nIndex,
const _TYPE_CH *  pszStr,
StrLen_t  iLenCat 
)

insert substring at zero-based index; concatenates if index is past end of string

insert in the middle.

Returns
New length.

◆ IsEmpty()

template<typename _TYPE_CH = char>
bool Gray::CStringT< _TYPE_CH >::IsEmpty ( ) const
inlinenoexcept

◆ isValidString()

template<typename _TYPE_CH = char>
bool Gray::CStringT< _TYPE_CH >::isValidString ( ) const
inlinenoexcept

Is the string properly terminated?

◆ Left()

template<typename _TYPE_CH >
CStringT< _TYPE_CH > Gray::CStringT< _TYPE_CH >::Left ( StrLen_t  nCount) const

◆ m_Nil() [1/2]

const char Gray::CStringT< char >::m_Nil
protected

◆ m_Nil() [2/2]

const wchar_t Gray::CStringT< wchar_t >::m_Nil
protected

◆ MakeLower()

template<typename _TYPE_CH >
void Gray::CStringT< _TYPE_CH >::MakeLower

replaces strlwr() No portable linux equiv to strlwr()? Like MFC CString::MakeLower(), Similar to .NET String.ToLower() BUT NOT THE SAME.

◆ MakeUpper()

template<typename _TYPE_CH >
void Gray::CStringT< _TYPE_CH >::MakeUpper

replaces _strupr No portable linux equiv to _strupr()? Like MFC CString::MakeUpper(), Similar to .NET String.ToUpper(). BUT NOT THE SAME.

◆ Mid()

template<typename _TYPE_CH >
CStringT< _TYPE_CH > Gray::CStringT< _TYPE_CH >::Mid ( StrLen_t  nFirst,
StrLen_t  nCount = StrT::k_LEN_MAX 
) const

Same as STL substr() function.

◆ operator const _TYPE_CH *()

template<typename _TYPE_CH = char>
Gray::CStringT< _TYPE_CH >::operator const _TYPE_CH * ( ) const
inline

◆ operator+=() [1/2]

template<typename _TYPE_CH = char>
const THIS_t& Gray::CStringT< _TYPE_CH >::operator+= ( _TYPE_CH  ch)
inline

◆ operator+=() [2/2]

template<typename _TYPE_CH = char>
const THIS_t& Gray::CStringT< _TYPE_CH >::operator+= ( const _TYPE_CH *  psz)
inline

◆ operator=() [1/4]

template<typename _TYPE_CH = char>
const THIS_t& Gray::CStringT< _TYPE_CH >::operator= ( const char *  pStr)
inline

◆ operator=() [2/4]

template<typename _TYPE_CH = char>
const THIS_t& Gray::CStringT< _TYPE_CH >::operator= ( const THIS_t &  ref)
inline

Copy assignment

◆ operator=() [3/4]

template<typename _TYPE_CH = char>
const THIS_t& Gray::CStringT< _TYPE_CH >::operator= ( const wchar_t *  pStr)
inline

◆ operator=() [4/4]

template<typename _TYPE_CH = char>
const THIS_t& Gray::CStringT< _TYPE_CH >::operator= ( THIS_t &&  ref)
inline

Move assignment

◆ operator[]() [1/2]

template<typename _TYPE_CH = char>
const _TYPE_CH& Gray::CStringT< _TYPE_CH >::operator[] ( StrLen_t  nIndex)
inline

◆ operator[]() [2/2]

template<typename _TYPE_CH = char>
_TYPE_CH Gray::CStringT< _TYPE_CH >::operator[] ( StrLen_t  nIndex) const
inline

◆ ReferenceAt()

template<typename _TYPE_CH = char>
const _TYPE_CH& Gray::CStringT< _TYPE_CH >::ReferenceAt ( StrLen_t  nIndex) const
inline

◆ ReleaseBuffer()

template<typename _TYPE_CH >
void Gray::CStringT< _TYPE_CH >::ReleaseBuffer ( StrLen_t  nNewLength = k_StrLen_UNK)

Call this after using GetBuffer() or GetBufferSetLength(); Reset size to actual used size. nNewLength = count of chars, not including null char at the end.

◆ Right()

template<typename _TYPE_CH >
CStringT< _TYPE_CH > Gray::CStringT< _TYPE_CH >::Right ( StrLen_t  nCount) const
Returns
a new string with the nCount right most chars in this string.

◆ SetAt()

template<typename _TYPE_CH = char>
void Gray::CStringT< _TYPE_CH >::SetAt ( StrLen_t  nIndex,
_TYPE_CH  ch 
)
inline

◆ TrimLeft()

template<typename _TYPE_CH >
void Gray::CStringT< _TYPE_CH >::TrimLeft

Like MFC CString::TrimLeft(), Similar to .NET String.TrimStart()

◆ TrimRight()

template<typename _TYPE_CH >
void Gray::CStringT< _TYPE_CH >::TrimRight

Like MFC CString::TrimRight(), Similar to .NET String.TrimEnd()

Friends And Related Function Documentation

◆ operator!=

template<typename _TYPE_CH = char>
bool operator!= ( const THIS_t &  str1,
const _TYPE_CH *  str2 
)
friend

◆ operator==

template<typename _TYPE_CH = char>
bool operator== ( const THIS_t &  str1,
const _TYPE_CH *  str2 
)
friend

Member Data Documentation

◆ m_Nil

template<typename _TYPE_CH = char>
const _TYPE_CH Gray::CStringT< _TYPE_CH >::m_Nil
staticprotected

◆ m_pchData

template<typename _TYPE_CH = char>
_TYPE_CH* Gray::CStringT< _TYPE_CH >::m_pchData
protected
The documentation for this class was generated from the following files: