From 65ba91d1c98b59dbe7c1df173b0938d5b0df2668 Mon Sep 17 00:00:00 2001 From: KUDr Date: Fri, 29 Jun 2007 22:33:58 +0000 Subject: (svn r10389) -Add: CStrA, CStrCiA, CStrW, CStrCiW - case sensitive/insensitive ANSI/UNICODE string classes that support formatted (sprintf like) output. --- projects/openttd.vcproj | 6 ++ projects/openttd_vs80.vcproj | 8 ++ source.list | 2 + src/misc/str.hpp | 175 +++++++++++++++++++++++++++++++++++++++++++ src/misc/strapi.hpp | 94 +++++++++++++++++++++++ 5 files changed, 285 insertions(+) create mode 100644 src/misc/str.hpp create mode 100644 src/misc/strapi.hpp diff --git a/projects/openttd.vcproj b/projects/openttd.vcproj index 651884773..9a4b21361 100644 --- a/projects/openttd.vcproj +++ b/projects/openttd.vcproj @@ -1187,6 +1187,12 @@ + + + + + + + + +#include +#include "strapi.hpp" + +/** Blob based string. */ +template +struct CStrT : public CBlobT +{ + typedef CBlobT base; ///< base class + typedef CStrApiT Api; ///< string API abstraction layer + typedef typename base::bsize_t bsize_t; ///< size type inherited from blob + typedef typename base::OnTransfer OnTransfer; ///< temporary 'transfer ownership' object type + + /** Construction from C zero ended string. */ + FORCEINLINE CStrT(const Tchar* str = NULL) + { + AppendStr(str); + } + + /** Construction from C string and given number of characters. */ + FORCEINLINE CStrT(const Tchar* str, bsize_t num_chars) : base(str, num_chars) + { + base::FixTail(); + } + + /** Construction from C string determined by 'begin' and 'end' pointers. */ + FORCEINLINE CStrT(const Tchar* str, const Tchar* end) + : base(str, end - str) + { + base::FixTail(); + } + + /** Construction from blob contents. */ + FORCEINLINE CStrT(const CBlobBaseSimple& src) + : base(src) + { + base::FixTail(); + } + + /** Copy constructor. */ + FORCEINLINE CStrT(const CStrT& src) + : base(src) + { + base::FixTail(); + } + + /** Take over ownership constructor */ + FORCEINLINE CStrT(const OnTransfer& ot) + : base(ot) + { + } + + /** Grow the actual buffer and fix the trailing zero at the end. */ + FORCEINLINE Tchar* GrowSizeNC(bsize_t count) + { + Tchar* ret = base::GrowSizeNC(count); + base::FixTail(); + return ret; + } + + /** Append zero-ended C string. */ + FORCEINLINE void AppendStr(const Tchar* str) + { + if (str != NULL && str[0] != '\0') { + base::Append(str, (bsize_t)Api::StrLen(str)); + base::FixTail(); + } + } + + /** Append another CStrT or blob. */ + FORCEINLINE void Append(const CBlobBaseSimple& src) + { + if (src.RawSize() > 0) { + base::AppendRaw(src); + base::FixTail(); + } + } + + /** Assignment from C string. */ + FORCEINLINE CStrT& operator = (const Tchar* src) + { + base::Clear(); + AppendStr(src); + return *this; + } + + /** Assignment from another CStrT or blob. */ + FORCEINLINE CStrT& operator = (const CBlobBaseSimple& src) + { + base::Clear(); + base::AppendRaw(src); + base::FixTail(); + return *this; + } + + /** Assignment from another CStrT or blob. */ + FORCEINLINE CStrT& operator = (const CStrT& src) + { + base::Clear(); + base::AppendRaw(src); + base::FixTail(); + return *this; + } + + /** Lower-than operator (to support stl collections) */ + FORCEINLINE bool operator < (const CStrT &other) const + { + return (Api::StrCmp(base::Data(), other.Data()) < 0); + } + + /** Add formated string (like vsprintf) at the end of existing contents. */ + int AddFormatL(const Tchar *format, va_list args) + { + bsize_t addSize = Api::StrLen(format); + if (addSize < 16) addSize = 16; + addSize += addSize > 1; + int ret, err; + do { + Tchar *buf = MakeFreeSpace(addSize); + ret = Api::SPrintFL(buf, base::GetReserve(), format, args); + addSize *= 2; + err = errno; + } while(ret < 0 && (err == ERANGE || err == ENOENT || err == 0)); + if (ret > 0) { + GrowSizeNC(ret); + } else { +// int err = errno; + base::FixTail(); + } + return ret; + } + + /** Add formated string (like sprintf) at the end of existing contents. */ + int AddFormat(const Tchar *format, ...) + { + va_list args; + va_start(args, format); + int ret = AddFormatL(format, args); + va_end(args); + return ret; + } + + /** Assign formated string (like vsprintf). */ + int FormatL(const Tchar *format, va_list args) + { + base::Free(); + int ret = AddFormatL(format, args); + return ret; + } + + /** Assign formated string (like sprintf). */ + int Format(const Tchar *format, ...) + { + base::Free(); + va_list args; + va_start(args, format); + int ret = AddFormatL(format, args); + va_end(args); + return ret; + } +}; + +typedef CStrT CStrA; ///< Case sensitive ANSI/UTF-8 string +typedef CStrT CStrCiA; ///< Case insensitive ANSI/UTF-8 string +typedef CStrT CStrW; ///< Case sensitive unicode string +typedef CStrT CStrCiW; ///< Case insensitive unicode string + +#endif /* STR_HPP */ diff --git a/src/misc/strapi.hpp b/src/misc/strapi.hpp new file mode 100644 index 000000000..c901af6ea --- /dev/null +++ b/src/misc/strapi.hpp @@ -0,0 +1,94 @@ +/* $Id$ */ + +/** @file strapi.hpp */ + +#ifndef STRAPI_HPP +#define STRAPI_HPP + +#include +#include + +#if !defined(_MSC_VER) +#define _stricmp strcmp +#define _wcsicmp wcscmp +#endif //!_MSC_VER + +/** String API mapper base - just mapping by character type, not by case sensitivity yet. + * Class template CStrApiBaseT declaration is general, but following inline method + * definitions are specialized by character type. Class is not used directly, but only + * as a base class for template class CStrApiT */ +template +class CStrApiBaseT +{ +public: + /** ::strlen wrapper */ + static size_t StrLen(const Tchar *s); + static int SPrintFL(Tchar *buf, size_t count, const Tchar *fmt, va_list args); +}; + +/** ::strlen wrapper specialization for char */ +template <> /*static*/ inline size_t CStrApiBaseT::StrLen(const char *s) +{ + return ::strlen(s); +} + +/** ::strlen wrapper specialization for wchar_t */ +template <> /*static*/ inline size_t CStrApiBaseT::StrLen(const wchar_t *s) +{ + return ::wcslen(s); +} + +/** ::vsprintf wrapper specialization for char */ +template <> /*static*/ inline int CStrApiBaseT::SPrintFL(char *buf, size_t count, const char *fmt, va_list args) +{ +#if defined(_MSC_VER) && (_MSC_VER >= 1400) // VC 8.0 and above + return ::vsnprintf_s(buf, count, count - 1, fmt, args); +#else // ! VC 8.0 and above + return ::vsnprintf(buf, count, fmt, args); +#endif +} + +/** ::vsprintf wrapper specialization for wchar_t */ +template <> /*static*/ inline int CStrApiBaseT::SPrintFL(wchar_t *buf, size_t count, const wchar_t *fmt, va_list args) +{ +#if defined(_MSC_VER) && (_MSC_VER >= 1400) // VC 8.0 and above + return ::_vsnwprintf_s(buf, count, count - 1, fmt, args); +#else // ! VC 8.0 and above +# if defined(_WIN32) + return ::_vsnwprintf(buf, count, fmt, args); +# else // !_WIN32 + return ::vswprintf(buf, count, fmt, args); +# endif // !_WIN32 +#endif +} + + + +template +class CStrApiT : public CStrApiBaseT +{ +public: + static int StrCmp(const Tchar *s1, const Tchar *s2); +}; + +template <> /*static*/ inline int CStrApiT::StrCmp(const char *s1, const char *s2) +{ + return ::strcmp(s1, s2); +} + +template <> /*static*/ inline int CStrApiT::StrCmp(const char *s1, const char *s2) +{ + return ::_stricmp(s1, s2); +} + +template <> /*static*/ inline int CStrApiT::StrCmp(const wchar_t *s1, const wchar_t *s2) +{ + return ::wcscmp(s1, s2); +} + +template <> /*static*/ inline int CStrApiT::StrCmp(const wchar_t *s1, const wchar_t *s2) +{ + return ::_wcsicmp(s1, s2); +} + +#endif /* STRAPI_HPP */ -- cgit v1.2.3-54-g00ecf