Leviathan  0.8.0.0
Leviathan game engine
Public Member Functions | Static Public Member Functions | List of all members
Leviathan::StringOperations Class Reference

Singleton class that has string processing functions. More...

#include <StringOperations.h>

Public Member Functions

template<>
DLLEXPORT void MakeString (std::wstring &str, const char *characters, size_t count)
 

Static Public Member Functions

template<typename CharType >
static bool IsCharacterWhitespace (CharType character)
 
template<typename CharType >
static bool IsCharacterQuote (CharType character)
 
template<class StringTypeN >
static void MakeString (StringTypeN &str, const char *characters, size_t count)
 
template<class StringTypeN >
static StringTypeN RepeatCharacter (int character, size_t count)
 
template<class StringTypeN >
static const StringTypeN RemoveExtension (const StringTypeN &filepath, bool delpath=true)
 
template<class StringTypeN >
static const StringTypeN GetExtension (const StringTypeN &filepath)
 
template<class StringTypeN >
static const StringTypeN ChangeExtension (const StringTypeN &filepath, const StringTypeN &newext)
 
template<class StringTypeN >
static const StringTypeN RemovePath (const StringTypeN &filepath)
 
template<class StringTypeN >
static const StringTypeN GetPath (const StringTypeN &filepath)
 Returns the path part of a path+filename. More...
 
static DLLEXPORT std::string URLProtocol (const std::string &url)
 
static DLLEXPORT std::string BaseHostName (const std::string &url)
 
static DLLEXPORT std::string URLPath (const std::string &url, bool stripoptions=true)
 
static DLLEXPORT std::string CombineURL (const std::string &first, const std::string &second)
 
static DLLEXPORT std::string RemovePartsBeforeAbsoluteURLParts (const std::string &url)
 
static DLLEXPORT bool IsURLDomain (const std::string &str)
 Returns true if string looks like a top level domain. More...
 
template<class StringTypeN >
static const StringTypeN ChangeLineEndsToWindows (const StringTypeN &input)
 Changes all line separators to Windows line separators. More...
 
template<class StringTypeN >
static const StringTypeN ChangeLineEndsToUniversal (const StringTypeN &input)
 Changes all line separators to universal line separators. More...
 
template<class StringTypeN >
static size_t CutLines (const StringTypeN &input, std::vector< StringTypeN > &output)
 Splits a string on line separators. More...
 
template<class StringTypeN >
static bool CutString (const StringTypeN &strtocut, const StringTypeN &separator, std::vector< StringTypeN > &vec)
 
template<class StringTypeN >
static int CountOccuranceInString (const StringTypeN &data, const StringTypeN &lookfor)
 
template<class StringTypeN >
static StringTypeN Replace (const StringTypeN &data, const StringTypeN &toreplace, const StringTypeN &replacer)
 
template<class StringTypeN >
static StringTypeN ReplaceSingleCharacter (const StringTypeN &data, const StringTypeN &toreplace, int replacer=' ')
 
template<class StringTypeN >
static StringTypeN RemoveCharacters (const StringTypeN &data, const StringTypeN &toremove)
 
template<class StringTypeN >
static StringTypeN RemoveFirstWords (const StringTypeN &data, int amount)
 
template<class StringTypeN >
static StringTypeN RemovePrefix (const StringTypeN &data, const StringTypeN &prefix)
 
template<class StringTypeN >
static StringTypeN StitchTogether (const std::vector< StringTypeN *> &data, const StringTypeN &separator)
 
template<class StringTypeN >
static StringTypeN StitchTogether (const std::vector< StringTypeN > &data, const StringTypeN &separator)
 
template<class StringTypeN >
static StringTypeN StitchTogether (const std::vector< std::shared_ptr< StringTypeN >> &data, const StringTypeN &separator)
 
template<class StringTypeN >
static void RemovePreceedingTrailingSpaces (StringTypeN &str)
 
template<class StringTypeN >
static bool CompareInsensitive (const StringTypeN &data, const StringTypeN &second)
 
template<class StringTypeN >
static bool StringStartsWith (const StringTypeN &data, const StringTypeN &tomatch)
 
template<class StringTypeN >
static bool StringEndsWith (const StringTypeN &data, const StringTypeN &tomatch)
 
template<class StringTypeN >
static bool IsStringNumeric (const StringTypeN &data)
 
template<class StringTypeN >
static StringTypeN ToUpperCase (const StringTypeN &data)
 
template<class StringTypeN >
static StringTypeN Indent (size_t numspaces)
 
template<class StringTypeN >
static StringTypeN IndentLines (const StringTypeN &str, size_t spaces)
 Appends spaces number of spaces to each line in str and returns the result. More...
 
template<class StringTypeN >
static StringTypeN RemoveEnding (const StringTypeN &str, const StringTypeN &ending)
 
static bool IsLineTerminator (int32_t codepoint)
 
static bool IsLineTerminator (int32_t codepoint1, int32_t codepoint2)
 

Detailed Description

Singleton class that has string processing functions.

Most functions work with any type of string, but it is recommended to only pass string or wstring to avoid headaches.

Todo:

Get rid of ElementType and just use ints for everything and hope that it is large enough

Drop wstring support

Definition at line 33 of file StringOperations.h.

Member Function Documentation

◆ BaseHostName()

DLLEXPORT std::string StringOperations::BaseHostName ( const std::string &  url)
static

Definition at line 28 of file StringOperations.cpp.

29 {
30  if(url.empty())
31  return "";
32 
33  // Start scanning until a '/' is found that is not preceeded by ':' or '/'
34  size_t length = 0;
35 
36  for(size_t i = 0; i < url.size(); ++i) {
37 
38  length = i + 1;
39 
40  if(url[i] == '/') {
41 
42  if(i < 1)
43  continue;
44 
45  if(url[i - 1] == ':' || url[i - 1] == '/')
46  continue;
47 
48  // found it //
49  break;
50  }
51  }
52 
53  // Make sure it has an ending '/'
54  if(length == url.size() && url.back() != '/')
55  return url + "/";
56 
57  return url.substr(0, length);
58 }

◆ ChangeExtension()

template<class StringTypeN >
static const StringTypeN Leviathan::StringOperations::ChangeExtension ( const StringTypeN &  filepath,
const StringTypeN &  newext 
)
inlinestatic

Definition at line 146 of file StringOperations.h.

148  {
149  size_t startcopy = 0;
150  size_t endcopy = filepath.size() - 1;
151 
152  size_t lastdot = filepath.find_last_of(DOT_CHARACTER);
153 
154  if(lastdot != StringTypeN::npos) {
155  // dot found //
156  endcopy = lastdot;
157 
158  } else {
159  // No dot, so just append it //
160  return filepath + newext;
161  }
162 
163  // Return empty if no data is valid //
164  if(startcopy > endcopy || startcopy >= filepath.size() || endcopy >= filepath.size())
165  return StringTypeN();
166 
167  // Return the extension //
168  return filepath.substr(startcopy, endcopy - startcopy + 1) + newext;
169  }
Leviathan::DOT_CHARACTER
constexpr int32_t DOT_CHARACTER
Definition: StringOperations.h:13

◆ ChangeLineEndsToUniversal()

template<class StringTypeN >
static const StringTypeN Leviathan::StringOperations::ChangeLineEndsToUniversal ( const StringTypeN &  input)
inlinestatic

Changes all line separators to universal line separators.

Definition at line 317 of file StringOperations.h.

318  {
319  StringTypeN results;
320 
321  // This is the line ending sequence //
322  StringTypeN separator;
323  MakeString(separator, UNIVERSAL_LINE_SEPARATOR, sizeof(UNIVERSAL_LINE_SEPARATOR));
324 
325  // Try to find path strings and replace them //
326  size_t copystart = 0;
327  size_t copyend = 0;
328 
329  for(size_t i = 0; i < input.size(); i++) {
330  if(input[i] == WINDOWS_LINE_SEPARATOR[0] && i + 1 < input.size() &&
331  input[i + 1] == WINDOWS_LINE_SEPARATOR[1]) {
332  // Found a line separator //
333  // Copy the current thing //
334  if(copyend >= copystart && copystart - copyend > 1)
335  results += input.substr(copystart, copyend - copystart + 1);
336 
337 
338  results += separator;
339 
340  copystart = i + 2 < input.size() ? i + 2 : i;
341  copyend = copystart;
342 
343  i += 2;
344 
345  continue;
346  }
347 
348  // Change the end copy //
349  copyend = i;
350  }
351 
352  if(copyend >= copystart && copystart - copyend > 1)
353  results += input.substr(copystart, copyend - copystart + 1);
354 
355 
356  return results;
357  }
Leviathan::UNIVERSAL_LINE_SEPARATOR
constexpr char UNIVERSAL_LINE_SEPARATOR[]
Definition: StringOperations.h:24
Leviathan::WINDOWS_LINE_SEPARATOR
constexpr char WINDOWS_LINE_SEPARATOR[]
Definition: StringOperations.h:23
Leviathan::StringOperations::MakeString
static void MakeString(StringTypeN &str, const char *characters, size_t count)
Definition: StringOperations.h:60

◆ ChangeLineEndsToWindows()

template<class StringTypeN >
static const StringTypeN Leviathan::StringOperations::ChangeLineEndsToWindows ( const StringTypeN &  input)
inlinestatic

Changes all line separators to Windows line separators.

Definition at line 274 of file StringOperations.h.

275  {
276  StringTypeN results;
277 
278  // This is the line ending sequence //
279  StringTypeN separator;
280  MakeString(separator, WINDOWS_LINE_SEPARATOR, sizeof(WINDOWS_LINE_SEPARATOR));
281 
282  // Try to find path strings and replace them //
283  StartEndIndex copyparts;
284 
285  for(size_t i = 0; i < input.size(); i++) {
286  if(input[i] == UNIVERSAL_LINE_SEPARATOR[0]
287  // Previous character wasn't the first character of a windows line separator.
288  // If it was this is already the correct line separator and should be ignored
289  && (i == 0 || input[i - 1] != WINDOWS_LINE_SEPARATOR[0])) {
290  // Found a line separator //
291  // Copy the current thing //
292  if(copyparts.Start && copyparts.End)
293  results += input.substr(copyparts.Start, copyparts.Length());
294 
295  copyparts.Reset();
296 
297  results += separator;
298 
299  continue;
300  }
301 
302  if(!copyparts.Start)
303  copyparts.Start = i;
304 
305  // Change the end copy //
306  copyparts.End = i;
307  }
308 
309  if(copyparts.End && copyparts.Start)
310  results += input.substr(copyparts.Start, copyparts.Length());
311 
312  return results;
313  }
Leviathan::UNIVERSAL_LINE_SEPARATOR
constexpr char UNIVERSAL_LINE_SEPARATOR[]
Definition: StringOperations.h:24
Leviathan::WINDOWS_LINE_SEPARATOR
constexpr char WINDOWS_LINE_SEPARATOR[]
Definition: StringOperations.h:23
Leviathan::StringOperations::MakeString
static void MakeString(StringTypeN &str, const char *characters, size_t count)
Definition: StringOperations.h:60

◆ CombineURL()

DLLEXPORT std::string StringOperations::CombineURL ( const std::string &  first,
const std::string &  second 
)
static

Definition at line 105 of file StringOperations.cpp.

107 {
108  // To fix messed up urls we always do this cleanup
109  const auto cleanedUpSecond = RemovePartsBeforeAbsoluteURLParts(second);
110 
111  if(first.empty())
112  return cleanedUpSecond;
113 
114  if(cleanedUpSecond.empty())
115  return first;
116 
117  // If second is an absolute URL just return it //
118  if(cleanedUpSecond.find("://") != std::string::npos)
119  return cleanedUpSecond;
120 
121  // If the other starts with double '//' then we just need to grab the protocol from the
122  // first and add the second
123  if(cleanedUpSecond.find("//") == 0)
124  return URLProtocol(first) + ":" + second;
125 
126  // Simplest case: first ends with '/' and second doesn't begin with '/'
127  if(first.back() == '/' && cleanedUpSecond.front() != '/')
128  return first + cleanedUpSecond;
129 
130  // Second begins with '/': trim the first to the base url and then append the second
131  if(cleanedUpSecond.front() == '/')
132  return BaseHostName(first) + cleanedUpSecond.substr(1);
133 
134  // An error catching function
135  // If first is the basehostname then just combine them
136  if(first.back() != '/' && BaseHostName(first).length() == first.length() + 1)
137  return first + "/" + cleanedUpSecond;
138 
139  // Most complex case: trim from the end of first until the last '/' and then append second
140  const auto lastpos = first.find_last_of('/');
141  return first.substr(0, lastpos + 1) + cleanedUpSecond;
142 }
Leviathan::StringOperations::BaseHostName
static DLLEXPORT std::string BaseHostName(const std::string &url)
Definition: StringOperations.cpp:28
Leviathan::StringOperations::URLProtocol
static DLLEXPORT std::string URLProtocol(const std::string &url)
Definition: StringOperations.cpp:18
Leviathan::StringOperations::RemovePartsBeforeAbsoluteURLParts
static DLLEXPORT std::string RemovePartsBeforeAbsoluteURLParts(const std::string &url)
Definition: StringOperations.cpp:144

◆ CompareInsensitive()

template<class StringTypeN >
static bool Leviathan::StringOperations::CompareInsensitive ( const StringTypeN &  data,
const StringTypeN &  second 
)
inlinestatic

Definition at line 869 of file StringOperations.h.

870  {
871  if(data.size() != second.size())
872  return false;
873 
874  for(unsigned int i = 0; i < data.size(); i++) {
875  if(data[i] != second[i]) {
876 
877  // Check are they different case //
878  if(97 <= data[i] && data[i] <= 122) {
879 
880  if(data[i] - 32 != second[i]) {
881 
882  return false;
883  }
884  } else if(97 <= second[i] && second[i] <= 122) {
885 
886  if(second[i] - 32 != data[i]) {
887 
888  return false;
889  }
890  } else {
891 
892  return false;
893  }
894  }
895  }
896 
897  return true;
898  }

◆ CountOccuranceInString()

template<class StringTypeN >
static int Leviathan::StringOperations::CountOccuranceInString ( const StringTypeN &  data,
const StringTypeN &  lookfor 
)
inlinestatic

Definition at line 506 of file StringOperations.h.

507  {
508  int count = 0;
509 
510  for(size_t i = 0; i < data.length(); i++) {
511  if(data[i] == lookfor[0]) {
512  // Found a possible match //
513  // test further //
514  size_t modifier = 0;
515  bool WasMatch = false;
516  while(data[i + modifier] == lookfor[modifier]) {
517  // check can it increase without going out of bounds //
518  if((data.length() > i + modifier + 1) &&
519  (lookfor.length() > modifier + 1)) {
520  // increase modifier to move forward //
521  modifier++;
522  } else {
523  // check is it a match
524  if(modifier + 1 == lookfor.length()) {
525  // found match! //
526  count++;
527  WasMatch = true;
528  break;
529  }
530  break;
531  }
532  }
533  // skip the separator amount of characters, if it was found //
534  if(WasMatch)
535  // -1 here so that first character of next string won't be missing,
536  // because of the loop incrementation
537  i += lookfor.length() - 1;
538  }
539  }
540 
541  return count;
542  }

◆ CutLines()

template<class StringTypeN >
static size_t Leviathan::StringOperations::CutLines ( const StringTypeN &  input,
std::vector< StringTypeN > &  output 
)
inlinestatic

Splits a string on line separators.

Definition at line 361 of file StringOperations.h.

362  {
363  if(input.empty())
364  return 0;
365 
366  size_t copystart = 0;
367  size_t copyend = 0;
368 
369  for(size_t i = 0; i < input.size(); i++) {
370  // Check is at a line separator
371  bool windows = input[i] == WINDOWS_LINE_SEPARATOR[0] && i + 1 < input.size() &&
372  input[i + 1] == WINDOWS_LINE_SEPARATOR[1];
373 
374  if(windows || (input[i] == UNIVERSAL_LINE_SEPARATOR[0])) {
375  // Check that previous character wasn't the beginning of
376  // a windows line separator. If it was this is already added
377  // and should be ignored
378  if(i > 0 && input[i - 1] == WINDOWS_LINE_SEPARATOR[0]) {
379 
380  // Skip adding this
381  continue;
382  }
383 
384  // Found a line separator //
385  // Copy the current thing //
386  if(copyend >= copystart && copystart - copyend > 1) {
387 
388  output.push_back(input.substr(copystart, copyend - copystart + 1));
389 
390  } else {
391  // There was an empty line //
392  output.push_back(StringTypeN());
393  }
394 
395  copystart = windows ? i + 2 : i + 1;
396  copyend = 0;
397 
398  continue;
399  }
400 
401  copyend = i;
402  }
403 
404  if(copyend >= copystart)
405  output.push_back(input.substr(copystart, copyend - copystart + 1));
406 
407  return output.size();
408  }
Leviathan::UNIVERSAL_LINE_SEPARATOR
constexpr char UNIVERSAL_LINE_SEPARATOR[]
Definition: StringOperations.h:24
Leviathan::WINDOWS_LINE_SEPARATOR
constexpr char WINDOWS_LINE_SEPARATOR[]
Definition: StringOperations.h:23

◆ CutString()

template<class StringTypeN >
static bool Leviathan::StringOperations::CutString ( const StringTypeN &  strtocut,
const StringTypeN &  separator,
std::vector< StringTypeN > &  vec 
)
inlinestatic

Definition at line 413 of file StringOperations.h.

415  {
416  // scan the input and gather positions for string copying //
417  std::vector<StartEndIndex> CopyOperations;
418  bool PositionStarted = false;
419 
420  for(size_t i = 0; i < strtocut.length(); i++) {
421  if(!PositionStarted) {
422  PositionStarted = true;
423  // add new position index //
424  CopyOperations.push_back(StartEndIndex(i));
425  }
426 
427  if(strtocut[i] == separator[0]) {
428  // Found a possible match //
429  // test further //
430  size_t modifier = 0;
431  bool WasMatch = false;
432  while(strtocut[i + modifier] == separator[modifier]) {
433  // check can it increase without going out of bounds //
434  if((strtocut.length() > i + modifier + 1) &&
435  (separator.length() > modifier + 1)) {
436  // increase modifier to move forward //
437  modifier++;
438  } else {
439  // check is it a match
440  if(modifier + 1 == separator.length()) {
441  // found match! //
442 
443  // end old string to just before this position //
444  CopyOperations.back().End = i; /*-1;
445  not this because we would have to
446  add 1 in the copy phase anyway */
447 
448  PositionStarted = false;
449  // skip separator //
450  WasMatch = true;
451  break;
452  }
453  break;
454  }
455  }
456 
457  // skip the separator amount of characters, if it was found //
458  if(WasMatch)
459  // -1 here so that first character of next string won't be missing,
460  // because of the loop incrementation
461  i += separator.length() - 1;
462  }
463  }
464 
465  // Return empty string if there is nothing here //
466  if(CopyOperations.empty()) {
467 
468  vec.push_back(StringTypeN());
469  return false;
470  }
471 
472  // make sure final position has end //
473  if(!CopyOperations.back().End)
474  CopyOperations.back().End = strtocut.length();
475 
476  if(CopyOperations.size() < 2) {
477 
478  vec.push_back(strtocut.substr(CopyOperations.front().Start,
479  static_cast<size_t>(CopyOperations.front().End) -
480  static_cast<size_t>(CopyOperations.front().Start)));
481 
482  // would be just one string, for legacy
483  // (actually we don't want caller to think it got cut) reasons we return nothing //
484  return false;
485  }
486 
487  // length-1 is not used here, because it would have to be added in copy phase to the
488  // substring length, and we didn't add that earlier...
489 
490  // make space //
491  vec.reserve(CopyOperations.size());
492 
493  // loop through positions and copy substrings to result vector //
494  for(size_t i = 0; i < CopyOperations.size(); i++) {
495  // copy using std::wstring method for speed //
496  vec.push_back(strtocut.substr(
497  CopyOperations[i].Start, static_cast<size_t>(CopyOperations[i].End) -
498  static_cast<size_t>(CopyOperations[i].Start)));
499  }
500 
501  // cutting succeeded //
502  return true;
503  }

◆ GetExtension()

template<class StringTypeN >
static const StringTypeN Leviathan::StringOperations::GetExtension ( const StringTypeN &  filepath)
inlinestatic

Definition at line 123 of file StringOperations.h.

124  {
125  size_t startcopy = 0;
126  size_t endcopy = filepath.size() - 1;
127 
128  size_t lastdot = filepath.find_last_of(DOT_CHARACTER);
129 
130  if(lastdot == StringTypeN::npos) {
131  // no dot //
132  return StringTypeN();
133  }
134 
135  startcopy = lastdot + 1;
136 
137  // Return empty if no data is valid //
138  if(startcopy > endcopy || startcopy >= filepath.size() || endcopy >= filepath.size())
139  return StringTypeN();
140 
141  // Return the extension //
142  return filepath.substr(startcopy, endcopy - startcopy + 1);
143  }
Leviathan::DOT_CHARACTER
constexpr int32_t DOT_CHARACTER
Definition: StringOperations.h:13

◆ GetPath()

template<class StringTypeN >
static const StringTypeN Leviathan::StringOperations::GetPath ( const StringTypeN &  filepath)
inlinestatic

Returns the path part of a path+filename.

Definition at line 204 of file StringOperations.h.

205  {
206  size_t startcopy = 0;
207  size_t endcopy = filepath.size() - 1;
208 
209  // Find last path character //
210  size_t lastpath;
211  bool found = false;
212 
213  for(size_t i = 0; i < filepath.size(); i++) {
214  if(filepath[i] == UNIVERSAL_PATHSEPARATOR ||
215  filepath[i] == WINDOWS_PATHSEPARATOR) {
216  // Currently last found path //
217  lastpath = i;
218  found = true;
219  }
220  }
221 
222  if(!found) {
223  // Set start //
224  return StringTypeN();
225  }
226 
227  // Set up copy //
228  endcopy = lastpath;
229 
230 
231  // Return empty if no data is valid //
232  if(startcopy > endcopy || startcopy >= filepath.size() || endcopy >= filepath.size())
233  return StringTypeN();
234 
235 
236  // return the wanted part //
237  return filepath.substr(startcopy, endcopy - startcopy + 1);
238  }
Leviathan::UNIVERSAL_PATHSEPARATOR
constexpr int32_t UNIVERSAL_PATHSEPARATOR
Definition: StringOperations.h:14
Leviathan::WINDOWS_PATHSEPARATOR
constexpr int32_t WINDOWS_PATHSEPARATOR
Definition: StringOperations.h:15

◆ Indent()

template<class StringTypeN >
static StringTypeN Leviathan::StringOperations::Indent ( size_t  numspaces)
inlinestatic

Definition at line 967 of file StringOperations.h.

968  {
969  if(!numspaces)
970  return StringTypeN();
971 
972  return StringTypeN(numspaces, static_cast<int>(' '));
973  }

◆ IndentLines()

template<class StringTypeN >
static StringTypeN Leviathan::StringOperations::IndentLines ( const StringTypeN &  str,
size_t  spaces 
)
inlinestatic

Appends spaces number of spaces to each line in str and returns the result.

Definition at line 977 of file StringOperations.h.

978  {
979  const auto indentstr = Indent<StringTypeN>(spaces);
980 
981  StringTypeN result;
982  result.reserve(str.size());
983 
984  StartEndIndex currentcut;
985 
986  for(size_t i = 0; i < str.size(); ++i) {
987 
988  // Check for line change //
989  if(IsLineTerminator(str[i])) {
990 
991  result += indentstr;
992 
993  if(currentcut.Start)
994  result += str.substr(
995  currentcut.Start, i - static_cast<size_t>(currentcut.Start));
996 
997  result += "\n";
998  currentcut = StartEndIndex();
999 
1000  // Multi character line terminator //
1001  if(i + 1 < str.length() && IsLineTerminator(str[i], str[i + 1]))
1002  ++i;
1003  }
1004 
1005  if(!currentcut.Start && !IsCharacterWhitespace(str[i])) {
1006 
1007  // Started a line //
1008  currentcut.Start = i;
1009  }
1010  }
1011 
1012  if(currentcut.Start) {
1013 
1014  currentcut.End = str.size();
1015 
1016  result += indentstr + str.substr(currentcut.Start, currentcut.Length());
1017  }
1018 
1019  return result;
1020  }
Leviathan::StringOperations::IsLineTerminator
static bool IsLineTerminator(int32_t codepoint)
Definition: StringOperations.h:1034
Leviathan::StringOperations::IsCharacterWhitespace
static bool IsCharacterWhitespace(CharType character)
Definition: StringOperations.h:36

◆ IsCharacterQuote()

template<typename CharType >
static bool Leviathan::StringOperations::IsCharacterQuote ( CharType  character)
inlinestatic

Definition at line 48 of file StringOperations.h.

49  {
50 
51  if(character == '"' || character == '\'')
52  return true;
53 
54  return false;
55  }

◆ IsCharacterWhitespace()

template<typename CharType >
static bool Leviathan::StringOperations::IsCharacterWhitespace ( CharType  character)
inlinestatic

Definition at line 36 of file StringOperations.h.

37  {
38  if((int)character <= 32)
39  return true;
40 
41  if(IsLineTerminator(character))
42  return true;
43 
44  return false;
45  }
Leviathan::StringOperations::IsLineTerminator
static bool IsLineTerminator(int32_t codepoint)
Definition: StringOperations.h:1034

◆ IsLineTerminator() [1/2]

static bool Leviathan::StringOperations::IsLineTerminator ( int32_t  codepoint)
inlinestatic
Returns
True if a character is a line terminating character

Definition at line 1034 of file StringOperations.h.

1035  {
1036  if(codepoint == '\r' || codepoint == '\n' ||
1037  // Unicode newlines //
1038  codepoint == 0x0085 || codepoint == 0x2028 || codepoint == 0x2029 ||
1039  codepoint == 0x000B || codepoint == 0x000C) {
1040  return true;
1041  }
1042 
1043  return false;
1044  }

◆ IsLineTerminator() [2/2]

static bool Leviathan::StringOperations::IsLineTerminator ( int32_t  codepoint1,
int32_t  codepoint2 
)
inlinestatic
Returns
True if two characters are a line terminating sequence

Definition at line 1047 of file StringOperations.h.

1048  {
1049  if(codepoint1 == '\r' && codepoint2 == '\n') {
1050  return true;
1051  }
1052 
1053  return false;
1054  }

◆ IsStringNumeric()

template<class StringTypeN >
static bool Leviathan::StringOperations::IsStringNumeric ( const StringTypeN &  data)
inlinestatic

Definition at line 929 of file StringOperations.h.

930  {
931  for(size_t i = 0; i < data.size(); i++) {
932  if((data[i] < FIRST_NUMBER || data[i] > LAST_NUMBER) &&
933  data[i] != DASH_CHARACTER && data[i] != DOT_CHARACTER &&
934  data[i] != PLUS_SYMBOL) {
935  return false;
936  }
937  }
938  return true;
939  }
Leviathan::LAST_NUMBER
constexpr int32_t LAST_NUMBER
Definition: StringOperations.h:19
Leviathan::DOT_CHARACTER
constexpr int32_t DOT_CHARACTER
Definition: StringOperations.h:13
Leviathan::DASH_CHARACTER
constexpr int32_t DASH_CHARACTER
Definition: StringOperations.h:20
Leviathan::PLUS_SYMBOL
constexpr int32_t PLUS_SYMBOL
Definition: StringOperations.h:21
Leviathan::FIRST_NUMBER
constexpr int32_t FIRST_NUMBER
Definition: StringOperations.h:18

◆ IsURLDomain()

DLLEXPORT bool StringOperations::IsURLDomain ( const std::string &  str)
static

Returns true if string looks like a top level domain.

Definition at line 176 of file StringOperations.cpp.

177 {
178  // Must have a dot
179  bool dotSeen = false;
180 
181  for(char c : str) {
182  if(c == '.') {
183  dotSeen = true;
184  continue;
185  }
186 
187  if(c >= '0' && c <= '9')
188  continue;
189 
190  if(c >= 'A' && c <= 'Z')
191  continue;
192 
193  if(c >= 'a' && c <= 'z')
194  continue;
195 
196  return false;
197  }
198 
199  return dotSeen;
200 }

◆ MakeString() [1/2]

DLLEXPORT void Leviathan::StringOperations::MakeString ( std::wstring &  str,
const char *  characters,
size_t  count 
)

Definition at line 7 of file StringOperations.cpp.

9 {
10  // Skip copying null terminator
11  const size_t copysize = count - 1;
12  str.resize(copysize);
13 
14  for(size_t i = 0; i < copysize; ++i)
15  str[i] = (wchar_t)characters[i];
16 }

◆ MakeString() [2/2]

template<class StringTypeN >
static void Leviathan::StringOperations::MakeString ( StringTypeN &  str,
const char *  characters,
size_t  count 
)
inlinestatic

Definition at line 60 of file StringOperations.h.

61  {
62  // Skip the null terminator //
63  str = StringTypeN(characters, count - 1);
64  }

◆ RemoveCharacters()

template<class StringTypeN >
static StringTypeN Leviathan::StringOperations::RemoveCharacters ( const StringTypeN &  data,
const StringTypeN &  toremove 
)
inlinestatic

Definition at line 648 of file StringOperations.h.

649  {
650  StringTypeN out;
651  out.reserve(data.size());
652 
653  for(auto iter = data.begin(); iter != data.end(); ++iter) {
654 
655  // Check does it contain //
656  bool ignore = false;
657 
658  for(auto iter2 = toremove.begin(); iter2 != toremove.end(); ++iter2) {
659 
660  if((*iter2) == (*iter)) {
661 
662  ignore = true;
663  break;
664  }
665  }
666 
667  if(ignore)
668  continue;
669 
670  out.push_back(*iter);
671  }
672 
673  return out;
674  }

◆ RemoveEnding()

template<class StringTypeN >
static StringTypeN Leviathan::StringOperations::RemoveEnding ( const StringTypeN &  str,
const StringTypeN &  ending 
)
inlinestatic

Definition at line 1023 of file StringOperations.h.

1024  {
1025  const auto pos = str.rfind(ending);
1026 
1027  if(pos != StringTypeN::npos && str.length() - pos == ending.length())
1028  return str.substr(0, pos);
1029 
1030  return str;
1031  }

◆ RemoveExtension()

template<class StringTypeN >
static const StringTypeN Leviathan::StringOperations::RemoveExtension ( const StringTypeN &  filepath,
bool  delpath = true 
)
inlinestatic

Definition at line 81 of file StringOperations.h.

82  {
83  size_t startcopy = 0;
84  size_t endcopy;
85 
86  size_t lastdot = filepath.find_last_of(DOT_CHARACTER);
87 
88  if(lastdot == StringTypeN::npos) {
89  // no dot //
90  endcopy = filepath.size() - 1;
91  } else {
92  endcopy = lastdot - 1;
93  }
94 
95  // Potentially erase from beginning //
96  if(delpath) {
97  // Find last path character //
98  size_t lastpath = 0;
99 
100  for(size_t i = 0; i < filepath.size(); i++) {
101  if(filepath[i] == UNIVERSAL_PATHSEPARATOR ||
102  filepath[i] == WINDOWS_PATHSEPARATOR) {
103  // Currently last found path //
104  lastpath = i;
105  }
106  }
107 
108  if(lastpath != 0) {
109  // Set start //
110  startcopy = lastpath + 1;
111  }
112  }
113 
114  // Return empty if no data is valid //
115  if(startcopy > endcopy || startcopy >= filepath.size() || endcopy >= filepath.size())
116  return StringTypeN();
117 
118  // return the wanted part //
119  return filepath.substr(startcopy, endcopy - startcopy + 1);
120  }
Leviathan::UNIVERSAL_PATHSEPARATOR
constexpr int32_t UNIVERSAL_PATHSEPARATOR
Definition: StringOperations.h:14
Leviathan::WINDOWS_PATHSEPARATOR
constexpr int32_t WINDOWS_PATHSEPARATOR
Definition: StringOperations.h:15
Leviathan::DOT_CHARACTER
constexpr int32_t DOT_CHARACTER
Definition: StringOperations.h:13

◆ RemoveFirstWords()

template<class StringTypeN >
static StringTypeN Leviathan::StringOperations::RemoveFirstWords ( const StringTypeN &  data,
int  amount 
)
inlinestatic

Definition at line 677 of file StringOperations.h.

678  {
679  size_t firstpos = 0;
680  // Find the copy start position //
681  int spaces = 0;
682  int words = 0;
683 
684  for(size_t i = 0; i < data.length(); i++) {
685  if(data[i] == SPACE_CHARACTER) {
686  spaces++;
687  continue;
688  }
689  if(spaces > 0) {
690  words++;
691  if(words == amount) {
692  // This is the spot we want to start from //
693  firstpos = i;
694  break;
695  }
696  spaces = 0;
697  }
698  }
699 
700  if(firstpos == 0) {
701  // Didn't remove anything? //
702  return data;
703  }
704 
705  // Generate sub string from start to end //
706  return data.substr(firstpos, data.size() - firstpos);
707  }
Leviathan::SPACE_CHARACTER
constexpr int32_t SPACE_CHARACTER
Definition: StringOperations.h:16

◆ RemovePartsBeforeAbsoluteURLParts()

DLLEXPORT std::string StringOperations::RemovePartsBeforeAbsoluteURLParts ( const std::string &  url)
static

Definition at line 144 of file StringOperations.cpp.

146 {
147  // Detect two '//'s in a path
148  const auto colonPos = url.find_first_of(':');
149 
150  if(colonPos != std::string::npos) {
151 
152  // First double slash
153  auto firstDouble = url.find("//", colonPos + 3);
154  // Second
155  const auto secondDouble = url.find("//", firstDouble + 2);
156 
157  if(firstDouble != std::string::npos && secondDouble != std::string::npos) {
158 
159  // If the part between the double slashes looks like a
160  // domain then we cut the part between the protocol and
161  // the first double slash
162  firstDouble += 2;
163 
164  if(IsURLDomain(url.substr(firstDouble, secondDouble - firstDouble))) {
165 
166  return URLProtocol(url) + "://" +
167  url.substr(firstDouble, secondDouble - firstDouble) + "/" +
168  url.substr(secondDouble + 2);
169  }
170  }
171  }
172 
173  return url;
174 }
Leviathan::StringOperations::URLProtocol
static DLLEXPORT std::string URLProtocol(const std::string &url)
Definition: StringOperations.cpp:18
Leviathan::StringOperations::IsURLDomain
static DLLEXPORT bool IsURLDomain(const std::string &str)
Returns true if string looks like a top level domain.
Definition: StringOperations.cpp:176

◆ RemovePath()

template<class StringTypeN >
static const StringTypeN Leviathan::StringOperations::RemovePath ( const StringTypeN &  filepath)
inlinestatic

Definition at line 172 of file StringOperations.h.

173  {
174  size_t startcopy = 0;
175  size_t endcopy = filepath.size() - 1;
176 
177  // Find last path character //
178  size_t lastpath = 0;
179 
180  for(size_t i = 0; i < filepath.size(); i++) {
181  if(filepath[i] == UNIVERSAL_PATHSEPARATOR ||
182  filepath[i] == WINDOWS_PATHSEPARATOR) {
183  // Currently last found path //
184  lastpath = i;
185  }
186  }
187 
188  if(lastpath != 0) {
189  // Set start //
190  startcopy = lastpath + 1;
191  }
192 
193  // Return empty if no data is valid //
194  if(startcopy > endcopy || startcopy >= filepath.size() || endcopy >= filepath.size())
195  return StringTypeN();
196 
197 
198  // return the wanted part //
199  return filepath.substr(startcopy, endcopy - startcopy + 1);
200  }
Leviathan::UNIVERSAL_PATHSEPARATOR
constexpr int32_t UNIVERSAL_PATHSEPARATOR
Definition: StringOperations.h:14
Leviathan::WINDOWS_PATHSEPARATOR
constexpr int32_t WINDOWS_PATHSEPARATOR
Definition: StringOperations.h:15

◆ RemovePreceedingTrailingSpaces()

template<class StringTypeN >
static void Leviathan::StringOperations::RemovePreceedingTrailingSpaces ( StringTypeN &  str)
inlinestatic

Definition at line 810 of file StringOperations.h.

811  {
812  StartEndIndex CutPositions;
813 
814  // search the right part of the string //
815  for(size_t i = 0; i < str.size(); i++) {
816  if(!IsCharacterWhitespace(str[i])) {
817  if(!CutPositions.Start) {
818  // beginning ended //
819  CutPositions.Start = i;
820  } else {
821  // set last pos as this //
822  }
823  continue;
824  }
825  if(!CutPositions.Start) {
826  // still haven't found a character //
827  continue;
828  }
829  // check is this last character //
830  size_t a = str.size() - 1;
831  bool found = false;
832  for(; a > i; a--) {
833  if(!IsCharacterWhitespace(str[a])) {
834  // there is still valid characters //
835  found = true;
836  break;
837  }
838  }
839  if(found) {
840  // skip to the found non-space character //
841  i = a - 1;
842  continue;
843  }
844  // end found //
845  CutPositions.End = i - 1;
846  break;
847  }
848 
849  if(!CutPositions.Start) {
850  // nothing in the string //
851  str.clear();
852  return;
853  }
854  if(!CutPositions.End) {
855  if(!CutPositions.Start) {
856  // just the first character required //
857  CutPositions.End = CutPositions.Start;
858  } else {
859  // no need to cut from the end //
860  CutPositions.End = str.length() - 1;
861  }
862  }
863 
864  // set the wstring as it's sub string //
865  str = str.substr(CutPositions.Start, CutPositions.Length());
866  }
Leviathan::StringOperations::IsCharacterWhitespace
static bool IsCharacterWhitespace(CharType character)
Definition: StringOperations.h:36

◆ RemovePrefix()

template<class StringTypeN >
static StringTypeN Leviathan::StringOperations::RemovePrefix ( const StringTypeN &  data,
const StringTypeN &  prefix 
)
inlinestatic

Definition at line 710 of file StringOperations.h.

711  {
712  if(data.find(prefix) == 0) {
713  return data.substr(prefix.size());
714  } else {
715  return data;
716  }
717  }

◆ RepeatCharacter()

template<class StringTypeN >
static StringTypeN Leviathan::StringOperations::RepeatCharacter ( int  character,
size_t  count 
)
inlinestatic

Definition at line 67 of file StringOperations.h.

68  {
69  StringTypeN result;
70 
71  result.resize(count);
72 
73  for(size_t i = 0; i < count; ++i)
74  result[i] = character;
75 
76  return result;
77  }

◆ Replace()

template<class StringTypeN >
static StringTypeN Leviathan::StringOperations::Replace ( const StringTypeN &  data,
const StringTypeN &  toreplace,
const StringTypeN &  replacer 
)
inlinestatic

Definition at line 545 of file StringOperations.h.

547  {
548  // We construct an output string from the wanted bits //
549  StringTypeN out;
550 
551  if(toreplace.size() < 1) {
552  // Don't replace anything //
553  return data;
554  }
555 
556  PotentiallySetIndex copystart;
557  PotentiallySetIndex copyend;
558 
559  // loop through data and copy final characters to out string //
560  for(size_t i = 0; i < data.size(); i++) {
561  // check for replaced part //
562  if(data[i] == toreplace[0]) {
563  // check for match //
564  bool IsMatch = false;
565  for(size_t checkind = 0;
566  (checkind < toreplace.size()) && (checkind < data.size()); checkind++) {
567  if(data[i + checkind] != toreplace[checkind]) {
568  // didn't match //
569  break;
570  }
571  // check is final iteration //
572  if(!((checkind + 1 < toreplace.size()) && (checkind + 1 < data.size()))) {
573  // is a match //
574  IsMatch = true;
575  break;
576  }
577  }
578 
579  if(IsMatch || toreplace.size() == 1) {
580 
581  if(copystart && !copyend)
582  copyend = copystart;
583 
584  // First add proper characters //
585  if(copystart && copyend)
586  out += data.substr(copystart,
587  static_cast<size_t>(copyend) - static_cast<size_t>(copystart) + 1);
588 
589  copystart.ValueSet = false;
590  copyend.ValueSet = false;
591 
592  // it is a match, copy everything in replacer and
593  // add toreplace length to i
594  out += replacer;
595 
596  i += toreplace.length() - 1;
597  continue;
598  }
599  }
600 
601  // non matching character mark as to copy //
602  if(!copystart) {
603  copystart = i;
604  } else {
605  copyend = i;
606  }
607  }
608 
609  // Copy rest to out //
610  if(copystart && copyend)
611  out += data.substr(
612  copystart, static_cast<size_t>(copyend) - static_cast<size_t>(copystart) + 1);
613 
614  // Return finished string //
615  return out;
616  }

◆ ReplaceSingleCharacter()

template<class StringTypeN >
static StringTypeN Leviathan::StringOperations::ReplaceSingleCharacter ( const StringTypeN &  data,
const StringTypeN &  toreplace,
int  replacer = ' ' 
)
inlinestatic

Definition at line 620 of file StringOperations.h.

622  {
623  // Copy the string and then modify it //
624  StringTypeN out(data);
625 
626  for(auto iter = out.begin(); iter != out.end(); ++iter) {
627 
628  // Check does it contain //
629  bool replace = false;
630 
631  for(auto iter2 = toreplace.begin(); iter2 != toreplace.end(); ++iter2) {
632 
633  if((*iter2) == (*iter)) {
634 
635  replace = true;
636  break;
637  }
638  }
639 
640  if(replace)
641  (*iter) = replacer;
642  }
643 
644  return out;
645  }

◆ StitchTogether() [1/3]

template<class StringTypeN >
static StringTypeN Leviathan::StringOperations::StitchTogether ( const std::vector< StringTypeN *> &  data,
const StringTypeN &  separator 
)
inlinestatic

Definition at line 720 of file StringOperations.h.

722  {
723  StringTypeN ret;
724  bool first = true;
725  // reserve space //
726  int totalcharacters = 0;
727 
728  // This might be faster than not reserving space //
729  for(size_t i = 0; i < data.size(); i++) {
730  totalcharacters += data[i]->length();
731  }
732 
733  totalcharacters += separator.length() * data.size();
734 
735  // By reserving space we don't have to allocate more memory
736  // during copying which might be faster
737  ret.reserve(totalcharacters);
738 
739  for(size_t i = 0; i < data.size(); i++) {
740  if(!first)
741  ret += separator;
742  ret += *data[i];
743  first = false;
744  }
745 
746  return ret;
747  }

◆ StitchTogether() [2/3]

template<class StringTypeN >
static StringTypeN Leviathan::StringOperations::StitchTogether ( const std::vector< StringTypeN > &  data,
const StringTypeN &  separator 
)
inlinestatic

Definition at line 750 of file StringOperations.h.

752  {
753  StringTypeN ret;
754  bool first = true;
755  // reserve space //
756  int totalcharacters = 0;
757 
758  // This might be faster than not reserving space //
759  for(size_t i = 0; i < data.size(); i++) {
760  totalcharacters += data[i].length();
761  }
762 
763  totalcharacters += separator.length() * data.size();
764 
765  // By reserving space we don't have to allocate more memory
766  // during copying which might be faster
767  ret.reserve(totalcharacters);
768 
769  for(size_t i = 0; i < data.size(); i++) {
770  if(!first)
771  ret += separator;
772  ret += data[i];
773  first = false;
774  }
775 
776  return ret;
777  }

◆ StitchTogether() [3/3]

template<class StringTypeN >
static StringTypeN Leviathan::StringOperations::StitchTogether ( const std::vector< std::shared_ptr< StringTypeN >> &  data,
const StringTypeN &  separator 
)
inlinestatic

Definition at line 781 of file StringOperations.h.

783  {
784  StringTypeN ret;
785  bool first = true;
786  // reserve space //
787  int totalcharacters = 0;
788 
789  // This might be faster than not reserving space //
790  for(size_t i = 0; i < data.size(); i++) {
791  totalcharacters += data[i]->length();
792  }
793  totalcharacters += separator.length() * data.size();
794 
795  // By reserving space we don't have to allocate more memory during
796  // copying which might be faster
797  ret.reserve(totalcharacters);
798 
799  for(size_t i = 0; i < data.size(); i++) {
800  if(!first)
801  ret += separator;
802  ret += *data[i].get();
803  first = false;
804  }
805 
806  return ret;
807  }

◆ StringEndsWith()

template<class StringTypeN >
static bool Leviathan::StringOperations::StringEndsWith ( const StringTypeN &  data,
const StringTypeN &  tomatch 
)
inlinestatic

Definition at line 907 of file StringOperations.h.

908  {
909  if(data.size() < tomatch.size())
910  return false;
911 
912  if(data.empty())
913  return true;
914 
915  for(size_t i = data.size() - 1, checkIndex = 0; checkIndex < tomatch.size();
916  --i, ++checkIndex) {
917 
918  if(data[i] != tomatch[tomatch.size() - 1 - checkIndex])
919  return false;
920 
921  if(i == 0)
922  return true;
923  }
924 
925  return true;
926  }

◆ StringStartsWith()

template<class StringTypeN >
static bool Leviathan::StringOperations::StringStartsWith ( const StringTypeN &  data,
const StringTypeN &  tomatch 
)
inlinestatic

Definition at line 901 of file StringOperations.h.

902  {
903  return data.find(tomatch) == 0;
904  }

◆ ToUpperCase()

template<class StringTypeN >
static StringTypeN Leviathan::StringOperations::ToUpperCase ( const StringTypeN &  data)
inlinestatic
Todo:
Make this work with any unicode characters

Definition at line 943 of file StringOperations.h.

944  {
945  StringTypeN result;
946  result.reserve(data.size());
947 
948  for(size_t i = 0; i < data.size(); i++) {
949 
950  // Not actually unicode decoding...
951  auto const codepoint = data[i];
952 
953  if(97 <= codepoint && codepoint <= 122) {
954 
955  result.push_back(codepoint - 32);
956 
957  } else {
958 
959  result.push_back(codepoint);
960  }
961  }
962 
963  return result;
964  }

◆ URLPath()

DLLEXPORT std::string StringOperations::URLPath ( const std::string &  url,
bool  stripoptions = true 
)
static

Definition at line 60 of file StringOperations.cpp.

62 {
63  if(url.empty())
64  return "";
65 
66  // Start scanning until a '/' is found that is not preceeded by ':' or '/'
67  size_t startCopy = 0;
68 
69  for(size_t i = 0; i < url.size(); ++i) {
70 
71  if(url[i] == '/') {
72 
73  if(i < 1)
74  continue;
75 
76  if(url[i - 1] == ':' || url[i - 1] == '/')
77  continue;
78 
79  // found it //
80  startCopy = i + 1;
81  break;
82  }
83  }
84 
85  // Make sure the string doesn't end there
86  if(startCopy >= url.size())
87  return "";
88 
89  size_t endCopy = url.size();
90 
91  // Scan backwards for cutting options
92  if(stripoptions) {
93  for(size_t cut = endCopy; cut > startCopy; --cut) {
94  if(url[cut] == '?') {
95  // Found options
96  endCopy = cut;
97  break;
98  }
99  }
100  }
101 
102  return url.substr(startCopy, endCopy - startCopy);
103 }

◆ URLProtocol()

DLLEXPORT std::string StringOperations::URLProtocol ( const std::string &  url)
static

Definition at line 18 of file StringOperations.cpp.

19 {
20  const auto colonpos = url.find_first_of(':');
21 
22  if(colonpos == std::string::npos)
23  return "";
24 
25  return url.substr(0, colonpos);
26 }
The documentation for this class was generated from the following files: