Процессинг строк в RayFoundation. Часть 1 RCString
uint64_t indexOfFirstCharacterCString (const char *string, uint64_t size, char character) { register uint64_t iterator = 0; while (iterator < size) { if(string[iterator] == character) { break; } else { ++iterator; } } return iterator; }
uint64_t indexOfLastCharacterCString (const char *string, uint64_t size, char character) { register uint64_t iterator = 0; register uint64_t last = size; while (iterator < size) { if(string[iterator] == character) { last = iterator; } ++iterator; } return last; }
char randomCharacter (void) { register char character = ((char)rand ()); while (character < 34 || character > 126) { character = ((char)rand ()); } return character; }
RCString *randomRCString (void) { register uint64_t iterator; RCString *string = constructorOfRCString ((NULL)); register uint64_t size = ((uint64_t)rand ()) % 50; char *cstring;
while (size == 0) { size = ((uint64_t)rand ()) % 50; } cstring = malloc (size * sizeof (char)); for (iterator = 0; iterator < size; ++iterator){ cstring[iterator] = randomCharacter(); } setConstantStringRCString(string, cstring); return string; }
RCString* constructorOfRCString (RCString *object) { object = malloc (sizeof (RCString)); if (object) {
object→classId = 1; object→size = 0; } return object; }
void destructorOfRCString (RCString *object) { free (object→baseString);; object→size = 0; }
void printerOfRCString (RCString *object) { printf (»%s\n», object→baseString); }
void flushRCString (RCString *object) { if (object→size!= 0 && object→baseString!= (NULL)) { free (object→baseString);; object→size = 0; } }
RCString * setStringRCString (RCString *object, const char *string) { if (string!= (NULL)) { register uint64_t stringSize = strlen (string) + 1;
if (object→size!= 0 && object→baseString!= (NULL) || object→size < stringSize) { free(object->baseString);; object→baseString = malloc (stringSize * sizeof (char)); }
object→size = stringSize; memcpy (object→baseString, string, object→size, __builtin_object_size (object→baseString, 0)); --object→size; } else { printf («Warning. RCS. Setted strings is empty, please delete function call, or fix it.\n»); } return object; }
RCString * setConstantStringRCString (RCString *object, char const *string) { if (string!= (NULL)) {
object→baseString = string; object→size = strlen (string); } else { printf («Warning. RCS. Setted strings is empty, please delete function call, or fix it.\n»); } return object; }
void replaceCharactersRCString (RCString *object, char characterToReplace, char replacer) { register uint64_t iterator = 0; while (iterator < object->size) { if (object→baseString[iterator] == characterToReplace) { object→baseString[iterator] = replacer; } ++iterator; } }
void replaceSubstringsRCString (RCString *object, RCString *toReplace, RCString *replacer) { if (toReplace!= (NULL) && replacer!= (NULL) && toReplace→size!= 0 && replacer→size!= 0 && toReplace→size <= object->size) {
register uint64_t iterator; for (iterator = 0; iterator < object->size; ++iterator) {
if (object→baseString[iterator] == toReplace→baseString[0]) {
if (memcmp (object→baseString + iterator + 1, toReplace→baseString + 1, toReplace→size — 1) == 0) {
insertSubstringAtRCString (object, replacer, iterator);
deleteInRangeRCString (object, makeRRange (iterator + replacer→size, toReplace→size)); } } } } else { printf («Warning. RCS. Bad strings, or sizes, please delete function call, or fix it.\n»); } }
uint64_t numberOfRepetitionsRCString (RCString *object, char character) { register uint64_t reps = 0; register uint64_t iterator;
for (iterator = 0; iterator < object->size; ++iterator) { if (object→baseString[iterator] == character) { ++reps; } } return reps; }
RCString * deleteAllCharactersRCString (RCString *object, char character) { register uint64_t iterator; for (iterator = 0; iterator < object->size; ++iterator) { if (object→baseString[iterator] == character) { memcpy (object→baseString + iterator, object→baseString + iterator + 1, object→size + 1 — iterator, __builtin_object_size (object→baseString + iterator, 0)); --iterator; --object→size; } } return object; }
void removeRepetitionsOfRCString (RCString *object, char character) { register uint64_t iterator; register uint64_t inner; for (iterator = 0; iterator < object->size — 1; ++iterator) { if (object→baseString[iterator] == character) {
for (inner = 0; inner < object->size — iterator; ++inner) { if (object→baseString[inner + iterator + 1] != character){ break; } }
if (inner > 0) { deleteInRangeRCString (object, makeRRange (iterator + 1, inner)); } } } }
RCString * deleteAllSubstringsRCString (RCString *object, const RCString *substring) { register uint64_t iterator; register uint64_t inner; register byte flag = 1;
if (substring→size!= 0 || substring→baseString == (NULL)) { for (iterator = 0; iterator < object->size — substring→size; ++iterator) {
if (object→baseString[iterator] == substring→baseString[0]) { for (inner = 1; inner < substring->size; ++inner) {
if (object→baseString[iterator + 1] != substring→baseString[inner]) { flag = 0; break; }
} } else { flag = 0; }
if (flag == 1) { memcpy (object→baseString + iterator, object→baseString + iterator + substring→size, object→size + 1 — iterator — substring→size, __builtin_object_size (object→baseString + iterator, 0)); --iterator; object→size -= substring→size; } else { flag = 1; } } return object; } else { printf («Warning. RCS. Substring size is 0, or, substring is NULL.\n»); } return (NULL); }
void removeRepetitionsOfStringRCString (RCString *object, const RCString *substring) {
if (compareWithRCString (object→baseString, substring) != equals && object→size >= substring→size * 2) {
register uint64_t iterator; register uint64_t place; register uint64_t repetitionsCount;
for (iterator = 0; iterator < object->size — substring→size; ++iterator) {
if (object→size — iterator >= substring→size && object→baseString[iterator] == substring→baseString[0]) {
if (memcmp (object→baseString + iterator + 1, substring→baseString + 1, substring→size — 1) == 0) {
iterator += substring→size; place = iterator;
for (repetitionsCount = 0; repetitionsCount < (object->size / substring→size — 1);) { if (memcmp (object→baseString + iterator, substring→baseString, substring→size) == 0) { ++repetitionsCount; iterator += substring→size; } else { break; } }
if (repetitionsCount > 0) {
deleteInRangeRCString (object, makeRRange (place, repetitionsCount * substring→size)); iterator -= repetitionsCount * substring→size; } } } } } }
RCString * deleteCharacterAtRCString (RCString *object, uint64_t index) { if (index > object→size) { printf («Error. RCS. Bad index!»); } else { memmove (object→baseString + index, object→baseString + index + 1, object→size — index, __builtin_object_size (object→baseString + index, 0)); } return object; }
void deleteInRangeRCString (RCString *object, RRange range) { if (range.count!= 0 && ((range.from + range.count) < object->size)) { memmove (object→baseString + range.from, object→baseString + range.from + range.count, object→size — range.count — range.from + 1, __builtin_object_size (object→baseString + range.from, 0));
object→size -= range.count; object→baseString[object→size + 1] = 0; } else { printf («ERRROR. RCS. deleteInRange, bad range, do nothing.\n»); } }
RCString * setSubstringInRangeRCString (RCString *object, RRange range, const char *string) { if (range.count!= 0 && ((range.from + range.count — 1) < object->size)) { memmove (object→baseString + range.from, string, range.count, __builtin_object_size (object→baseString + range.from, 0)); } else { printf («ERROR. RCS. BAD RANGE!\n»); } return object; }
RCString * insertSubstringAtRCString (RCString *object, RCString *substring, uint64_t place) { if (place < object->size) { char *result = malloc (object→size + substring→size + 1); memmove (result, object→baseString, place, __builtin_object_size (result, 0)); memmove (result + place, substring→baseString, substring→size, __builtin_object_size (result + place, 0)); memmove (result + place + substring→size, object→baseString + place, object→size — place, __builtin_object_size (result + place + substring→size, 0)); free (object→baseString);;
object→size += substring→size; object→baseString = result; } else if (place == object→size) { concatenateRCString (object, substring); } else { printf («Warning. RCS. BAD place to insert!\n»); }
return object; }
RCString * substringInRangeRCString (RCString *object, RRange range) { if (range.count!= 0 && range.from < object->size) { char *cstring = malloc (range.count + 1 * sizeof (char)); memmove (cstring, object→baseString + range.from, range.count, __builtin_object_size (cstring, 0)); cstring[range.count + 1] = 0;
RCString *rcString = constructorOfRCString ((NULL)); rcString→size = range.count; rcString→baseString = cstring;
return rcString; } else { printf («ERROR. RCS. BAD RANGE!\n»); return (NULL); }
}
RCString * substringToSymbolRCString (RCString *object, char symbol) { register uint64_t index = indexOfFirstCharacterCString (object→baseString, object→size, symbol); if (index!= object→size) { return substringInRangeRCString (object, makeRRange (0, index)); } else { return (NULL); } }
RArray * substringsSeparatedBySymbolRCString (RCString *object, char symbol) {
RCString tempObject = *object; RArray *result = (NULL); RCString *string = substringToSymbolRCString (object, symbol);
if (string!= (NULL)) { result = constructorOfRArray ((NULL), (NULL)); result→destructorDelegate = destructorOfRCString; result→printerDelegate = printerOfRCString; }
while (string!= (NULL)) { addObjectRArray (result, string); object→baseString += string→size + 1; object→size -= string→size + 1; string = substringToSymbolRCString (object, symbol); if (string == (NULL)) { addObjectRArray (result, copyRCString (object)); } }
*object = tempObject;
if (result!= (NULL)) { sizeToFitRArray (result); } return result; }
RArray * substringsSeparatedBySymbolsRCString (RCString *object, RCString *separatorsString) { register uint64_t iterator = 0;
RArray *result = (NULL);
if (separatorsString!= (NULL) && separatorsString→size!= 0 && object!= (NULL) && object→size!= 0) {
while (iterator < separatorsString->size) { if (separatorsString→baseString[iterator] != ' ') { replaceCharactersRCString (object, separatorsString→baseString[iterator], ' '); }
++iterator; }
}
return result; }
RCString * substringByBoundsRCString (RCString *object, RBounds bounds) { register RRange range; range.from = indexOfFirstCharacterCString (object→baseString, object→size, bounds.startSymbol) + 1; range.count = indexOfLastCharacterCString (object→baseString, object→size, bounds.endSymbol) — range.from; return substringInRangeRCString (object, range); }
RCString * copyRCString (RCString *object) { RCString *copy = substringInRangeRCString (object, makeRRange (0, object→size)); return copy; }
RCompareFlags compareWithRCString (RCString *object, const RCString *checkString) { static uint64_t iterator; if (checkString == (NULL) || object == (NULL)) { printf («Warning. RCS. One of compare strings is empty, please delete function call, or fix it.\n»); return not_equals; } else { if (checkString == object) { return equals; } else { if (checkString→size == object→size) { for (iterator = 0; iterator < object->size; ++iterator) { if (object→baseString[iterator] != checkString→baseString[iterator]){ return not_equals; } } return equals; } else { if (checkString→size == object→size) { return shorter; } else { return longer; } } } } return not_equals; }
void fromFileRCString (RCString *object, const RCString *filename) { FILE *file = fopen (filename→baseString, «rb»); char *buffer; long fileSize;
if (file!= (NULL)) { fseek (file, 0, 2); fileSize = ftell (file); rewind (file); buffer = malloc (fileSize * (sizeof (char))); fread (buffer, sizeof (char), fileSize, file); fclose (file); setConstantStringRCString (object, buffer); } else { printf («Warning. RCS. Cannot open file.\n»); } }
void concatenateRCString (RCString *object, const RCString *string) { if (string→size!= 0 && string→baseString!= (NULL)) { char *concatenationResult = malloc (string→size + object→size + 1); memmove (concatenationResult, object→baseString, object→size, __builtin_object_size (concatenationResult, 0)); memmove (concatenationResult + object→size, string→baseString, string→size, __builtin_object_size (concatenationResult + object→size, 0)); concatenationResult[string→size + object→size + 1] = 0;
free (object→baseString);; object→baseString = concatenationResult; object→size += string→size; } else { printf («Warning. RCS. Bad concatenate string.\n»); } }
RCString* toUpperCaseRCString (RCString *object) { register uint64_t iterator; for (iterator = 0; iterator < object->size; ++iterator) { if (object→baseString[iterator] > 96 && object→baseString[iterator] < 123 ) { object->baseString[iterator] -= 32; } } return object; }
RCString* toLowerCaseRCString (RCString *object) { register uint64_t iterator; for (iterator = 0; iterator < object->size; ++iterator) { if (object→baseString[iterator] > 64 && object→baseString[iterator] < 91 ) { object->baseString[iterator] += 32; } } return object; }
