barant/CoreUtils
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

ZString debugged.

Browse Source
This commit is contained in:
Brad Arant 2022-01-29 15:50:32 +00:00
parent a37c4e6829
commit be014d0d24
1 changed files with 134 additions and 89 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

219
ZString.cpp
View File

@ -1,26 +1,32 @@
#include "ZString.h" #include "ZString.h"
#include "Log.h" #include "Log.h"
namespace coreutils { namespace coreutils
{
std::ostream& operator<<(std::ostream& os, const ZString &zstring) { std::ostream &operator<<(std::ostream &os, const ZString &zstring)
for(int ix = 0; ix < (zstring.length - (zstring.cursor - zstring.data)); ++ix) { {
for (int ix = 0; ix < (zstring.length - (zstring.cursor - zstring.data)); ++ix)
{
os << zstring.cursor[ix]; os << zstring.cursor[ix];
} }
return os; return os;
} }
std::ostream& operator<<(std::ostream& os, const std::string &string) { std::ostream &operator<<(std::ostream &os, const std::string &string)
{
os << string; os << string;
return os; return os;
} }
std::ostream& operator+(std::ostream& os, const ZString &zstring) { std::ostream &operator+(std::ostream &os, const ZString &zstring)
{
os << zstring; os << zstring;
return os; return os;
} }
ZString::ZString() { ZString::ZString()
{
data = NULL; data = NULL;
length = 0; length = 0;
cursor = data; cursor = data;
@ -32,179 +38,212 @@ namespace coreutils {
ZString::ZString(const char *data, size_t length) : data((char *)data), length(length), cursor((char *)data) {} ZString::ZString(const char *data, size_t length) : data((char *)data), length(length), cursor((char *)data) {}
ZString::ZString(const ZString &zstring) { ZString::ZString(const ZString &zstring)
{
data = zstring.data; data = zstring.data;
length = zstring.length; length = zstring.length;
cursor = zstring.cursor; cursor = zstring.cursor;
// Log(LOG_DEBUG_2) << "ZString Copy Constructor: "; // Log(LOG_DEBUG_2) << "ZString Copy Constructor: ";
} }
ZString::ZString(std::string data) { ZString::ZString(std::string data)
{
this->data = (char *)data.c_str(); this->data = (char *)data.c_str();
length = data.length(); length = data.length();
cursor = (char *)data.c_str(); cursor = (char *)data.c_str();
} }
bool ZString::operator<(const ZString &valuex) const { bool ZString::operator<(const ZString &valuex) const
return (strncmp(cursor, valuex.cursor, (valuex.length <= length ? valuex.length: length) < 0)); {
return (strncmp(cursor, valuex.cursor, (valuex.length <= length ? valuex.length : length) < 0));
} }
bool ZString::operator>(const ZString &valuex) const { bool ZString::operator>(const ZString &valuex) const
return (strncmp(data, valuex.data, valuex.length <= length ? valuex.length: length) > 0); {
return (strncmp(data, valuex.data, valuex.length <= length ? valuex.length : length) > 0);
} }
bool ZString::operator==(const ZString &valuex) const { bool ZString::operator==(const ZString &valuex) const
return (strncmp(data, valuex.data, valuex.length <= length ? valuex.length: length) == 0); {
return (strncmp(data, valuex.data, valuex.length <= length ? valuex.length : length) == 0);
} }
std::vector<ZString> &ZString::getList() { std::vector<ZString> &ZString::getList()
{
return list; return list;
} }
int ZString::asInteger() { int ZString::asInteger()
{
std::stringstream temp(std::string(data, length)); std::stringstream temp(std::string(data, length));
int tempInt = 0; int tempInt = 0;
temp >> tempInt; temp >> tempInt;
return tempInt; return tempInt;
} }
std::string ZString::str() { std::string ZString::str()
{
return std::string(data, length); return std::string(data, length);
} }
std::string ZString::str(int len) { std::string ZString::str(int len)
{
return std::string(data, len); return std::string(data, len);
} }
std::vector<ZString> &ZString::split(std::string delimiter, size_t maxSize) { std::vector<ZString> &ZString::split(std::string delimiter, size_t maxSize)
{
coreutils::ZString zDelimiter((char *)delimiter.c_str(), delimiter.size()); coreutils::ZString zDelimiter((char *)delimiter.c_str(), delimiter.size());
return split(zDelimiter, maxSize); return split(zDelimiter, maxSize);
} }
std::vector<ZString> &ZString::split(ZString &delimiter, size_t maxSize) { std::vector<ZString> &ZString::split(ZString &delimiter, size_t maxSize)
{
list.clear(); list.clear();
if(length == 0) { if (length == 0) {
list.push_back(ZString("")); list.push_back(ZString(""));
return list; return list;
} }
char *end = data + length; char *end = data + length;
char *pos = cursor; char *pos = cursor;
while((pos + delimiter.getLength()) < end) { while ((pos + delimiter.getLength()) <= end) {
if(strncmp(pos, delimiter.getData(), delimiter.getLength()) == 0) { if (strncmp(pos, delimiter.getData(), delimiter.getLength()) == 0)
list.push_back(ZString(cursor, pos - cursor)); {
cursor = pos + delimiter.getLength(); list.push_back(ZString(cursor, pos - cursor));
pos = cursor; cursor = pos + delimiter.getLength();
} pos = cursor;
else { }
++pos; else
} {
++pos;
}
} }
pos += delimiter.getLength();
list.push_back(ZString(cursor, pos - cursor)); list.push_back(ZString(cursor, pos - cursor));
cursor = pos; cursor = pos;
return list; return list;
} }
bool ZString::isCharacter(char ch, const char *string) { bool ZString::isCharacter(char ch, const char *string)
{
int len = strlen(string); int len = strlen(string);
for(int ix = 0; ix < len; ++ix) { for (int ix = 0; ix < len; ++ix)
if(ch == string[ix]) {
return true; if (ch == string[ix])
return true;
} }
return false; return false;
} }
ZString ZString::getTokenInclude(const char *include) { ZString ZString::getTokenInclude(const char *include)
{
char *start = cursor; char *start = cursor;
while((cursor <= (data + length)) && isCharacter(*cursor, include)) while ((cursor <= (data + length)) && isCharacter(*cursor, include))
++cursor; ++cursor;
return ZString(start, cursor - start); return ZString(start, cursor - start);
} }
ZString ZString::getTokenExclude(const char *exclude) { ZString ZString::getTokenExclude(const char *exclude)
{
char *start = cursor; char *start = cursor;
while((cursor <= (data + length)) && !isCharacter(*cursor, exclude)) while ((cursor <= (data + length)) && !isCharacter(*cursor, exclude))
++cursor; ++cursor;
return ZString(start, cursor - start); return ZString(start, cursor - start);
} }
ZString ZString::getTokenExclude(std::string exclude) { ZString ZString::getTokenExclude(std::string exclude)
{
return getTokenExclude(exclude.c_str()); return getTokenExclude(exclude.c_str());
} }
ZString &ZString::operator[](int index) { ZString &ZString::operator[](int index)
{
return list[index]; return list[index];
} }
bool ZString::eod() { bool ZString::eod()
{
return cursor >= data + length; return cursor >= data + length;
} }
bool ZString::equals(const char *value) { bool ZString::equals(const char *value)
if(strlen(value) != length) {
return false; if (strlen(value) != length)
return false;
return strncmp(data, value, length) == 0; return strncmp(data, value, length) == 0;
} }
bool ZString::equals(char *value) { bool ZString::equals(char *value)
if(strlen(value) != length) {
return false; if (strlen(value) != length)
return false;
return strncmp(data, value, length) == 0; return strncmp(data, value, length) == 0;
} }
bool ZString::equals(ZString &zstring) { bool ZString::equals(ZString &zstring)
if(zstring.getLength() != length) {
return false; if (zstring.getLength() != length)
return false;
return strncmp(data, zstring.getData(), length) == 0; return strncmp(data, zstring.getData(), length) == 0;
} }
bool ZString::equals(std::string &string) { bool ZString::equals(std::string &string)
{
return string == std::string(data, length); return string == std::string(data, length);
} }
bool ZString::ifNext(const char *value) { bool ZString::ifNext(const char *value)
if(((data + length) - cursor) < strlen(value)) {
return false; if (((data + length) - cursor) < strlen(value))
return false;
bool test = (strncmp(cursor, value, strlen(value)) == 0); bool test = (strncmp(cursor, value, strlen(value)) == 0);
if(test) if (test)
cursor += strlen(value); cursor += strlen(value);
return test; return test;
} }
int ZString::ifEqualsCount(ZString &comparator) { int ZString::ifEqualsCount(ZString &comparator)
{
int count = 0; int count = 0;
while(cursor < (data + length)) { while (cursor < (data + length))
if(*cursor == *comparator.cursor) { {
if (*cursor == *comparator.cursor)
{
++count; ++count;
++cursor; ++cursor;
++comparator.cursor; ++comparator.cursor;
} }
else { else
{
return count; return count;
} }
} }
return count; return count;
} }
int ZString::skipWhitespace() { int ZString::skipWhitespace()
{
int len = strspn(cursor, " \t"); int len = strspn(cursor, " \t");
cursor += len; cursor += len;
return len; return len;
} }
ZString ZString::goeol() { ZString ZString::goeol()
{
bool set = false; bool set = false;
char *temp = cursor; char *temp = cursor;
char *tempend = data + length; char *tempend = data + length;
while(cursor <= (data + length)) { while (cursor <= (data + length))
if(*cursor == '\r') { {
if (*cursor == '\r')
{
tempend = cursor++; tempend = cursor++;
set = true; set = true;
} }
if(*cursor == '\n') { if (*cursor == '\n')
if(!set) {
tempend = cursor; if (!set)
tempend = cursor;
++cursor; ++cursor;
break; break;
} }
@ -213,44 +252,50 @@ namespace coreutils {
return ZString(temp, tempend - temp); return ZString(temp, tempend - temp);
} }
ZString ZString::readBlock(size_t size) { ZString ZString::readBlock(size_t size)
{
char *temp = cursor; char *temp = cursor;
cursor += size; cursor += size;
return ZString(temp, size); return ZString(temp, size);
} }
char* ZString::getData() { char *ZString::getData()
{
return data; return data;
} }
size_t ZString::getLength() { size_t ZString::getLength()
{
return length - (cursor - data); return length - (cursor - data);
} }
void ZString::setZString(ZString zstring) { void ZString::setZString(ZString zstring)
{
data = zstring.getData(); data = zstring.getData();
length = zstring.getLength(); length = zstring.getLength();
cursor = data; cursor = data;
} }
void ZString::reset() { void ZString::reset()
{
cursor = data; cursor = data;
} }
char ZString::charAt(int index) { char ZString::charAt(int index)
{
return *(data + index); return *(data + index);
} }
bool ZString::ifCRLF() { bool ZString::ifCRLF()
{
int len = length; int len = length;
if(*(data + length - 1) == '\n') if (*(data + length - 1) == '\n')
--length; --length;
if(*(data + length - 1) == '\r') if (*(data + length - 1) == '\r')
--length; --length;
if(cursor > (data + length)) if (cursor >= (data + length))
cursor = data + length; cursor = data + length;
return len != length; return len != length;
} }
} }