OpenShot Audio Library | OpenShotAudio  0.3.1
juce_CharPointer_ASCII.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 //==============================================================================
37 class CharPointer_ASCII final
38 {
39 public:
40  using CharType = char;
41 
42  inline explicit CharPointer_ASCII (const CharType* rawPointer) noexcept
43  : data (const_cast<CharType*> (rawPointer))
44  {
45  }
46 
47  inline CharPointer_ASCII (const CharPointer_ASCII& other) = default;
48 
49  inline CharPointer_ASCII operator= (const CharPointer_ASCII other) noexcept
50  {
51  data = other.data;
52  return *this;
53  }
54 
55  inline CharPointer_ASCII operator= (const CharType* text) noexcept
56  {
57  data = const_cast<CharType*> (text);
58  return *this;
59  }
60 
62  inline bool operator== (CharPointer_ASCII other) const noexcept { return data == other.data; }
63  inline bool operator!= (CharPointer_ASCII other) const noexcept { return data != other.data; }
64  inline bool operator<= (CharPointer_ASCII other) const noexcept { return data <= other.data; }
65  inline bool operator< (CharPointer_ASCII other) const noexcept { return data < other.data; }
66  inline bool operator>= (CharPointer_ASCII other) const noexcept { return data >= other.data; }
67  inline bool operator> (CharPointer_ASCII other) const noexcept { return data > other.data; }
68 
70  inline CharType* getAddress() const noexcept { return data; }
71 
73  inline operator const CharType*() const noexcept { return data; }
74 
76  inline bool isEmpty() const noexcept { return *data == 0; }
77 
79  inline bool isNotEmpty() const noexcept { return *data != 0; }
80 
82  inline juce_wchar operator*() const noexcept { return (juce_wchar) (uint8) *data; }
83 
85  inline CharPointer_ASCII operator++() noexcept
86  {
87  ++data;
88  return *this;
89  }
90 
92  inline CharPointer_ASCII operator--() noexcept
93  {
94  --data;
95  return *this;
96  }
97 
100  inline juce_wchar getAndAdvance() noexcept { return (juce_wchar) (uint8) *data++; }
101 
104  {
105  auto temp (*this);
106  ++data;
107  return temp;
108  }
109 
111  inline void operator+= (const int numToSkip) noexcept
112  {
113  data += numToSkip;
114  }
115 
116  inline void operator-= (const int numToSkip) noexcept
117  {
118  data -= numToSkip;
119  }
120 
122  inline juce_wchar operator[] (const int characterIndex) const noexcept
123  {
124  return (juce_wchar) (uint8) data [characterIndex];
125  }
126 
128  CharPointer_ASCII operator+ (const int numToSkip) const noexcept
129  {
130  return CharPointer_ASCII (data + numToSkip);
131  }
132 
134  CharPointer_ASCII operator- (const int numToSkip) const noexcept
135  {
136  return CharPointer_ASCII (data - numToSkip);
137  }
138 
140  inline void write (const juce_wchar charToWrite) noexcept
141  {
142  *data++ = (char) charToWrite;
143  }
144 
145  inline void replaceChar (const juce_wchar newChar) noexcept
146  {
147  *data = (char) newChar;
148  }
149 
151  inline void writeNull() const noexcept
152  {
153  *data = 0;
154  }
155 
157  size_t length() const noexcept
158  {
159  return (size_t) strlen (data);
160  }
161 
163  size_t lengthUpTo (const size_t maxCharsToCount) const noexcept
164  {
165  return CharacterFunctions::lengthUpTo (*this, maxCharsToCount);
166  }
167 
169  size_t lengthUpTo (const CharPointer_ASCII end) const noexcept
170  {
171  return CharacterFunctions::lengthUpTo (*this, end);
172  }
173 
177  size_t sizeInBytes() const noexcept
178  {
179  return length() + 1;
180  }
181 
185  static inline size_t getBytesRequiredFor (const juce_wchar) noexcept
186  {
187  return 1;
188  }
189 
194  template <class CharPointer>
195  static size_t getBytesRequiredFor (const CharPointer text) noexcept
196  {
197  return text.length();
198  }
199 
202  {
203  return CharPointer_ASCII (data + length());
204  }
205 
207  template <typename CharPointer>
208  void writeAll (const CharPointer src) noexcept
209  {
210  CharacterFunctions::copyAll (*this, src);
211  }
212 
217  template <typename CharPointer>
218  size_t writeWithDestByteLimit (const CharPointer src, const size_t maxDestBytes) noexcept
219  {
220  return CharacterFunctions::copyWithDestByteLimit (*this, src, maxDestBytes);
221  }
222 
227  template <typename CharPointer>
228  void writeWithCharLimit (const CharPointer src, const int maxChars) noexcept
229  {
230  CharacterFunctions::copyWithCharLimit (*this, src, maxChars);
231  }
232 
234  template <typename CharPointer>
235  int compare (const CharPointer other) const noexcept
236  {
237  return CharacterFunctions::compare (*this, other);
238  }
239 
241  int compare (const CharPointer_ASCII other) const noexcept
242  {
243  return strcmp (data, other.data);
244  }
245 
247  template <typename CharPointer>
248  int compareUpTo (const CharPointer other, const int maxChars) const noexcept
249  {
250  return CharacterFunctions::compareUpTo (*this, other, maxChars);
251  }
252 
254  int compareUpTo (const CharPointer_ASCII other, const int maxChars) const noexcept
255  {
256  return strncmp (data, other.data, (size_t) maxChars);
257  }
258 
260  template <typename CharPointer>
261  int compareIgnoreCase (const CharPointer other) const
262  {
263  return CharacterFunctions::compareIgnoreCase (*this, other);
264  }
265 
266  int compareIgnoreCase (const CharPointer_ASCII other) const
267  {
268  #if JUCE_MINGW || (JUCE_WINDOWS && JUCE_CLANG)
269  return CharacterFunctions::compareIgnoreCase (*this, other);
270  #elif JUCE_WINDOWS
271  return stricmp (data, other.data);
272  #else
273  return strcasecmp (data, other.data);
274  #endif
275  }
276 
278  template <typename CharPointer>
279  int compareIgnoreCaseUpTo (const CharPointer other, const int maxChars) const noexcept
280  {
281  return CharacterFunctions::compareIgnoreCaseUpTo (*this, other, maxChars);
282  }
283 
285  template <typename CharPointer>
286  int indexOf (const CharPointer stringToFind) const noexcept
287  {
288  return CharacterFunctions::indexOf (*this, stringToFind);
289  }
290 
292  int indexOf (const juce_wchar charToFind) const noexcept
293  {
294  int i = 0;
295 
296  while (data[i] != 0)
297  {
298  if (data[i] == (char) charToFind)
299  return i;
300 
301  ++i;
302  }
303 
304  return -1;
305  }
306 
308  int indexOf (const juce_wchar charToFind, const bool ignoreCase) const noexcept
309  {
310  return ignoreCase ? CharacterFunctions::indexOfCharIgnoreCase (*this, charToFind)
311  : CharacterFunctions::indexOfChar (*this, charToFind);
312  }
313 
315  bool isWhitespace() const { return CharacterFunctions::isWhitespace (*data) != 0; }
317  bool isDigit() const { return CharacterFunctions::isDigit (*data) != 0; }
319  bool isLetter() const { return CharacterFunctions::isLetter (*data) != 0; }
321  bool isLetterOrDigit() const { return CharacterFunctions::isLetterOrDigit (*data) != 0; }
323  bool isUpperCase() const { return CharacterFunctions::isUpperCase ((juce_wchar) (uint8) *data) != 0; }
325  bool isLowerCase() const { return CharacterFunctions::isLowerCase ((juce_wchar) (uint8) *data) != 0; }
326 
328  juce_wchar toUpperCase() const noexcept { return CharacterFunctions::toUpperCase ((juce_wchar) (uint8) *data); }
330  juce_wchar toLowerCase() const noexcept { return CharacterFunctions::toLowerCase ((juce_wchar) (uint8) *data); }
331 
333  int getIntValue32() const noexcept { return atoi (data); }
334 
336  int64 getIntValue64() const noexcept
337  {
338  #if JUCE_LINUX || JUCE_ANDROID || JUCE_MINGW
339  return atoll (data);
340  #elif JUCE_WINDOWS
341  return _atoi64 (data);
342  #else
343  return CharacterFunctions::getIntValue <int64, CharPointer_ASCII> (*this);
344  #endif
345  }
346 
348  double getDoubleValue() const noexcept { return CharacterFunctions::getDoubleValue (*this); }
349 
352 
354  static bool canRepresent (juce_wchar character) noexcept
355  {
356  return ((unsigned int) character) < (unsigned int) 128;
357  }
358 
360  static bool isValidString (const CharType* dataToTest, int maxBytesToRead)
361  {
362  while (--maxBytesToRead >= 0)
363  {
364  if (((signed char) *dataToTest) <= 0)
365  return *dataToTest == 0;
366 
367  ++dataToTest;
368  }
369 
370  return true;
371  }
372 
373 private:
374  CharType* data;
375 };
376 
377 } // namespace juce
int getIntValue32() const noexcept
double getDoubleValue() const noexcept
size_t length() const noexcept
static bool isValidString(const CharType *dataToTest, int maxBytesToRead)
size_t sizeInBytes() const noexcept
CharType * getAddress() const noexcept
CharPointer_ASCII operator+(const int numToSkip) const noexcept
size_t lengthUpTo(const CharPointer_ASCII end) const noexcept
bool isNotEmpty() const noexcept
void writeAll(const CharPointer src) noexcept
static size_t getBytesRequiredFor(const juce_wchar) noexcept
int compareIgnoreCaseUpTo(const CharPointer other, const int maxChars) const noexcept
CharPointer_ASCII operator++() noexcept
int compareIgnoreCase(const CharPointer other) const
CharPointer_ASCII operator--() noexcept
static size_t getBytesRequiredFor(const CharPointer text) noexcept
juce_wchar toUpperCase() const noexcept
int compareUpTo(const CharPointer_ASCII other, const int maxChars) const noexcept
int compare(const CharPointer_ASCII other) const noexcept
juce_wchar toLowerCase() const noexcept
int indexOf(const juce_wchar charToFind, const bool ignoreCase) const noexcept
void writeNull() const noexcept
void write(const juce_wchar charToWrite) noexcept
static bool canRepresent(juce_wchar character) noexcept
juce_wchar operator[](const int characterIndex) const noexcept
CharPointer_ASCII operator-(const int numToSkip) const noexcept
int indexOf(const CharPointer stringToFind) const noexcept
CharPointer_ASCII findEndOfWhitespace() const noexcept
juce_wchar operator*() const noexcept
void operator+=(const int numToSkip) noexcept
int compare(const CharPointer other) const noexcept
int indexOf(const juce_wchar charToFind) const noexcept
bool isEmpty() const noexcept
juce_wchar getAndAdvance() noexcept
void writeWithCharLimit(const CharPointer src, const int maxChars) noexcept
size_t writeWithDestByteLimit(const CharPointer src, const size_t maxDestBytes) noexcept
bool operator==(CharPointer_ASCII other) const noexcept
int compareUpTo(const CharPointer other, const int maxChars) const noexcept
int64 getIntValue64() const noexcept
CharPointer_ASCII findTerminatingNull() const noexcept
size_t lengthUpTo(const size_t maxCharsToCount) const noexcept
static int compare(juce_wchar char1, juce_wchar char2) noexcept
static juce_wchar toLowerCase(juce_wchar character) noexcept
static size_t copyWithDestByteLimit(DestCharPointerType &dest, SrcCharPointerType src, size_t maxBytesToWrite) noexcept
static int indexOfCharIgnoreCase(Type text, juce_wchar charToFind) noexcept
static bool isDigit(char character) noexcept
static int compareIgnoreCaseUpTo(CharPointerType1 s1, CharPointerType2 s2, int maxChars) noexcept
static int indexOfChar(Type text, const juce_wchar charToFind) noexcept
static int compareIgnoreCase(juce_wchar char1, juce_wchar char2) noexcept
static bool isLowerCase(juce_wchar character) noexcept
static bool isLetter(char character) noexcept
static int indexOf(CharPointerType1 textToSearch, const CharPointerType2 substringToLookFor) noexcept
static size_t lengthUpTo(CharPointerType text, const size_t maxCharsToCount) noexcept
static Type findEndOfWhitespace(Type text) noexcept
static void copyWithCharLimit(DestCharPointerType &dest, SrcCharPointerType src, int maxChars) noexcept
static bool isWhitespace(char character) noexcept
static bool isLetterOrDigit(char character) noexcept
static juce_wchar toUpperCase(juce_wchar character) noexcept
static bool isUpperCase(juce_wchar character) noexcept
static double getDoubleValue(CharPointerType text) noexcept
static void copyAll(DestCharPointerType &dest, SrcCharPointerType src) noexcept
static int compareUpTo(CharPointerType1 s1, CharPointerType2 s2, int maxChars) noexcept