OpenShot Audio Library | OpenShotAudio  0.3.1
juce_CharPointer_UTF32.h
1 /*
2  ==============================================================================
3 
4  This file is part of the JUCE library.
5  Copyright (c) 2017 - ROLI Ltd.
6 
7  JUCE is an open source library subject to commercial or open-source
8  licensing.
9 
10  The code included in this file is provided under the terms of the ISC license
11  http://www.isc.org/downloads/software-support-policy/isc-license. Permission
12  To use, copy, modify, and/or distribute this software for any purpose with or
13  without fee is hereby granted provided that the above copyright notice and
14  this permission notice appear in all copies.
15 
16  JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
17  EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
18  DISCLAIMED.
19 
20  ==============================================================================
21 */
22 
23 namespace juce
24 {
25 
26 //==============================================================================
34 class CharPointer_UTF32 final
35 {
36 public:
37  using CharType = juce_wchar;
38 
39  inline explicit CharPointer_UTF32 (const CharType* rawPointer) noexcept
40  : data (const_cast<CharType*> (rawPointer))
41  {
42  }
43 
44  inline CharPointer_UTF32 (const CharPointer_UTF32& other) = default;
45 
46  inline CharPointer_UTF32 operator= (CharPointer_UTF32 other) noexcept
47  {
48  data = other.data;
49  return *this;
50  }
51 
52  inline CharPointer_UTF32 operator= (const CharType* text) noexcept
53  {
54  data = const_cast<CharType*> (text);
55  return *this;
56  }
57 
59  inline bool operator== (CharPointer_UTF32 other) const noexcept { return data == other.data; }
60  inline bool operator!= (CharPointer_UTF32 other) const noexcept { return data != other.data; }
61  inline bool operator<= (CharPointer_UTF32 other) const noexcept { return data <= other.data; }
62  inline bool operator< (CharPointer_UTF32 other) const noexcept { return data < other.data; }
63  inline bool operator>= (CharPointer_UTF32 other) const noexcept { return data >= other.data; }
64  inline bool operator> (CharPointer_UTF32 other) const noexcept { return data > other.data; }
65 
67  inline CharType* getAddress() const noexcept { return data; }
68 
70  inline operator const CharType*() const noexcept { return data; }
71 
73  inline bool isEmpty() const noexcept { return *data == 0; }
74 
76  inline bool isNotEmpty() const noexcept { return *data != 0; }
77 
79  inline juce_wchar operator*() const noexcept { return *data; }
80 
82  inline CharPointer_UTF32 operator++() noexcept
83  {
84  ++data;
85  return *this;
86  }
87 
89  inline CharPointer_UTF32 operator--() noexcept
90  {
91  --data;
92  return *this;
93  }
94 
97  inline juce_wchar getAndAdvance() noexcept { return *data++; }
98 
101  {
102  auto temp (*this);
103  ++data;
104  return temp;
105  }
106 
108  inline void operator+= (int numToSkip) noexcept
109  {
110  data += numToSkip;
111  }
112 
113  inline void operator-= (int numToSkip) noexcept
114  {
115  data -= numToSkip;
116  }
117 
119  inline juce_wchar& operator[] (int characterIndex) const noexcept
120  {
121  return data [characterIndex];
122  }
123 
125  CharPointer_UTF32 operator+ (int numToSkip) const noexcept
126  {
127  return CharPointer_UTF32 (data + numToSkip);
128  }
129 
131  CharPointer_UTF32 operator- (int numToSkip) const noexcept
132  {
133  return CharPointer_UTF32 (data - numToSkip);
134  }
135 
137  inline void write (juce_wchar charToWrite) noexcept
138  {
139  *data++ = charToWrite;
140  }
141 
142  inline void replaceChar (juce_wchar newChar) noexcept
143  {
144  *data = newChar;
145  }
146 
148  inline void writeNull() const noexcept
149  {
150  *data = 0;
151  }
152 
154  size_t length() const noexcept
155  {
156  #if JUCE_NATIVE_WCHAR_IS_UTF32 && ! JUCE_ANDROID
157  return wcslen (data);
158  #else
159  size_t n = 0;
160  while (data[n] != 0)
161  ++n;
162  return n;
163  #endif
164  }
165 
167  size_t lengthUpTo (size_t maxCharsToCount) const noexcept
168  {
169  return CharacterFunctions::lengthUpTo (*this, maxCharsToCount);
170  }
171 
173  size_t lengthUpTo (CharPointer_UTF32 end) const noexcept
174  {
175  return CharacterFunctions::lengthUpTo (*this, end);
176  }
177 
181  size_t sizeInBytes() const noexcept
182  {
183  return sizeof (CharType) * (length() + 1);
184  }
185 
189  static inline size_t getBytesRequiredFor (juce_wchar) noexcept
190  {
191  return sizeof (CharType);
192  }
193 
198  template <class CharPointer>
199  static size_t getBytesRequiredFor (CharPointer text) noexcept
200  {
201  return sizeof (CharType) * text.length();
202  }
203 
206  {
207  return CharPointer_UTF32 (data + length());
208  }
209 
211  template <typename CharPointer>
212  void writeAll (CharPointer src) noexcept
213  {
214  CharacterFunctions::copyAll (*this, src);
215  }
216 
218  void writeAll (CharPointer_UTF32 src) noexcept
219  {
220  auto* s = src.data;
221 
222  while ((*data = *s) != 0)
223  {
224  ++data;
225  ++s;
226  }
227  }
228 
233  template <typename CharPointer>
234  size_t writeWithDestByteLimit (CharPointer src, size_t maxDestBytes) noexcept
235  {
236  return CharacterFunctions::copyWithDestByteLimit (*this, src, maxDestBytes);
237  }
238 
243  template <typename CharPointer>
244  void writeWithCharLimit (CharPointer src, int maxChars) noexcept
245  {
246  CharacterFunctions::copyWithCharLimit (*this, src, maxChars);
247  }
248 
250  template <typename CharPointer>
251  int compare (CharPointer other) const noexcept
252  {
253  return CharacterFunctions::compare (*this, other);
254  }
255 
256  #if JUCE_NATIVE_WCHAR_IS_UTF32 && ! JUCE_ANDROID
257 
258  int compare (CharPointer_UTF32 other) const noexcept
259  {
260  return wcscmp (data, other.data);
261  }
262  #endif
263 
265  template <typename CharPointer>
266  int compareUpTo (CharPointer other, int maxChars) const noexcept
267  {
268  return CharacterFunctions::compareUpTo (*this, other, maxChars);
269  }
270 
272  template <typename CharPointer>
273  int compareIgnoreCase (CharPointer other) const
274  {
275  return CharacterFunctions::compareIgnoreCase (*this, other);
276  }
277 
279  template <typename CharPointer>
280  int compareIgnoreCaseUpTo (CharPointer other, int maxChars) const noexcept
281  {
282  return CharacterFunctions::compareIgnoreCaseUpTo (*this, other, maxChars);
283  }
284 
286  template <typename CharPointer>
287  int indexOf (CharPointer stringToFind) const noexcept
288  {
289  return CharacterFunctions::indexOf (*this, stringToFind);
290  }
291 
293  int indexOf (juce_wchar charToFind) const noexcept
294  {
295  int i = 0;
296 
297  while (data[i] != 0)
298  {
299  if (data[i] == charToFind)
300  return i;
301 
302  ++i;
303  }
304 
305  return -1;
306  }
307 
309  int indexOf (juce_wchar charToFind, bool ignoreCase) const noexcept
310  {
311  return ignoreCase ? CharacterFunctions::indexOfCharIgnoreCase (*this, charToFind)
312  : CharacterFunctions::indexOfChar (*this, charToFind);
313  }
314 
316  bool isWhitespace() const { return CharacterFunctions::isWhitespace (*data) != 0; }
318  bool isDigit() const { return CharacterFunctions::isDigit (*data) != 0; }
320  bool isLetter() const { return CharacterFunctions::isLetter (*data) != 0; }
322  bool isLetterOrDigit() const { return CharacterFunctions::isLetterOrDigit (*data) != 0; }
324  bool isUpperCase() const { return CharacterFunctions::isUpperCase (*data) != 0; }
326  bool isLowerCase() const { return CharacterFunctions::isLowerCase (*data) != 0; }
327 
329  juce_wchar toUpperCase() const noexcept { return CharacterFunctions::toUpperCase (*data); }
331  juce_wchar toLowerCase() const noexcept { return CharacterFunctions::toLowerCase (*data); }
332 
334  int getIntValue32() const noexcept { return CharacterFunctions::getIntValue <int, CharPointer_UTF32> (*this); }
336  int64 getIntValue64() const noexcept { return CharacterFunctions::getIntValue <int64, CharPointer_UTF32> (*this); }
337 
339  double getDoubleValue() const noexcept { return CharacterFunctions::getDoubleValue (*this); }
340 
343 
345  static bool canRepresent (juce_wchar character) noexcept
346  {
347  return ((uint32) character) < (uint32) 0x10ffff;
348  }
349 
351  static bool isValidString (const CharType* dataToTest, int maxBytesToRead)
352  {
353  maxBytesToRead /= (int) sizeof (CharType);
354 
355  while (--maxBytesToRead >= 0 && *dataToTest != 0)
356  if (! canRepresent (*dataToTest++))
357  return false;
358 
359  return true;
360  }
361 
364  {
365  return CharPointer_UTF32 (reinterpret_cast<Atomic<CharType*>&> (data).exchange (newValue.data));
366  }
367 
368 private:
369  CharType* data;
370 };
371 
372 } // namespace juce
bool isEmpty() const noexcept
static double getDoubleValue(CharPointerType text) noexcept
static size_t getBytesRequiredFor(juce_wchar) noexcept
static juce_wchar toUpperCase(juce_wchar character) noexcept
CharPointer_UTF32 operator--() noexcept
int compareUpTo(CharPointer other, int maxChars) const noexcept
CharPointer_UTF32 operator+(int numToSkip) const noexcept
static int indexOfCharIgnoreCase(Type text, juce_wchar charToFind) noexcept
static void copyAll(DestCharPointerType &dest, SrcCharPointerType src) noexcept
static int compareIgnoreCase(juce_wchar char1, juce_wchar char2) noexcept
CharPointer_UTF32 operator-(int numToSkip) const noexcept
int compare(CharPointer other) const noexcept
size_t writeWithDestByteLimit(CharPointer src, size_t maxDestBytes) noexcept
static bool isDigit(char character) noexcept
static Type findEndOfWhitespace(Type text) noexcept
void writeWithCharLimit(CharPointer src, int maxChars) noexcept
void writeNull() const noexcept
int64 getIntValue64() const noexcept
size_t lengthUpTo(CharPointer_UTF32 end) const noexcept
int indexOf(juce_wchar charToFind, bool ignoreCase) const noexcept
static size_t getBytesRequiredFor(CharPointer text) noexcept
static bool isWhitespace(char character) noexcept
CharType * getAddress() const noexcept
juce_wchar operator*() const noexcept
void writeAll(CharPointer_UTF32 src) noexcept
CharPointer_UTF32 atomicSwap(CharPointer_UTF32 newValue)
size_t lengthUpTo(size_t maxCharsToCount) const noexcept
static int indexOfChar(Type text, const juce_wchar charToFind) noexcept
static int compareIgnoreCaseUpTo(CharPointerType1 s1, CharPointerType2 s2, int maxChars) noexcept
int indexOf(juce_wchar charToFind) const noexcept
bool isNotEmpty() const noexcept
static bool isUpperCase(juce_wchar character) noexcept
int compareIgnoreCaseUpTo(CharPointer other, int maxChars) const noexcept
juce_wchar getAndAdvance() noexcept
static size_t lengthUpTo(CharPointerType text, const size_t maxCharsToCount) noexcept
static bool isValidString(const CharType *dataToTest, int maxBytesToRead)
static size_t copyWithDestByteLimit(DestCharPointerType &dest, SrcCharPointerType src, size_t maxBytesToWrite) noexcept
size_t sizeInBytes() const noexcept
int getIntValue32() const noexcept
double getDoubleValue() const noexcept
int indexOf(CharPointer stringToFind) const noexcept
size_t length() const noexcept
static juce_wchar toLowerCase(juce_wchar character) noexcept
static bool isLetter(char character) noexcept
int compareIgnoreCase(CharPointer other) const
juce_wchar toUpperCase() const noexcept
CharPointer_UTF32 operator++() noexcept
juce_wchar toLowerCase() const noexcept
static int indexOf(CharPointerType1 textToSearch, const CharPointerType2 substringToLookFor) noexcept
void operator+=(int numToSkip) noexcept
static bool isLowerCase(juce_wchar character) noexcept
void write(juce_wchar charToWrite) noexcept
static bool canRepresent(juce_wchar character) noexcept
bool operator==(CharPointer_UTF32 other) const noexcept
juce_wchar & operator[](int characterIndex) const noexcept
static bool isLetterOrDigit(char character) noexcept
CharPointer_UTF32 findEndOfWhitespace() const noexcept
static int compareUpTo(CharPointerType1 s1, CharPointerType2 s2, int maxChars) noexcept
CharPointer_UTF32 findTerminatingNull() const noexcept
static void copyWithCharLimit(DestCharPointerType &dest, SrcCharPointerType src, int maxChars) noexcept
static int compare(juce_wchar char1, juce_wchar char2) noexcept
void writeAll(CharPointer src) noexcept