falkTX
/
Carla
mirror of https://github.com/falkTX/Carla
1
0
Fork 0
Code Releases 42 Activity
Audio plugin host https://kx.studio/carla
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
6813 Commits
16 Branches
197MB
Tree: 0335e038a7
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '0335e038a7'
${ noResults }
Carla/source/includes/vst3sdk/base/source/fstring.h

749 lines
39KB
Raw Blame History 

  1. //------------------------------------------------------------------------

  2. // Project     : SDK Base

  3. // Version     : 1.0

  4. //

  5. // Category    : Helpers

  6. // Filename    : base/source/fstring.h

  7. // Created by  : Steinberg, 2008

  8. // Description : String class

  9. //

  10. //-----------------------------------------------------------------------------

  11. // LICENSE

  12. // (c) 2021, Steinberg Media Technologies GmbH, All Rights Reserved

  13. //-----------------------------------------------------------------------------

  14. // Redistribution and use in source and binary forms, with or without modification,

  15. // are permitted provided that the following conditions are met:

  16. // 

  17. //   * Redistributions of source code must retain the above copyright notice, 

  18. //     this list of conditions and the following disclaimer.

  19. //   * Redistributions in binary form must reproduce the above copyright notice,

  20. //     this list of conditions and the following disclaimer in the documentation 

  21. //     and/or other materials provided with the distribution.

  22. //   * Neither the name of the Steinberg Media Technologies nor the names of its

  23. //     contributors may be used to endorse or promote products derived from this 

  24. //     software without specific prior written permission.

  25. // 

  26. // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND

  27. // ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 

  28. // WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 

  29. // IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 

  30. // INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 

  31. // BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 

  32. // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 

  33. // LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE 

  34. // OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE  OF THIS SOFTWARE, EVEN IF ADVISED

  35. // OF THE POSSIBILITY OF SUCH DAMAGE.

  36. //-----------------------------------------------------------------------------

  37. 

  38. #pragma once

  39. 

  40. #include "pluginterfaces/base/ftypes.h"

  41. #include "pluginterfaces/base/fstrdefs.h"

  42. #include "pluginterfaces/base/istringresult.h"

  43. #include "pluginterfaces/base/ipersistent.h"

  44. 

  45. #include "base/source/fobject.h"

  46. 

  47. #include <cstdarg>

  48. 

  49. namespace Steinberg {

  50. 

  51. class FVariant;

  52. class String;

  53. 

  54. #ifdef UNICODE

  55. static const bool kWideStringDefault = true;

  56. #else

  57. static const bool kWideStringDefault = false;

  58. #endif

  59. 

  60. static const uint16 kBomUtf16 = 0xFEFF;					///< UTF16 Byte Order Mark

  61. static const char8* const kBomUtf8 = "\xEF\xBB\xBF";	///< UTF8 Byte Order Mark

  62. static const int32 kBomUtf8Length = 3;

  63. 

  64. 

  65. enum MBCodePage

  66. {

  67. 	kCP_ANSI = 0,			///< Default ANSI codepage.

  68. 	kCP_MAC_ROMAN = 2,		///< Default Mac codepage.

  69. 

  70. 	kCP_ANSI_WEL = 1252,	///< West European Latin Encoding.

  71. 	kCP_MAC_CEE = 10029,	///< Mac Central European Encoding.

  72. 	kCP_Utf8 = 65001,		///< UTF8 Encoding.

  73. 	kCP_ShiftJIS = 932,		///< Shifted Japan Industrial Standard Encoding.

  74. 	kCP_US_ASCII = 20127,	///< US-ASCII (7-bit).

  75. 

  76. 	kCP_Default = kCP_ANSI	///< Default ANSI codepage.

  77. };

  78. 

  79. enum UnicodeNormalization

  80. {

  81. 	kUnicodeNormC,	///< Unicode normalization Form C, canonical composition. 

  82. 	kUnicodeNormD,	///< Unicode normalization Form D, canonical decomposition. 

  83. 	kUnicodeNormKC,	///< Unicode normalization form KC, compatibility composition. 

  84. 	kUnicodeNormKD 	///< Unicode normalization form KD, compatibility decomposition. 

  85. };

  86. 

  87. //------------------------------------------------------------------------

  88. // Helper functions to create hash codes from string data.

  89. //------------------------------------------------------------------------

  90. extern uint32 hashString8 (const char8* s, uint32 m);

  91. extern uint32 hashString16 (const char16* s, uint32 m);

  92. inline uint32 hashString (const tchar* s, uint32 m)

  93. {

  94. #ifdef UNICODE

  95. 	return hashString16 (s, m);

  96. #else

  97. 	return hashString8 (s, m);

  98. #endif

  99. }

  100. 

  101. 

  102. //-----------------------------------------------------------------------------

  103. /** Invariant String. 

  104. @ingroup adt

  105. 

  106. A base class which provides methods to work with its

  107. member string. Neither of the operations allows modifying the member string and 

  108. that is why all operation are declared as const. 

  109. 

  110. There are operations for access, comparison, find, numbers and conversion.

  111. 

  112. Almost all operations exist in three versions for char8, char16 and the 

  113. polymorphic type tchar. The type tchar can either be char8 or char16 depending

  114. on whether UNICODE is activated or not.*/

  115. //-----------------------------------------------------------------------------

  116. class ConstString

  117. {

  118. public:

  119. //-----------------------------------------------------------------------------

  120. 	ConstString (const char8* str, int32 length = -1);	///< Assign from string of type char8 (length=-1: all)

  121. 	ConstString (const char16* str, int32 length = -1);	///< Assign from string of type char16 (length=-1: all)

  122. 	ConstString (const ConstString& str, int32 offset = 0, int32 length = -1); ///< Copy constructor (length=-1: all).

  123. 	ConstString (const FVariant& var);	///< Assign a string from FVariant

  124. 	ConstString ();

  125. 	virtual ~ConstString () {}			///< Destructor.

  126. 

  127. 	// access -----------------------------------------------------------------

  128. 	virtual int32 length () const {return static_cast<int32> (len);}	///< Return length of string

  129. 	inline bool isEmpty () const {return buffer == nullptr || len == 0;}		///< Return true if string is empty

  130. 

  131. 	operator const char8* () const {return text8 ();} 							///< Returns pointer to string of type char8 (no modification allowed)

  132. 	operator const char16* () const {return text16 ();}							///< Returns pointer to string of type char16(no modification allowed)

  133. 	inline tchar operator[] (short idx) const {return getChar (static_cast<uint32> (idx));} ///< Returns character at 'idx'

  134. 	inline tchar operator[] (long idx) const {return getChar (static_cast<uint32> (idx));}

  135. 	inline tchar operator[] (int idx) const {return getChar (static_cast<uint32> (idx));}

  136. 	inline tchar operator[] (unsigned short idx) const {return getChar (idx);}

  137. 	inline tchar operator[] (unsigned long idx) const {return getChar (static_cast<uint32> (idx));}

  138. 	inline tchar operator[] (unsigned int idx) const {return getChar (idx);}

  139. 

  140. 	inline virtual const char8* text8 () const;		///< Returns pointer to string of type char8

  141. 	inline virtual const char16* text16 () const;	///< Returns pointer to string of type char16

  142. 	inline virtual const tchar* text () const;		///< Returns pointer to string of type tchar

  143. 	inline virtual const void* ptr () const {return buffer;}	///< Returns pointer to string of type void

  144. 

  145. 	inline virtual char8 getChar8 (uint32 index) const;		///< Returns character of type char16 at 'index'

  146. 	inline virtual char16 getChar16 (uint32 index) const;	///< Returns character of type char8 at 'index'

  147. 	inline tchar getChar (uint32 index) const;				///< Returns character of type tchar at 'index'

  148. 	inline tchar getCharAt (uint32 index) const;			///< Returns character of type tchar at 'index', no conversion!

  149. 

  150. 	bool testChar8 (uint32 index, char8 c) const;			///< Returns true if character is equal at position 'index'

  151. 	bool testChar16 (uint32 index, char16 c) const;

  152. 	inline bool testChar (uint32 index, char8 c) const {return testChar8 (index, c);}

  153. 	inline bool testChar (uint32 index, char16 c) const {return testChar16 (index, c);}

  154. 

  155. 	bool extract (String& result, uint32 idx, int32 n = -1) const;		///< Get n characters long substring starting at index (n=-1: until end)

  156. 	int32 copyTo8 (char8* str, uint32 idx = 0, int32 n = -1) const;

  157. 	int32 copyTo16 (char16* str, uint32 idx = 0, int32 n = -1) const;

  158. 	int32 copyTo (tchar* str, uint32 idx = 0, int32 n = -1) const;

  159. 	void copyTo (IStringResult* result) const;							///< Copies whole member string

  160. 	void copyTo (IString& string) const;							    ///< Copies whole member string

  161. 

  162. 	inline uint32 hash (uint32 tsize) const 

  163. 	{

  164. 		return isWide ? hashString16 (buffer16, tsize) : hashString8 (buffer8, tsize) ;  

  165. 	}

  166. 	//-------------------------------------------------------------------------

  167. 

  168. 	// compare ----------------------------------------------------------------

  169. 	enum CompareMode

  170. 	{

  171. 		kCaseSensitive,		///< Comparison is done with regard to character's case

  172. 		kCaseInsensitive	///< Comparison is done without regard to character's case

  173. 	};

  174. 

  175. 	int32 compareAt (uint32 index, const ConstString& str, int32 n = -1, CompareMode m = kCaseSensitive) const; 				///< Compare n characters of str with n characters of this starting at index (return: see above)

  176. 	int32 compare (const ConstString& str, int32 n, CompareMode m = kCaseSensitive) const;										///< Compare n characters of str with n characters of this (return: see above)

  177. 	int32 compare (const ConstString& str, CompareMode m = kCaseSensitive) const;												///< Compare all characters of str with this (return: see above)

  178. 

  179. 	int32 naturalCompare (const ConstString& str, CompareMode mode = kCaseSensitive) const;

  180. 

  181. 	bool startsWith (const ConstString& str, CompareMode m = kCaseSensitive) const;												///< Check if this starts with str

  182. 	bool endsWith (const ConstString& str, CompareMode m = kCaseSensitive) const;												///< Check if this ends with str

  183. 	bool contains (const ConstString& str, CompareMode m = kCaseSensitive) const;												///< Check if this contains str											

  184. 

  185. 	// static methods

  186. 	static bool isCharSpace (char8 character);	   ///< Returns true if character is a space

  187. 	static bool isCharSpace (char16 character);    ///< @copydoc isCharSpace(const char8)

  188. 	static bool isCharAlpha (char8 character);	   ///< Returns true if character is an alphabetic character

  189. 	static bool isCharAlpha (char16 character);    ///< @copydoc isCharAlpha(const char8)

  190. 	static bool isCharAlphaNum (char8 character);  ///< Returns true if character is an alphanumeric character

  191. 	static bool isCharAlphaNum (char16 character); ///< @copydoc isCharAlphaNum(const char8)

  192. 	static bool isCharDigit (char8 character);	   ///< Returns true if character is a number

  193. 	static bool isCharDigit (char16 character);    ///< @copydoc isCharDigit(const char8)

  194. 	static bool isCharAscii (char8 character);     ///< Returns true if character is in ASCII range

  195. 	static bool isCharAscii (char16 character);    ///< Returns true if character is in ASCII range

  196. 	static bool isCharUpper (char8 character);

  197. 	static bool isCharUpper (char16 character);

  198. 	static bool isCharLower (char8 character);

  199. 	static bool isCharLower (char16 character);

  200. 	//-------------------------------------------------------------------------

  201. 

  202. 	/** @name Find first occurrence of n characters of str in this (n=-1: all) ending at endIndex (endIndex = -1: all)*/

  203. 	///@{

  204. 	inline int32 findFirst (const ConstString& str, int32 n = -1, CompareMode m = kCaseSensitive, int32 endIndex = -1) const {return findNext (0, str, n, m, endIndex);}

  205. 	inline int32 findFirst (char8 c, CompareMode m = kCaseSensitive, int32 endIndex = -1) const {return findNext (0, c, m, endIndex);}

  206. 	inline int32 findFirst (char16 c, CompareMode m = kCaseSensitive, int32 endIndex = -1) const {return findNext (0, c, m, endIndex);}

  207. 	///@}

  208. 	/** @name Find next occurrence of n characters of str starting at startIndex in this (n=-1: all) ending at endIndex (endIndex = -1: all)*/

  209. 	///@{

  210. 	int32 findNext (int32 startIndex, const ConstString& str, int32 n = -1, CompareMode = kCaseSensitive, int32 endIndex = -1) const;

  211. 	int32 findNext (int32 startIndex, char8 c, CompareMode = kCaseSensitive, int32 endIndex = -1) const;

  212. 	int32 findNext (int32 startIndex, char16 c, CompareMode = kCaseSensitive, int32 endIndex = -1) const;

  213. 	///@}

  214. 	/** @name Find previous occurrence of n characters of str starting at startIndex in this (n=-1: all) */

  215. 	///@{

  216. 	int32 findPrev (int32 startIndex, const ConstString& str, int32 n = -1, CompareMode = kCaseSensitive) const;

  217. 	int32 findPrev (int32 startIndex, char8 c, CompareMode = kCaseSensitive) const;

  218. 	int32 findPrev (int32 startIndex, char16 c, CompareMode = kCaseSensitive) const;

  219. 	///@}

  220. 	

  221. 	inline int32 findLast (const ConstString& str, int32 n = -1, CompareMode m = kCaseSensitive) const {return findPrev (-1, str, n, m);}	///< Find last occurrence of n characters of str in this (n=-1: all)

  222. 	inline int32 findLast (char8 c, CompareMode m = kCaseSensitive) const {return findPrev (-1, c, m);}

  223. 	inline int32 findLast (char16 c, CompareMode m = kCaseSensitive) const {return findPrev (-1, c, m);}

  224. 

  225. 	int32 countOccurences (char8 c, uint32 startIndex, CompareMode = kCaseSensitive) const; ///< Counts occurences of c within this starting at index

  226. 	int32 countOccurences (char16 c, uint32 startIndex, CompareMode = kCaseSensitive) const;

  227. 	int32 getFirstDifferent (const ConstString& str, CompareMode = kCaseSensitive) const;	///< Returns position of first different character

  228. 	//-------------------------------------------------------------------------

  229. 

  230. 	// numbers ----------------------------------------------------------------

  231. 	bool isDigit (uint32 index) const;	///< Returns true if character at position is a digit

  232. 	bool scanFloat (double& value, uint32 offset = 0, bool scanToEnd = true) const;		///< Converts string to double value starting at offset

  233. 	bool scanInt64 (int64& value, uint32 offset = 0, bool scanToEnd = true) const;		///< Converts string to int64 value starting at offset

  234. 	bool scanUInt64 (uint64& value, uint32 offset = 0, bool scanToEnd = true) const;	///< Converts string to uint64 value starting at offset

  235. 	bool scanInt32 (int32& value, uint32 offset = 0, bool scanToEnd = true) const;		///< Converts string to int32 value starting at offset

  236. 	bool scanUInt32 (uint32& value, uint32 offset = 0, bool scanToEnd = true) const;	///< Converts string to uint32 value starting at offset

  237. 	bool scanHex (uint8& value, uint32 offset = 0, bool scanToEnd = true) const;		///< Converts string to hex/uint8 value starting at offset

  238. 

  239. 	int32 getTrailingNumberIndex (uint32 width = 0) const;	///< Returns start index of trailing number

  240. 	int64 getTrailingNumber (int64 fallback = 0) const;		///< Returns result of scanInt64 or the fallback

  241. 	int64 getNumber () const;								///< Returns result of scanInt64

  242. 

  243. 	// static methods

  244. 	static bool scanInt64_8 (const char8* text, int64& value, bool scanToEnd = true);	///< Converts string of type char8 to int64 value

  245. 	static bool scanInt64_16 (const char16* text, int64& value, bool scanToEnd = true);	///< Converts string of type char16 to int64 value

  246. 	static bool scanInt64 (const tchar* text, int64& value, bool scanToEnd = true);		///< Converts string of type tchar to int64 value

  247. 

  248. 	static bool scanUInt64_8 (const char8* text, uint64& value, bool scanToEnd = true);		///< Converts string of type char8 to uint64 value

  249. 	static bool scanUInt64_16 (const char16* text, uint64& value, bool scanToEnd = true);	///< Converts string of type char16 to uint64 value

  250. 	static bool scanUInt64 (const tchar* text, uint64& value, bool scanToEnd = true);		///< Converts string of type tchar to uint64 value

  251. 

  252. 	static bool scanInt32_8 (const char8* text, int32& value, bool scanToEnd = true);		///< Converts string of type char8 to int32 value

  253. 	static bool scanInt32_16 (const char16* text, int32& value, bool scanToEnd = true);		///< Converts string of type char16 to int32 value

  254. 	static bool scanInt32 (const tchar* text, int32& value, bool scanToEnd = true);			///< Converts string of type tchar to int32 value

  255. 

  256. 	static bool scanUInt32_8 (const char8* text, uint32& value, bool scanToEnd = true);		///< Converts string of type char8 to int32 value

  257. 	static bool scanUInt32_16 (const char16* text, uint32& value, bool scanToEnd = true);		///< Converts string of type char16 to int32 value

  258. 	static bool scanUInt32 (const tchar* text, uint32& value, bool scanToEnd = true);			///< Converts string of type tchar to int32 value

  259. 

  260. 	static bool scanHex_8 (const char8* text, uint8& value, bool scanToEnd = true);		///< Converts string of type char8 to hex/unit8 value

  261. 	static bool scanHex_16 (const char16* text, uint8& value, bool scanToEnd = true);	///< Converts string of type char16 to hex/unit8 value

  262. 	static bool scanHex (const tchar* text, uint8& value, bool scanToEnd = true);		///< Converts string of type tchar to hex/unit8 value

  263. 	//-------------------------------------------------------------------------

  264. 

  265. 	// conversion -------------------------------------------------------------

  266. 	void toVariant (FVariant& var) const;

  267. 

  268. 	static char8 toLower (char8 c);		///< Converts to lower case

  269. 	static char8 toUpper (char8 c);		///< Converts to upper case

  270. 	static char16 toLower (char16 c);

  271. 	static char16 toUpper (char16 c);

  272. 

  273. 	static int32 multiByteToWideString (char16* dest, const char8* source, int32 wcharCount, uint32 sourceCodePage = kCP_Default);	///< If dest is zero, this returns the maximum number of bytes needed to convert source

  274. 	static int32 wideStringToMultiByte (char8* dest, const char16* source, int32 char8Count, uint32 destCodePage = kCP_Default);	///< If dest is zero, this returns the maximum number of bytes needed to convert source

  275. 

  276. 	bool isWideString () const {return isWide != 0;}	///< Returns true if string is wide

  277. 	bool isAsciiString () const; 						///< Checks if all characters in string are in ascii range

  278. 

  279. 	bool isNormalized (UnicodeNormalization = kUnicodeNormC); ///< On PC only kUnicodeNormC is working

  280. 

  281. #if SMTG_OS_MACOS

  282. 	virtual void* toCFStringRef (uint32 encoding = 0xFFFF, bool mutableCFString = false) const;	///< CFString conversion

  283. #endif

  284. //-------------------------------------------------------------------------

  285. 

  286. //-----------------------------------------------------------------------------

  287. protected:

  288. 

  289. 	union 

  290. 	{

  291. 		void* buffer;

  292. 		char8* buffer8;

  293. 		char16* buffer16;

  294. 	};

  295. 	uint32 len : 30;

  296. 	uint32 isWide : 1;

  297. };

  298. 

  299. //-----------------------------------------------------------------------------

  300. /** String.

  301. @ingroup adt

  302. 

  303. Extends class ConstString by operations which allow modifications. 

  304. 

  305. \see ConstString */

  306. //-----------------------------------------------------------------------------

  307. class String : public ConstString

  308. {

  309. public:

  310. 	

  311. //-----------------------------------------------------------------------------

  312. 	String ();

  313. 	String (const char8* str, MBCodePage codepage, int32 n = -1, bool isTerminated = true);							///< assign n characters of str and convert to wide string by using the specified codepage

  314. 	String (const char8* str, int32 n = -1, bool isTerminated = true);	///< assign n characters of str (-1: all)

  315. 	String (const char16* str, int32 n = -1, bool isTerminated = true);	///< assign n characters of str (-1: all)

  316. 	String (const String& str, int32 n = -1);							///< assign n characters of str (-1: all)

  317. 	String (const ConstString& str, int32 n = -1);		///< assign n characters of str (-1: all)

  318. 	String (const FVariant& var);						///< assign from FVariant

  319. 	String (IString* str);						///< assign from IString

  320. 	~String ();

  321. 

  322. #if SMTG_CPP11_STDLIBSUPPORT

  323. 	String (String&& str);

  324. 	String& operator= (String&& str);

  325. #endif

  326. 

  327. 	// access------------------------------------------------------------------

  328. 	void updateLength (); ///< Call this when the string is truncated outside (not recommended though)

  329. 	const char8* text8 () const SMTG_OVERRIDE;

  330. 	const char16* text16 () const SMTG_OVERRIDE;

  331. 	char8 getChar8 (uint32 index) const SMTG_OVERRIDE;

  332. 	char16 getChar16 (uint32 index) const SMTG_OVERRIDE;

  333. 

  334. 	bool setChar8 (uint32 index, char8 c);

  335. 	bool setChar16 (uint32 index, char16 c);

  336. 	inline bool setChar (uint32 index, char8 c) {return setChar8 (index, c);}

  337. 	inline bool setChar (uint32 index, char16 c) {return setChar16 (index, c);}

  338. 	//-------------------------------------------------------------------------

  339. 

  340. 	// assignment--------------------------------------------------------------

  341. 	String& operator= (const char8* str) {return assign (str);}	///< Assign from a string of type char8

  342. 	String& operator= (const char16* str) {return assign (str);}

  343. 	String& operator= (const ConstString& str) {return assign (str);}

  344. 	String& operator= (const String& str) {return assign (str);}

  345. 	String& operator= (char8 c) {return assign (c);}

  346. 	String& operator= (char16 c) {return assign (c);}

  347. 

  348. 	String& assign (const ConstString& str, int32 n = -1);			///< Assign n characters of str (-1: all)

  349. 	String& assign (const char8* str, int32 n = -1, bool isTerminated = true);			///< Assign n characters of str (-1: all)

  350. 	String& assign (const char16* str, int32 n = -1, bool isTerminated = true);			///< Assign n characters of str (-1: all)

  351. 	String& assign (char8 c, int32 n = 1);

  352. 	String& assign (char16 c, int32 n = 1);

  353. 	//-------------------------------------------------------------------------

  354. 

  355. 	// concat------------------------------------------------------------------

  356. 	String& append (const ConstString& str, int32 n = -1);		///< Append n characters of str to this (n=-1: all)

  357. 	String& append (const char8* str, int32 n = -1);			///< Append n characters of str to this (n=-1: all)

  358. 	String& append (const char16* str, int32 n = -1);			///< Append n characters of str to this (n=-1: all)

  359. 	String& append (const char8 c, int32 n = 1);                ///< Append char c n times

  360. 	String& append (const char16 c, int32 n = 1);               ///< Append char c n times

  361. 

  362. 	String& insertAt (uint32 idx, const ConstString& str, int32 n = -1);	///< Insert n characters of str at position idx (n=-1: all)

  363. 	String& insertAt (uint32 idx, const char8* str, int32 n = -1);	///< Insert n characters of str at position idx (n=-1: all)

  364. 	String& insertAt (uint32 idx, const char16* str, int32 n = -1);	///< Insert n characters of str at position idx (n=-1: all)

  365. 	String& insertAt (uint32 idx, char8 c) {char8 str[] = {c, 0}; return insertAt (idx, str, 1);} 

  366. 	String& insertAt (uint32 idx, char16 c) {char16 str[] = {c, 0}; return insertAt (idx, str, 1);}

  367. 

  368. 	String& operator+= (const String& str) {return append (str);}

  369. 	String& operator+= (const ConstString& str) {return append (str);}

  370. 	String& operator+= (const char8* str) {return append (str);}

  371. 	String& operator+= (const char16* str) {return append (str);}

  372. 	String& operator+= (const char8 c) {return append (c);}

  373. 	String& operator+= (const char16 c) {return append (c);}

  374. 	//-------------------------------------------------------------------------

  375. 

  376. 	// replace-----------------------------------------------------------------

  377. 	String& replace (uint32 idx, int32 n1, const ConstString& str, int32 n2 = -1);		///< Replace n1 characters of this (starting at idx) with n2 characters of str (n1,n2=-1: until end)

  378. 	String& replace (uint32 idx, int32 n1, const char8* str, int32 n2 = -1);			///< Replace n1 characters of this (starting at idx) with n2 characters of str (n1,n2=-1: until end)

  379. 	String& replace (uint32 idx, int32 n1, const char16* str, int32 n2 = -1);			///< Replace n1 characters of this (starting at idx) with n2 characters of str (n1,n2=-1: until end)

  380. 

  381. 	int32 replace (const char8* toReplace, const char8* toReplaceWith, bool all = false, CompareMode m = kCaseSensitive);			///< Replace find string with replace string - returns number of replacements

  382. 	int32 replace (const char16* toReplace, const char16* toReplaceWith, bool all = false, CompareMode m = kCaseSensitive);		///< Replace find string with replace string - returns number of replacements

  383. 

  384. 	bool replaceChars8 (const char8* toReplace, char8 toReplaceBy); ///< Returns true when any replacement was done

  385. 	bool replaceChars16 (const char16* toReplace, char16 toReplaceBy);

  386. 	inline bool replaceChars8 (char8 toReplace, char8 toReplaceBy)  {char8 str[] = {toReplace, 0}; return replaceChars8 (str, toReplaceBy);}

  387. 	inline bool replaceChars16 (char16 toReplace, char16 toReplaceBy)  {char16 str[] = {toReplace, 0}; return replaceChars16 (str, toReplaceBy);}

  388. 	inline bool replaceChars (char8 toReplace, char8 toReplaceBy) {return replaceChars8 (toReplace, toReplaceBy);}

  389. 	inline bool replaceChars (char16 toReplace, char16 toReplaceBy) {return replaceChars16 (toReplace, toReplaceBy);}

  390. 	inline bool replaceChars (const char8* toReplace, char8 toReplaceBy) {return replaceChars8 (toReplace, toReplaceBy);}

  391. 	inline bool replaceChars (const char16* toReplace, char16 toReplaceBy) {return replaceChars16 (toReplace, toReplaceBy);}

  392. 	//-------------------------------------------------------------------------

  393. 

  394. 	// remove------------------------------------------------------------------

  395. 	String& remove (uint32 index = 0, int32 n = -1);		///< Remove n characters from string starting at index (n=-1: until end)

  396. 	enum CharGroup {kSpace, kNotAlphaNum, kNotAlpha};

  397. 	bool trim (CharGroup mode = kSpace);					///< Trim lead/trail.

  398. 	void removeChars (CharGroup mode = kSpace);				///< Removes all of group.

  399. 	bool removeChars8 (const char8* which);					///< Remove all occurrences of each char in 'which'

  400. 	bool removeChars16 (const char16* which);				///< Remove all occurrences of each char in 'which'

  401. 	inline bool removeChars8 (const char8 which) {char8 str[] = {which, 0}; return removeChars8 (str); }     

  402. 	inline bool removeChars16 (const char16 which) {char16 str[] = {which, 0}; return removeChars16 (str); }                

  403. 	inline bool removeChars (const char8* which) {return removeChars8 (which);}

  404. 	inline bool removeChars (const char16* which) {return removeChars16 (which);}

  405. 	inline bool removeChars (const char8 which) {return removeChars8 (which);}

  406. 	inline bool removeChars (const char16 which) {return removeChars16 (which);}

  407. 	bool removeSubString (const ConstString& subString, bool allOccurences = true);

  408. 	//-------------------------------------------------------------------------

  409. 

  410. 	// print-------------------------------------------------------------------

  411. 	String& printf (const char8* format, ...);					///< Print formatted data into string

  412. 	String& printf (const char16* format, ...);					///< Print formatted data into string

  413. 	String& vprintf (const char8* format, va_list args);

  414. 	String& vprintf (const char16* format, va_list args);

  415. 	//-------------------------------------------------------------------------

  416. 

  417. 	// numbers-----------------------------------------------------------------

  418. 	String& printInt64 (int64 value);

  419. 	String& printFloat (double value);

  420. 	/** Increment the trailing number if present else start with minNumber, width specifies the string width format (width 2 for number 3 is 03),

  421. 		applyOnlyFormat set to true will only format the string to the given width without incrementing the founded trailing number */

  422. 	bool incrementTrailingNumber (uint32 width = 2, tchar separator = STR (' '), uint32 minNumber = 1, bool applyOnlyFormat = false);

  423. 	//-------------------------------------------------------------------------

  424. 

  425. 	// conversion--------------------------------------------------------------

  426. 	bool fromVariant (const FVariant& var);		///< Assigns string from FVariant

  427. 	void toVariant (FVariant& var) const;

  428. 	bool fromAttributes (IAttributes* a, IAttrID attrID);	///< Assigns string from FAttributes

  429. 	bool toAttributes (IAttributes* a, IAttrID attrID);

  430. 

  431. 	void swapContent (String& s); 								///< Swaps ownership of the strings pointed to

  432. 	void take (String& str);      								///< Take ownership of the string of 'str'

  433. 	void take (void* _buffer, bool wide);      					///< Take ownership of buffer

  434. 	void* pass ();

  435. 	void passToVariant (FVariant& var);							///< Pass ownership of buffer to Variant - sets Variant ownership

  436. 

  437. 	void toLower (uint32 index);								///< Lower case the character.

  438. 	void toLower ();											///< Lower case the string.

  439. 	void toUpper (uint32 index);								///< Upper case the character.

  440. 	void toUpper ();											///< Upper case the string.

  441. 

  442. 	unsigned char* toPascalString (unsigned char* buf);			///< Pascal string conversion

  443. 	const String& fromPascalString (const unsigned char* buf);	///< Pascal string conversion

  444. 

  445. 	bool toWideString (uint32 sourceCodePage = kCP_Default);	///< Converts to wide string according to sourceCodePage

  446. 	bool toMultiByte (uint32 destCodePage = kCP_Default);

  447. 

  448. 	void fromUTF8 (const char8* utf8String);				///< Assigns from UTF8 string

  449. 	bool normalize (UnicodeNormalization = kUnicodeNormC);	///< On PC only kUnicodeNormC is working

  450. 

  451. #if SMTG_OS_MACOS

  452. 	virtual bool fromCFStringRef (const void*, uint32 encoding = 0xFFFF);	///< CFString conversion

  453. #endif

  454. 	//-------------------------------------------------------------------------

  455. 

  456. 	//-----------------------------------------------------------------------------

  457. protected:

  458. 	bool resize (uint32 newSize, bool wide, bool fill = false);

  459. 

  460. private:

  461. 	void tryFreeBuffer ();

  462. 	bool checkToMultiByte (uint32 destCodePage = kCP_Default) const; // to remove debug code from inline - const_cast inside!!!

  463. };

  464. 

  465. // String concatenation functions.

  466. inline String operator+ (const ConstString& s1, const ConstString& s2) {return String (s1).append (s2);}

  467. inline String operator+ (const ConstString& s1, const char8* s2) {return String (s1).append (s2);}

  468. inline String operator+ (const ConstString& s1, const char16* s2) {return String (s1).append (s2);}

  469. inline String operator+ (const char8* s1, const ConstString& s2) {return String (s1).append (s2);}

  470. inline String operator+ (const char16* s1, const ConstString& s2) {return String (s1).append (s2);}

  471. inline String operator+ (const ConstString& s1, const String& s2) {return String (s1).append (s2);}

  472. inline String operator+ (const String& s1, const ConstString& s2) {return String (s1).append (s2);}

  473. inline String operator+ (const String& s1, const String& s2) {return String (s1).append (s2);}

  474. inline String operator+ (const String& s1, const char8* s2) {return String (s1).append (s2);}

  475. inline String operator+ (const String& s1, const char16* s2) {return String (s1).append (s2);}

  476. inline String operator+ (const char8* s1, const String& s2) {return String (s1).append (s2);}

  477. inline String operator+ (const char16* s1, const String& s2) {return String (s1).append (s2);}

  478. 

  479. //-----------------------------------------------------------------------------

  480. // ConstString

  481. //-----------------------------------------------------------------------------

  482. inline const tchar* ConstString::text () const

  483. {

  484. #ifdef UNICODE

  485. 	return text16 ();

  486. #else

  487. 	return text8 ();

  488. #endif

  489. }

  490. 

  491. //-----------------------------------------------------------------------------

  492. inline const char8* ConstString::text8 () const

  493. {

  494. 	return (!isWide && buffer8) ? buffer8: kEmptyString8;

  495. }

  496. 

  497. //-----------------------------------------------------------------------------

  498. inline const char16* ConstString::text16 () const

  499. {

  500. 	return (isWide && buffer16) ? buffer16 : kEmptyString16;

  501. }

  502. 

  503. //-----------------------------------------------------------------------------

  504. inline char8 ConstString::getChar8 (uint32 index) const

  505. {

  506. 	if (index < len && buffer8 && !isWide)

  507. 		return buffer8[index];

  508. 	return 0;

  509. }

  510. 

  511. //-----------------------------------------------------------------------------

  512. inline char16 ConstString::getChar16 (uint32 index) const

  513. {

  514. 	if (index < len && buffer16 && isWide)

  515. 		return buffer16[index];

  516. 	return 0;

  517. }

  518. 

  519. //-----------------------------------------------------------------------------

  520. inline tchar ConstString::getChar (uint32 index) const

  521. {

  522. #ifdef UNICODE

  523. 	return getChar16 (index);

  524. #else

  525. 	return getChar8 (index);

  526. #endif

  527. }

  528. 

  529. //-----------------------------------------------------------------------------

  530. inline tchar ConstString::getCharAt (uint32 index) const

  531. {

  532. #ifdef UNICODE

  533. 	if (isWide)

  534. 		return getChar16 (index);

  535. #endif

  536. 

  537. 	return static_cast<tchar> (getChar8 (index));

  538. }

  539. 

  540. //-----------------------------------------------------------------------------

  541. inline int64 ConstString::getNumber () const

  542. {

  543. 	int64 tmp = 0;

  544. 	scanInt64 (tmp);

  545. 	return tmp;

  546. }

  547. 

  548. //-----------------------------------------------------------------------------

  549. inline bool ConstString::scanInt32_8 (const char8* text, int32& value, bool scanToEnd)

  550. {

  551. 	int64 tmp;

  552. 	if (scanInt64_8 (text, tmp, scanToEnd))

  553. 	{

  554. 		value = (int32)tmp;

  555. 		return true;

  556. 	}

  557. 	return false;

  558. }

  559. 

  560. //-----------------------------------------------------------------------------

  561. inline bool ConstString::scanInt32_16 (const char16* text, int32& value, bool scanToEnd)

  562. {

  563. 	int64 tmp;

  564. 	if (scanInt64_16 (text, tmp, scanToEnd))

  565. 	{

  566. 		value = (int32)tmp;

  567. 		return true;

  568. 	}

  569. 	return false;

  570. }

  571. 

  572. //-----------------------------------------------------------------------------

  573. inline bool ConstString::scanInt32 (const tchar* text, int32& value, bool scanToEnd)

  574. {

  575. 	int64 tmp;

  576. 	if (scanInt64 (text, tmp, scanToEnd))

  577. 	{

  578. 		value = (int32)tmp;

  579. 		return true;

  580. 	}

  581. 	return false;

  582. }

  583. 

  584. //-----------------------------------------------------------------------------

  585. inline bool ConstString::scanUInt32_8 (const char8* text, uint32& value, bool scanToEnd)

  586. {

  587. 	uint64 tmp;

  588. 	if (scanUInt64_8 (text, tmp, scanToEnd))

  589. 	{

  590. 		value = (uint32)tmp;

  591. 		return true;

  592. 	}

  593. 	return false;

  594. }

  595. 

  596. //-----------------------------------------------------------------------------

  597. inline bool ConstString::scanUInt32_16 (const char16* text, uint32& value, bool scanToEnd)

  598. {

  599. 	uint64 tmp;

  600. 	if (scanUInt64_16 (text, tmp, scanToEnd))

  601. 	{

  602. 		value = (uint32)tmp;

  603. 		return true;

  604. 	}

  605. 	return false;

  606. }

  607. 

  608. //-----------------------------------------------------------------------------

  609. inline bool ConstString::scanUInt32 (const tchar* text, uint32& value, bool scanToEnd)

  610. {

  611. 	uint64 tmp;

  612. 	if (scanUInt64 (text, tmp, scanToEnd))

  613. 	{

  614. 		value = (uint32)tmp;

  615. 		return true;

  616. 	}

  617. 	return false;

  618. }

  619. 

  620. //-----------------------------------------------------------------------------

  621. inline const char8* String::text8 () const

  622. {

  623. 	if (isWide && !isEmpty ())

  624. 		checkToMultiByte (); // this should be avoided, since it can lead to information loss

  625. 

  626. 	return ConstString::text8 ();

  627. }

  628. 

  629. //-----------------------------------------------------------------------------

  630. inline const char16* String::text16 () const

  631. {

  632. 	if (!isWide && !isEmpty ())

  633. 	{

  634. 		const_cast<String&> (*this).toWideString ();

  635. 	}

  636. 	return ConstString::text16 ();

  637. }

  638. 

  639. //-----------------------------------------------------------------------------

  640. inline char8 String::getChar8 (uint32 index) const

  641. {

  642. 	if (isWide && !isEmpty ())

  643. 		checkToMultiByte (); // this should be avoided, since it can lead to information loss

  644. 

  645. 	return ConstString::getChar8 (index);

  646. }

  647. 

  648. //-----------------------------------------------------------------------------

  649. inline char16 String::getChar16 (uint32 index) const

  650. {

  651. 	if (!isWide && !isEmpty ())

  652. 	{

  653. 		const_cast<String&> (*this).toWideString ();

  654. 	}

  655. 	return ConstString::getChar16 (index);

  656. }

  657. 

  658. //-----------------------------------------------------------------------------

  659. 

  660. 

  661. inline bool operator<  (const ConstString& s1, const ConstString& s2) {return (s1.compare (s2) < 0) ? true : false;}

  662. inline bool operator<= (const ConstString& s1, const ConstString& s2) {return (s1.compare (s2) <= 0) ? true : false;}

  663. inline bool operator>  (const ConstString& s1, const ConstString& s2) {return (s1.compare (s2) > 0) ? true : false;}

  664. inline bool operator>= (const ConstString& s1, const ConstString& s2) {return (s1.compare (s2) >= 0) ? true : false;}

  665. inline bool operator== (const ConstString& s1, const ConstString& s2) {return (s1.compare (s2) == 0) ? true : false;}

  666. inline bool operator!= (const ConstString& s1, const ConstString& s2) {return (s1.compare (s2) != 0) ? true : false;}

  667. 

  668. inline bool operator<  (const ConstString& s1, const char8* s2) {return (s1.compare (s2) < 0) ? true : false;}

  669. inline bool operator<= (const ConstString& s1, const char8* s2) {return (s1.compare (s2) <= 0) ? true : false;}

  670. inline bool operator>  (const ConstString& s1, const char8* s2) {return (s1.compare (s2) > 0) ? true : false;}

  671. inline bool operator>= (const ConstString& s1, const char8* s2) {return (s1.compare (s2) >= 0) ? true : false;}

  672. inline bool operator== (const ConstString& s1, const char8* s2) {return (s1.compare (s2) == 0) ? true : false;}

  673. inline bool operator!= (const ConstString& s1, const char8* s2) {return (s1.compare (s2) != 0) ? true : false;}

  674. inline bool operator<  (const char8* s1, const ConstString& s2) {return (s2.compare (s1) > 0) ? true : false;}

  675. inline bool operator<= (const char8* s1, const ConstString& s2) {return (s2.compare (s1) >= 0) ? true : false;}

  676. inline bool operator>  (const char8* s1, const ConstString& s2) {return (s2.compare (s1) < 0) ? true : false;}

  677. inline bool operator>= (const char8* s1, const ConstString& s2) {return (s2.compare (s1) <= 0) ? true : false;}

  678. inline bool operator== (const char8* s1, const ConstString& s2) {return (s2.compare (s1) == 0) ? true : false;}

  679. inline bool operator!= (const char8* s1, const ConstString& s2) {return (s2.compare (s1) != 0) ? true : false;}

  680. 

  681. inline bool operator<  (const ConstString& s1, const char16* s2) {return (s1.compare (s2) < 0) ? true : false;}

  682. inline bool operator<= (const ConstString& s1, const char16* s2) {return (s1.compare (s2) <= 0) ? true : false;}

  683. inline bool operator>  (const ConstString& s1, const char16* s2) {return (s1.compare (s2) > 0) ? true : false;}

  684. inline bool operator>= (const ConstString& s1, const char16* s2) {return (s1.compare (s2) >= 0) ? true : false;}

  685. inline bool operator== (const ConstString& s1, const char16* s2) {return (s1.compare (s2) == 0) ? true : false;}

  686. inline bool operator!= (const ConstString& s1, const char16* s2) {return (s1.compare (s2) != 0) ? true : false;}

  687. inline bool operator<  (const char16* s1, const ConstString& s2) {return (s2.compare (s1) > 0) ? true : false;}

  688. inline bool operator<= (const char16* s1, const ConstString& s2) {return (s2.compare (s1) >= 0) ? true : false;}

  689. inline bool operator>  (const char16* s1, const ConstString& s2) {return (s2.compare (s1) < 0) ? true : false;}

  690. inline bool operator>= (const char16* s1, const ConstString& s2) {return (s2.compare (s1) <= 0) ? true : false;}

  691. inline bool operator== (const char16* s1, const ConstString& s2) {return (s2.compare (s1) == 0) ? true : false;}

  692. inline bool operator!= (const char16* s1, const ConstString& s2) {return (s2.compare (s1) != 0) ? true : false;}

  693. 

  694. // The following functions will only work with European Numbers!

  695. // (e.g. Arabic, Tibetan, and Khmer digits are not supported)

  696. extern int32 strnatcmp8 (const char8* s1, const char8* s2, bool caseSensitive = true);

  697. extern int32 strnatcmp16 (const char16* s1, const char16* s2, bool caseSensitive = true);

  698. inline int32 strnatcmp (const tchar* s1, const tchar* s2, bool caseSensitive = true)

  699. {

  700. #ifdef UNICODE

  701. 	return strnatcmp16 (s1, s2, caseSensitive);

  702. #else

  703. 	return strnatcmp8 (s1, s2, caseSensitive);

  704. #endif

  705. }

  706. 

  707. //-----------------------------------------------------------------------------

  708. /** StringObject implements IStringResult and IString methods.

  709.     It can therefore be exchanged with other Steinberg objects using one or both of these

  710. interfaces.

  711. 

  712. \see String, ConstString

  713. */

  714. //-----------------------------------------------------------------------------

  715. class StringObject : public FObject, public String, public IStringResult, public IString

  716. {

  717. public:

  718. //-----------------------------------------------------------------------------

  719. 	StringObject () {}										

  720. 	StringObject (const char16* str, int32 n = -1, bool isTerminated = true) : String (str, n, isTerminated) {}

  721. 	StringObject (const char8* str, int32 n = -1, bool isTerminated = true) : String (str, n, isTerminated) {}

  722. 	StringObject (const StringObject& str, int32 n = -1) : String (str, n) {}		

  723. 	StringObject (const String& str, int32 n = -1) : String (str, n) {}		

  724. 	StringObject (const FVariant& var) : String (var) {}		

  725. 

  726. 	using String::operator=;

  727. 

  728. 	// IStringResult ----------------------------------------------------------

  729. 	void PLUGIN_API setText (const char8* text) SMTG_OVERRIDE;

  730. 	//-------------------------------------------------------------------------

  731. 

  732. 	// IString-----------------------------------------------------------------

  733. 	void PLUGIN_API setText8 (const char8* text) SMTG_OVERRIDE;

  734. 	void PLUGIN_API setText16 (const char16* text) SMTG_OVERRIDE;

  735. 

  736. 	const char8* PLUGIN_API getText8 () SMTG_OVERRIDE;

  737. 	const char16* PLUGIN_API getText16 () SMTG_OVERRIDE;

  738. 

  739. 	void PLUGIN_API take (void* s, bool _isWide) SMTG_OVERRIDE;

  740. 	bool PLUGIN_API isWideString () const SMTG_OVERRIDE;

  741. 	//-------------------------------------------------------------------------

  742. 

  743. 	OBJ_METHODS (StringObject, FObject)

  744. 	FUNKNOWN_METHODS2 (IStringResult, IString, FObject)

  745. };

  746. 

  747. //------------------------------------------------------------------------

  748. } // namespace Steinberg