From 7a2a8ac72d98000f8b6b1030a503fc34c3ac43c7 Mon Sep 17 00:00:00 2001 From: JustinAJ Date: Mon, 2 Jun 2014 14:44:44 -0400 Subject: [PATCH] Added Readable_String class and adapted implementations as neccessary --- Jupiter/Jupiter.vcxproj | 2 + Jupiter/Jupiter.vcxproj.filters | 6 + Jupiter/Readable_String.h | 181 ++++++++ Jupiter/Readable_String_Imp.h | 746 ++++++++++++++++++++++++++++++++ Jupiter/String_Type.h | 119 +---- Jupiter/String_Type_Imp.h | 709 ------------------------------ Release/Jupiter.lib | Bin 194266 -> 203748 bytes 7 files changed, 937 insertions(+), 826 deletions(-) create mode 100644 Jupiter/Readable_String.h create mode 100644 Jupiter/Readable_String_Imp.h diff --git a/Jupiter/Jupiter.vcxproj b/Jupiter/Jupiter.vcxproj index adacc60..b81cc9d 100644 --- a/Jupiter/Jupiter.vcxproj +++ b/Jupiter/Jupiter.vcxproj @@ -132,6 +132,8 @@ + + diff --git a/Jupiter/Jupiter.vcxproj.filters b/Jupiter/Jupiter.vcxproj.filters index 2ca4bfb..fe61b68 100644 --- a/Jupiter/Jupiter.vcxproj.filters +++ b/Jupiter/Jupiter.vcxproj.filters @@ -203,6 +203,12 @@ Header Files\Strings + + Header Files\Strings + + + Header Files\Strings + diff --git a/Jupiter/Readable_String.h b/Jupiter/Readable_String.h new file mode 100644 index 0000000..83c7485 --- /dev/null +++ b/Jupiter/Readable_String.h @@ -0,0 +1,181 @@ +/** + * Copyright (C) 2014 Justin James. + * + * This license must be preserved. + * Any applications, libraries, or code which make any use of any + * component of this program must not be commercial, unless explicit + * permission is granted from the original author. The use of this + * program for non-profit purposes is permitted. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * + * In the event that this license restricts you from making desired use of this program, contact the original author. + * Written by Justin James + */ + +#if !defined _READABLE_STRING_H_HEADER +#define _READABLE_STRING_H_HEADER + +/** + * @file Readable_String.h + * @brief Defines several basic accessive and comparative virtual functions for strings. + */ + +#include // wchar_t +#include // FILE +#include // std::basic_string type + +namespace Jupiter +{ + + /** + * @brief Provides the basis for String classes by providing implementations for operators, comparative operations, and defining abstract functions. + * Note: This is an abstract type. + * + * @param T Element type which the String will store. Defaults to char. + */ + template class Readable_String + { + public: + + /** + * @brief Fetches an element from the string. + * + * @param index Index of the element to return. + * @return The element located at the specified index. + */ + virtual T &get(size_t index) const = 0; + + /** + * @brief Returns the number of elements in the String. + * + * @return Number of elements in the string. + */ + virtual size_t size() const = 0; + + /** + * @brief Returns a pointer to the underlying string of elements. + * + * @return Pointer to the underlying string of elements. + */ + virtual const T *ptr() const = 0; + + /** + * @brief Checks if the string contains an element with the specified value. + * + * @param value Value of the element to search for. + * @return True if a match is found, false otherwise. + */ + bool contains(const T &value) const; + + /** + * @brief Compares another string against the String. + * + * @param in String to compare against. + * @return 0 if the strings are equal, negative if the first mismatched character is greater in the String, or positive if it's less. + */ + int compare(const Readable_String &in) const; + int compare(const std::basic_string &in) const; + int compare(const T *in) const; + int compare(const T &in) const; + int compare(const std::nullptr_t) const; + + /** + * @brief Checks if the strings are equal. + * Note: Case sensitive. + * + * @param in String to compare against. + * @return True if the contents of the strings are equal, false otherwise. + */ + bool equals(const Readable_String &in) const; + bool equals(const std::basic_string &in) const; + bool equals(const T *in) const; + bool equals(const T &in) const; + bool equals(const std::nullptr_t) const; + + /** + * @brief Checks if the strings are equal. + * Note: Case insensitive. Returns false for any type other than char and wchar_t. + * + * @param in String to compare against. + * @return True if the contents of the strings are equal, false otherwise. + */ + bool equalsi(const Readable_String &in) const; + bool equalsi(const std::basic_string &in) const; + bool equalsi(const T *in) const; + bool equalsi(const T &in) const; + bool equalsi(const std::nullptr_t) const; + + /** + * @brief Checks if the String matches a wildcard format. + * Note: Case sensitive. + * + * @param format Format that the string is compared against. + * @return True if the String matches the wildcard format, false otherwise. + */ + bool match(const Readable_String &format) const; + bool match(const std::basic_string &format) const; + bool match(const T *format) const; + + /** + * @brief Checks if the CString matches a wildcard format. + * Note: Case insensitive. Returns false for any type other than char and wchar_t. + * + * @param format Format that the string is compared against. + * @return True if the CString matches the wildcard format, false otherwise. + */ + bool matchi(const Readable_String &format) const; + bool matchi(const std::basic_string &format) const; + bool matchi(const T *format) const; + + /** + * @brief Counts the number of token deliminated words. + * + * @param whitespace A string of tokens used to deliminate words. + * @return Number of words found. + */ + unsigned int wordCount(const T *whitespace) const; + + /** + * @brief Interprets the string as an integer. + * Note: This returns 0 on any value string type other than char. + * + * @param base Base of the string representation. + * @return Integer representation of the string. + */ + int asInt(int base = 0) const; + + /** + * @brief Interprets the string as an integer. + * Note: This returns 0 on any value string type other than char. + * + * @param base Base of the string representation. + * @return Integer representation of the string. + */ + unsigned int asUnsignedInt(int base = 0) const; + + /** + * @brief Outputs the string to a FILE stream. + * + * @param out Stream to output to. + * @return Number of elements written successfully. + */ + size_t print(FILE *out) const; + size_t print(std::basic_ostream &out) const; + + /** + * @brief Outputs the string and a newline to a FILE stream + * + * @param out Stream to output to. + * @param Number of elements written successfully. + */ + size_t println(FILE *out) const; + size_t println(std::basic_ostream &out) const; + }; +} + +#include "Readable_String_Imp.h" + +#endif // _READABLE_STRING_H_HEADER \ No newline at end of file diff --git a/Jupiter/Readable_String_Imp.h b/Jupiter/Readable_String_Imp.h new file mode 100644 index 0000000..e624e1a --- /dev/null +++ b/Jupiter/Readable_String_Imp.h @@ -0,0 +1,746 @@ +/** + * Copyright (C) 2014 Justin James. + * + * This license must be preserved. + * Any applications, libraries, or code which make any use of any + * component of this program must not be commercial, unless explicit + * permission is granted from the original author. The use of this + * program for non-profit purposes is permitted. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * + * In the event that this license restricts you from making desired use of this program, contact the original author. + * Written by Justin James + */ + +#if !defined _READABLE_STRING_IMP_H_HEADER +#define _READABLE_STRING_IMP_H_HEADER + +/** + * @file Readable_String_Imp.h + * @brief Provides the implementations for Readable_String functions. + * Note: Modification of this file is not supported in any way. + */ + +#include "Readable_String.h" +#include "Functions.h" + +/** +* IMPLEMENTATION: +* Readable_String +*/ + +// contains + +template bool Jupiter::Readable_String::contains(const T &value) const +{ + for (size_t i = 0; i != this->size(); i++) if (this->get(i) == value) return true; + return false; +} + +// compare() + +template int Jupiter::Readable_String::compare(const Jupiter::Readable_String &in) const +{ + // rewrite to compare multiple bytes at a time. + size_t index = 0; + while (this->get(index) == in.get(index)) + { + index++; + if (index == in.size()) + { + if (index == this->size()) return 0; + return 1; + } + if (index == this->size()) return 0 - in.get(index); + } + return this->get(index) - in.get(index); +} + +template int Jupiter::Readable_String::compare(const std::basic_string &in) const +{ + // rewrite to compare multiple bytes at a time. + size_t index = 0; + while (this->get(index) == in.at(index)) + { + index++; + if (index == in.size()) + { + if (index == this->size()) return 0; + return 1; + } + if (index == this->size()) return 0 - in.at(index); + } + return this->get(index) - in.at(index); +} + +template int Jupiter::Readable_String::compare(const T *s2) const +{ + if (this->size() == 0) return 0 - *s2; + size_t index = 0; + while (this->get(index) == *s2) + { + index++; + if (*s2 == 0) + { + if (index == this->size()) return 0; + return 1; + } + s2++; + if (index == this->size()) return 0 - *s2; + } + return this->get(index) - *s2; +} + +template int Jupiter::Readable_String::compare(const T &in) const +{ + if (this->size() == 0) return 0 - in; + return this->get(0) - in; +} + +template int Jupiter::Readable_String::compare(const std::nullptr_t) const +{ + if (this->size() == 0) return true; + return this->get(0); +} + +// equals() + +template bool Jupiter::Readable_String::equals(const Jupiter::Readable_String &in) const +{ + if (this->size() != in.size()) return false; + + // rewrite to compare multiple bytes at a time. + size_t index = 0; + while (index != this->size()) + { + if (this->get(index) != in.get(index)) return false; + index++; + } + return true; +} + +template bool Jupiter::Readable_String::equals(const std::basic_string &in) const +{ + if (this->size() != in.size()) return false; + // rewrite to compare multiple bytes at a time. + size_t index = 0; + while (index != this->size()) + { + if (this->get(index) != in.at(index)) return false; + index++; + } + return true; +} + +template bool Jupiter::Readable_String::equals(const T *in) const +{ + if (in == nullptr) return this->size() == 0; + for (size_t index = 0; index != this->size(); index++) + { + if (*in == 0 || this->get(index) != *in) return false; + in++; + } + return *in == 0; +} + +template bool Jupiter::Readable_String::equals(const T &in) const +{ + return this->size() == 1 && this->get(0) == in; +} + +template bool Jupiter::Readable_String::equals(std::nullptr_t) const +{ + return this->size() == 0; +} + +// equalsi() + +template<> bool inline Jupiter::Readable_String::equalsi(const Jupiter::Readable_String &in) const +{ + if (this->size() != in.size()) return false; + for (size_t index = 0; index != this->size(); index++) + { + if (toupper(this->get(index)) != toupper(in.get(index))) return false; + } + return true; +} + +template<> bool inline Jupiter::Readable_String::equalsi(const Jupiter::Readable_String &in) const +{ + if (this->size() != in.size()) return false; + for (size_t index = 0; index != this->size(); index++) + { + if (towupper(this->get(index)) != towupper(in.get(index))) return false; + } + return true; +} + +template bool Jupiter::Readable_String::equalsi(const Jupiter::Readable_String &in) const +{ + return this->equals(in); // Concept of "case" not supported for type. +} + +template<> bool inline Jupiter::Readable_String::equalsi(const std::basic_string &in) const +{ + if (this->size() != in.size()) return false; + for (size_t index = 0; index != this->size(); index++) + { + if (toupper(this->get(index)) != toupper(in.at(index))) return false; + } + return true; +} + +template<> bool inline Jupiter::Readable_String::equalsi(const std::basic_string &in) const +{ + if (this->size() != in.size()) return false; + for (size_t index = 0; index != this->size(); index++) + { + if (towupper(this->get(index)) != towupper(in.at(index))) return false; + } + return true; +} + +template bool Jupiter::Readable_String::equalsi(const std::basic_string &in) const +{ + return this->equals(in); // Concept of "case" not supported for type. +} + +template<> bool inline Jupiter::Readable_String::equalsi(const char *in) const +{ + if (in == nullptr) return this->size() == 0; + for (size_t index = 0; index != this->size(); index++) + { + if (*in == 0 || toupper(this->get(index)) != toupper(*in)) return false; + in++; + } + return *in == 0; +} + +template<> bool inline Jupiter::Readable_String::equalsi(const wchar_t *in) const +{ + if (in == nullptr) return this->size() == 0; + for (size_t index = 0; index != this->size(); index++) + { + if (*in == 0 || towupper(this->get(index)) != towupper(*in)) return false; + in++; + } + return *in == 0; +} + +template bool Jupiter::Readable_String::equalsi(const T *in) const +{ + return this->equals(in); // Concept of "case" not supported for type. +} + +template<> bool inline Jupiter::Readable_String::equalsi(const char &in) const +{ + return this->size() == 1 && toupper(this->get(0)) == toupper(in); +} + +template<> bool inline Jupiter::Readable_String::equalsi(const wchar_t &in) const +{ + return this->size() == 1 && towupper(this->get(0)) == towupper(in); +} + +template bool Jupiter::Readable_String::equalsi(const T &in) const +{ + return this->equals(in); // Concept of "case" not supported for type. +} + +template bool Jupiter::Readable_String::equalsi(const std::nullptr_t) const +{ + return this->size() == 0; +} + +// match() + +template<> bool inline Jupiter::Readable_String::match(const Jupiter::Readable_String &format) const +{ + size_t index = 0; + size_t formatIndex = 0; + while (formatIndex != format.size()) + { + if (format.get(formatIndex) == '*') + { + formatIndex++; + while (format.get(formatIndex) == '?') + { + if (this->get(index) == 0) return false; + formatIndex++; + index++; + } + if (format.get(formatIndex) == 0) return true; + if (format.get(formatIndex) == '*') continue; + while (format.get(formatIndex) != this->get(index)) + { + if (this->get(index) == 0) return false; + index++; + } + } + else if (format.get(formatIndex) != '?' && format.get(formatIndex) != this->get(index)) return false; + formatIndex++; + index++; + } + return index == this->size(); +} + +template<> bool inline Jupiter::Readable_String::match(const Jupiter::Readable_String &format) const +{ + size_t index = 0; + size_t formatIndex = 0; + while (formatIndex != format.size()) + { + if (format.get(formatIndex) == '*') + { + formatIndex++; + while (format.get(formatIndex) == '?') + { + if (this->get(index) == 0) return false; + formatIndex++; + index++; + } + if (format.get(formatIndex) == 0) return true; + if (format.get(formatIndex) == '*') continue; + while (format.get(formatIndex) != this->get(index)) + { + if (this->get(index) == 0) return false; + index++; + } + } + else if (format.get(formatIndex) != '?' && format.get(formatIndex) != this->get(index)) return false; + formatIndex++; + index++; + } + return index == this->size(); +} + +template bool Jupiter::Readable_String::match(const Jupiter::Readable_String &format) const +{ + return false; // Wildcard matching not supported for type. +} + +template<> bool inline Jupiter::Readable_String::match(const std::basic_string &format) const +{ + size_t index = 0; + size_t formatIndex = 0; + while (formatIndex != format.size()) + { + if (format.at(formatIndex) == '*') + { + formatIndex++; + while (format.at(formatIndex) == '?') + { + if (this->get(index) == 0) return false; + formatIndex++; + index++; + } + if (format.at(formatIndex) == 0) return true; + if (format.at(formatIndex) == '*') continue; + while (format.at(formatIndex) != this->get(index)) + { + if (this->get(index) == 0) return false; + index++; + } + } + else if (format.at(formatIndex) != '?' && format.at(formatIndex) != this->get(index)) return false; + formatIndex++; + index++; + } + return index == this->size(); +} + +template<> bool inline Jupiter::Readable_String::match(const std::basic_string &format) const +{ + size_t index = 0; + size_t formatIndex = 0; + while (formatIndex != format.size()) + { + if (format.at(formatIndex) == '*') + { + formatIndex++; + while (format.at(formatIndex) == '?') + { + if (this->get(index) == 0) return false; + formatIndex++; + index++; + } + if (format.at(formatIndex) == 0) return true; + if (format.at(formatIndex) == '*') continue; + while (format.at(formatIndex) != this->get(index)) + { + if (this->get(index) == 0) return false; + index++; + } + } + else if (format.at(formatIndex) != '?' && format.at(formatIndex) != this->get(index)) return false; + formatIndex++; + index++; + } + return index == this->size(); +} + +template bool Jupiter::Readable_String::match(const std::basic_string &format) const +{ + return false; // Wildcard matching not supported for type. +} + +template<> inline bool Jupiter::Readable_String::match(const char *format) const +{ + size_t index = 0; + while (*format != 0) + { + if (*format == '*') + { + format++; + while (*format == '?') + { + if (this->get(index) == 0) return false; + format++; + index++; + } + if (*format == 0) return true; + if (*format == '*') continue; + while (*format != this->get(index)) + { + if (this->get(index) == 0) return false; + index++; + } + } + else if (*format != '?' && *format != this->get(index)) return false; + format++; + index++; + } + return index == this->size(); +} + +template<> inline bool Jupiter::Readable_String::match(const wchar_t *format) const +{ + size_t index = 0; + while (*format != 0) + { + if (*format == L'*') + { + format++; + while (*format == L'?') + { + if (this->get(index) == 0) return false; + format++; + index++; + } + if (*format == 0) return true; + if (*format == L'*') continue; + while (*format != this->get(index)) + { + if (this->get(index) == 0) return false; + index++; + } + } + else if (*format != L'?' && *format != this->get(index)) return false; + format++; + index++; + } + return index == this->size(); +} + +template bool Jupiter::Readable_String::match(const T *format) const +{ + return false; // Wildcard matching not supported for type. +} + +// matchi() + +template<> bool inline Jupiter::Readable_String::matchi(const Jupiter::Readable_String &format) const +{ + int fUpper; + size_t index = 0; + size_t formatIndex = 0; + while (formatIndex != format.size()) + { + if (format.get(formatIndex) == L'*') + { + formatIndex++; + while (format.get(formatIndex) == L'?') + { + if (this->get(index) == 0) return false; + formatIndex++; + index++; + } + if (format.get(formatIndex) == 0) return true; + if (format.get(formatIndex) == '*') continue; + fUpper = toupper(format.get(formatIndex)); + while (fUpper != toupper(this->get(index))) + { + if (this->get(index) == 0) return false; + index++; + } + } + else if (format.get(formatIndex) != L'?' && toupper(format.get(formatIndex)) != toupper(this->get(index))) return false; + formatIndex++; + index++; + } + return index == this->size(); +} + +template<> bool inline Jupiter::Readable_String::matchi(const Jupiter::Readable_String &format) const +{ + wint_t fUpper; + size_t index = 0; + size_t formatIndex = 0; + while (formatIndex != format.size()) + { + if (format.get(formatIndex) == L'*') + { + formatIndex++; + while (format.get(formatIndex) == L'?') + { + if (this->get(index) == 0) return false; + formatIndex++; + index++; + } + if (format.get(formatIndex) == 0) return true; + if (format.get(formatIndex) == '*') continue; + fUpper = towupper(format.get(formatIndex)); + while (fUpper != towupper(this->get(index))) + { + if (this->get(index) == 0) return false; + index++; + } + } + else if (format.get(formatIndex) != L'?' && towupper(format.get(formatIndex)) != towupper(this->get(index))) return false; + formatIndex++; + index++; + } + return index == this->size(); +} + +template bool Jupiter::Readable_String::matchi(const Jupiter::Readable_String &format) const +{ + return false; // Wildcard matching not supported for type. Concept of "case" not supported for type. +} + +template<> bool inline Jupiter::Readable_String::matchi(const std::basic_string &format) const +{ + int fUpper; + size_t index = 0; + size_t formatIndex = 0; + while (formatIndex != format.size()) + { + if (format.at(formatIndex) == L'*') + { + formatIndex++; + while (format.at(formatIndex) == L'?') + { + if (this->get(index) == 0) return false; + formatIndex++; + index++; + } + if (format.at(formatIndex) == 0) return true; + if (format.at(formatIndex) == '*') continue; + fUpper = toupper(format.at(formatIndex)); + while (fUpper != toupper(this->get(index))) + { + if (this->get(index) == 0) return false; + index++; + } + } + else if (format.at(formatIndex) != L'?' && toupper(format.at(formatIndex)) != toupper(this->get(index))) return false; + formatIndex++; + index++; + } + return index == this->size(); +} + +template<> bool inline Jupiter::Readable_String::matchi(const std::basic_string &format) const +{ + wint_t fUpper; + size_t index = 0; + size_t formatIndex = 0; + while (formatIndex != format.size()) + { + if (format.at(formatIndex) == L'*') + { + formatIndex++; + while (format.at(formatIndex) == L'?') + { + if (this->get(index) == 0) return false; + formatIndex++; + index++; + } + if (format.at(formatIndex) == 0) return true; + if (format.at(formatIndex) == '*') continue; + fUpper = towupper(format.at(formatIndex)); + while (fUpper != towupper(this->get(index))) + { + if (this->get(index) == 0) return false; + index++; + } + } + else if (format.at(formatIndex) != L'?' && towupper(format.at(formatIndex)) != towupper(this->get(index))) return false; + formatIndex++; + index++; + } + return index == this->size(); +} + +template bool Jupiter::Readable_String::matchi(const std::basic_string &format) const +{ + return false; // Wildcard matching not supported for type. Concept of "case" not supported for type. +} + +template<> bool inline Jupiter::Readable_String::matchi(const char *format) const +{ + int fUpper; + size_t index = 0; + while (*format != 0) + { + if (*format == '*') + { + format++; + while (*format == '?') + { + if (this->get(index) == 0) return false; + format++; + index++; + } + if (*format == 0) return true; + if (*format == '*') continue; + fUpper = toupper(*format); + while (fUpper != toupper(this->get(index))) + { + if (this->get(index) == 0) return false; + index++; + } + } + else if (*format != '?' && toupper(*format) != toupper(this->get(index))) return false; + format++; + index++; + } + return index == this->size(); +} + +template<> bool inline Jupiter::Readable_String::matchi(const wchar_t *format) const +{ + wint_t fUpper; + size_t index = 0; + while (*format != 0) + { + if (*format == L'*') + { + format++; + while (*format == L'?') + { + if (this->get(index) == 0) return false; + format++; + index++; + } + if (*format == 0) return true; + if (*format == '*') continue; + fUpper = towupper(*format); + while (fUpper != towupper(this->get(index))) + { + if (this->get(index) == 0) return false; + index++; + } + } + else if (*format != L'?' && towupper(*format) != towupper(this->get(index))) return false; + format++; + index++; + } + return index == this->size(); +} + +template bool Jupiter::Readable_String::matchi(const T *format) const +{ + return false; // Wildcard matching not supported for type. Concept of "case" not supported for type. +} + +// wordCount() + +template unsigned int Jupiter::Readable_String::wordCount(const T *whitespace) const +{ + unsigned int result = 0; + const T *p = this->ptr(); + bool prev = true; + while (*p != 0) + { + if (Jupiter::strpbrk(whitespace, *p) == nullptr) // This isn't whitespace! + { + if (prev == true) // We just left whitespace! + { + prev = false; + result++; + } + } + else prev = true; // This is whitespace! + p++; + } + return result; +} + +// as + +template<> unsigned int inline Jupiter::Readable_String::asUnsignedInt(int base) const +{ + return strtoui_s(this->ptr(), this->size(), base); +} + +template unsigned int Jupiter::Readable_String::asUnsignedInt(int base) const +{ + return 0; +} + +template<> int inline Jupiter::Readable_String::asInt(int base) const +{ + return strtoi_s(this->ptr(), this->size(), base); +} + +template int Jupiter::Readable_String::asInt(int base) const +{ + return 0; +} + +// Stream output + +template size_t Jupiter::Readable_String::print(FILE *out) const +{ + return fwrite(this->ptr(), sizeof(T), this->size(), out); +} + +template<> size_t inline Jupiter::Readable_String::print(FILE *out) const +{ + size_t index = 0; + while (index != this->size() && fputwc(this->get(index), out) != WEOF) index++; + return index; +} + +template size_t Jupiter::Readable_String::print(std::basic_ostream &out) const +{ + size_t index = 0; + while (index != this->size()) + { + out << this->get(index); + index++; + } + return index; +} + +template size_t Jupiter::Readable_String::println(FILE *out) const +{ + size_t r = this->print(out); + if (r != this->size()) return r; + if (fputs("\r\n", out) != EOF) r += 2; + return r; +} + +template size_t Jupiter::Readable_String::println(std::basic_ostream &out) const +{ + size_t r = this->print(out); + if (r != this->size()) return r; + out << std::endl; + return r; +} + +#endif // _READABLE_STRING_IMP_H_HEADER \ No newline at end of file diff --git a/Jupiter/String_Type.h b/Jupiter/String_Type.h index 358ee13..7e6e84e 100644 --- a/Jupiter/String_Type.h +++ b/Jupiter/String_Type.h @@ -24,11 +24,8 @@ * Note: Some methods are commented out. This means that they should be implemented, but could not be put declared in this template (return of abstract type). */ -#include "Jupiter.h" -#include // std::basic_string type #include // va_list -#include -#include +#include "Readable_String.h" namespace Jupiter { @@ -39,7 +36,7 @@ namespace Jupiter * * @param T Element type which the String will store. Defaults to char. */ - template class String_Type + template class String_Type : public Jupiter::Readable_String { public: @@ -65,100 +62,6 @@ namespace Jupiter */ const T *ptr() const; - /** - * @brief Checks if the string contains an element with the specified value. - * - * @param value Value of the element to search for. - * @return True if a match is found, false otherwise. - */ - bool contains(const T &value) const; - - /** - * @brief Compares another string against the String. - * - * @param in String to compare against. - * @return 0 if the strings are equal, negative if the first mismatched character is greater in the String, or positive if it's less. - */ - int compare(const String_Type &in) const; - int compare(const std::basic_string &in) const; - int compare(const T *in) const; - int compare(const T &in) const; - int compare(const std::nullptr_t) const; - - /** - * @brief Checks if the strings are equal. - * Note: Case sensitive. - * - * @param in String to compare against. - * @return True if the contents of the strings are equal, false otherwise. - */ - bool equals(const String_Type &in) const; - bool equals(const std::basic_string &in) const; - bool equals(const T *in) const; - bool equals(const T &in) const; - bool equals(const std::nullptr_t) const; - - /** - * @brief Checks if the strings are equal. - * Note: Case insensitive. Returns false for any type other than char and wchar_t. - * - * @param in String to compare against. - * @return True if the contents of the strings are equal, false otherwise. - */ - bool equalsi(const String_Type &in) const; - bool equalsi(const std::basic_string &in) const; - bool equalsi(const T *in) const; - bool equalsi(const T &in) const; - bool equalsi(const std::nullptr_t) const; - - /** - * @brief Checks if the String matches a wildcard format. - * Note: Case sensitive. - * - * @param format Format that the string is compared against. - * @return True if the String matches the wildcard format, false otherwise. - */ - bool match(const String_Type &format) const; - bool match(const std::basic_string &format) const; - bool match(const T *format) const; - - /** - * @brief Checks if the CString matches a wildcard format. - * Note: Case insensitive. Returns false for any type other than char and wchar_t. - * - * @param format Format that the string is compared against. - * @return True if the CString matches the wildcard format, false otherwise. - */ - bool matchi(const String_Type &format) const; - bool matchi(const std::basic_string &format) const; - bool matchi(const T *format) const; - - /** - * @brief Counts the number of token deliminated words. - * - * @param whitespace A string of tokens used to deliminate words. - * @return Number of words found. - */ - unsigned int wordCount(const T *whitespace) const; - - /** - * @brief Interprets the string as an integer. - * Note: This returns 0 on any value string type other than char. - * - * @param base Base of the string representation. - * @return Integer representation of the string. - */ - int asInt(int base = 0) const; - - /** - * @brief Interprets the string as an integer. - * Note: This returns 0 on any value string type other than char. - * - * @param base Base of the string representation. - * @return Integer representation of the string. - */ - unsigned int asUnsignedInt(int base = 0) const; - /** * @brief Returns a C-Style string version of the String. * @@ -166,24 +69,6 @@ namespace Jupiter */ virtual const T *c_str() const = 0; - /** - * @brief Outputs the string to a FILE stream. - * - * @param out Stream to output to. - * @return Number of elements written successfully. - */ - size_t print(FILE *out) const; - size_t print(std::basic_ostream &out) const; - - /** - * @brief Outputs the string and a newline to a FILE stream - * - * @param out Stream to output to. - * @param Number of elements written successfully. - */ - size_t println(FILE *out) const; - size_t println(std::basic_ostream &out) const; - /** * @brief Sets the CString's contents based on the format string and input variables. * Note: Format specifiers similar to printf. Returns 0 for any type other than char and wchar_t. diff --git a/Jupiter/String_Type_Imp.h b/Jupiter/String_Type_Imp.h index e1d91f5..439ebd1 100644 --- a/Jupiter/String_Type_Imp.h +++ b/Jupiter/String_Type_Imp.h @@ -55,715 +55,6 @@ template const T *Jupiter::String_Type::ptr() const return Jupiter::String_Type::str; } -template bool Jupiter::String_Type::contains(const T &value) const -{ - for (unsigned int i = 0; i < Jupiter::String_Type::length; i++) if (Jupiter::String_Type::str[i] == value) return true; - return false; -} - -// compare() - -template int Jupiter::String_Type::compare(const Jupiter::String_Type &in) const -{ - // rewrite to compare multiple bytes at a time. - size_t index = 0; - while (Jupiter::String_Type::str[index] == in.get(index)) - { - index++; - if (index == in.size()) - { - if (index == Jupiter::String_Type::length) return 0; - return 1; - } - if (index == Jupiter::String_Type::length) return 0 - in.get(index); - } - return Jupiter::String_Type::str[index] - in.get(index); -} - -template int Jupiter::String_Type::compare(const std::basic_string &in) const -{ - // rewrite to compare multiple bytes at a time. - size_t index = 0; - while (Jupiter::String_Type::str[index] == in.at(index)) - { - index++; - if (index == in.size()) - { - if (index == Jupiter::String_Type::length) return 0; - return 1; - } - if (index == Jupiter::String_Type::length) return 0 - in.at(index); - } - return Jupiter::String_Type::str[index] - in.at(index); -} - -template int Jupiter::String_Type::compare(const T *s2) const -{ - if (Jupiter::String_Type::length == 0) return 0 - *s2; - size_t index = 0; - while (Jupiter::String_Type::str[index] == *s2) - { - index++; - if (*s2 == 0) - { - if (index == Jupiter::String_Type::length) return 0; - return 1; - } - s2++; - if (index == Jupiter::String_Type::length) return 0 - *s2; - } - return Jupiter::String_Type::str[index] - *s2; -} - -template int Jupiter::String_Type::compare(const T &in) const -{ - if (Jupiter::String_Type::length == 0) return 0 - in; - return *Jupiter::String_Type::str - in; -} - -template int Jupiter::String_Type::compare(const std::nullptr_t) const -{ - if (Jupiter::String_Type::length == 0) return true; - return *Jupiter::String_Type::str; -} - -// equals() - -template bool Jupiter::String_Type::equals(const Jupiter::String_Type &in) const -{ - if (Jupiter::String_Type::length != in.size()) return false; - - // rewrite to compare multiple bytes at a time. - size_t index = 0; - while (index != Jupiter::String_Type::length) - { - if (Jupiter::String_Type::str[index] != in.str[index]) return false; - index++; - } - return true; -} - -template bool Jupiter::String_Type::equals(const std::basic_string &in) const -{ - if (Jupiter::String_Type::length != in.size()) return false; - // rewrite to compare multiple bytes at a time. - size_t index = 0; - while (index != Jupiter::String_Type::length) - { - if (Jupiter::String_Type::str[index] != in.at(index)) return false; - index++; - } - return true; -} - -template bool Jupiter::String_Type::equals(const T *in) const -{ - if (in == nullptr) return Jupiter::String_Type::length == 0; - for (size_t index = 0; index != Jupiter::String_Type::length; index++) - { - if (*in == 0 || Jupiter::String_Type::str[index] != *in) return false; - in++; - } - return *in == 0; -} - -template bool Jupiter::String_Type::equals(const T &in) const -{ - return Jupiter::String_Type::length == 1 && *Jupiter::String_Type::str == in; -} - -template bool Jupiter::String_Type::equals(std::nullptr_t) const -{ - return Jupiter::String_Type::length == 0; -} - -// equalsi() - -template<> bool inline Jupiter::String_Type::equalsi(const Jupiter::String_Type &in) const -{ - if (Jupiter::String_Type::length != in.size()) return false; - for (size_t index = 0; index != Jupiter::String_Type::length; index++) - { - if (toupper(Jupiter::String_Type::str[index]) != toupper(in.str[index])) return false; - } - return true; -} - -template<> bool inline Jupiter::String_Type::equalsi(const Jupiter::String_Type &in) const -{ - if (Jupiter::String_Type::length != in.size()) return false; - for (size_t index = 0; index != Jupiter::String_Type::length; index++) - { - if (towupper(Jupiter::String_Type::str[index]) != towupper(in.str[index])) return false; - } - return true; -} - -template bool Jupiter::String_Type::equalsi(const Jupiter::String_Type &in) const -{ - return Jupiter::String_Type::equals(in); // Concept of "case" not supported for type. -} - -template<> bool inline Jupiter::String_Type::equalsi(const std::basic_string &in) const -{ - if (Jupiter::String_Type::length != in.size()) return false; - for (size_t index = 0; index != Jupiter::String_Type::length; index++) - { - if (toupper(Jupiter::String_Type::str[index]) != toupper(in.at(index))) return false; - } - return true; -} - -template<> bool inline Jupiter::String_Type::equalsi(const std::basic_string &in) const -{ - if (Jupiter::String_Type::length != in.size()) return false; - for (size_t index = 0; index != Jupiter::String_Type::length; index++) - { - if (towupper(Jupiter::String_Type::str[index]) != towupper(in.at(index))) return false; - } - return true; -} - -template bool Jupiter::String_Type::equalsi(const std::basic_string &in) const -{ - return Jupiter::String_Type::equals(in); // Concept of "case" not supported for type. -} - -template<> bool inline Jupiter::String_Type::equalsi(const char *in) const -{ - if (in == nullptr) return Jupiter::String_Type::length == 0; - for (size_t index = 0; index != Jupiter::String_Type::length; index++) - { - if (*in == 0 || toupper(Jupiter::String_Type::str[index]) != toupper(*in)) return false; - in++; - } - return *in == 0; -} - -template<> bool inline Jupiter::String_Type::equalsi(const wchar_t *in) const -{ - if (in == nullptr) return Jupiter::String_Type::length == 0; - for (size_t index = 0; index != Jupiter::String_Type::length; index++) - { - if (*in == 0 || towupper(Jupiter::String_Type::str[index]) != towupper(*in)) return false; - in++; - } - return *in == 0; -} - -template bool Jupiter::String_Type::equalsi(const T *in) const -{ - return Jupiter::String_Type::equals(in); // Concept of "case" not supported for type. -} - -template<> bool inline Jupiter::String_Type::equalsi(const char &in) const -{ - return Jupiter::String_Type::length == 1 && toupper(*Jupiter::String_Type::str) == toupper(in); -} - -template<> bool inline Jupiter::String_Type::equalsi(const wchar_t &in) const -{ - return Jupiter::String_Type::length == 1 && towupper(*Jupiter::String_Type::str) == towupper(in); -} - -template bool Jupiter::String_Type::equalsi(const T &in) const -{ - return Jupiter::String_Type::equals(in); // Concept of "case" not supported for type. -} - -template bool Jupiter::String_Type::equalsi(const std::nullptr_t) const -{ - return Jupiter::String_Type::length == 0; -} - -// match() - -template<> bool inline Jupiter::String_Type::match(const Jupiter::String_Type &format) const -{ - size_t index = 0; - size_t formatIndex = 0; - while (formatIndex != format.size()) - { - if (format.str[formatIndex] == '*') - { - formatIndex++; - while (format.str[formatIndex] == '?') - { - if (Jupiter::String_Type::str[index] == 0) return false; - formatIndex++; - index++; - } - if (format.str[formatIndex] == 0) return true; - if (format.str[formatIndex] == '*') continue; - while (format.str[formatIndex] != Jupiter::String_Type::str[index]) - { - if (Jupiter::String_Type::str[index] == 0) return false; - index++; - } - } - else if (format.str[formatIndex] != '?' && format.str[formatIndex] != Jupiter::String_Type::str[index]) return false; - formatIndex++; - index++; - } - return index == Jupiter::String_Type::length; -} - -template<> bool inline Jupiter::String_Type::match(const Jupiter::String_Type &format) const -{ - size_t index = 0; - size_t formatIndex = 0; - while (formatIndex != format.size()) - { - if (format.str[formatIndex] == '*') - { - formatIndex++; - while (format.str[formatIndex] == '?') - { - if (Jupiter::String_Type::str[index] == 0) return false; - formatIndex++; - index++; - } - if (format.str[formatIndex] == 0) return true; - if (format.str[formatIndex] == '*') continue; - while (format.str[formatIndex] != Jupiter::String_Type::str[index]) - { - if (Jupiter::String_Type::str[index] == 0) return false; - index++; - } - } - else if (format.str[formatIndex] != '?' && format.str[formatIndex] != Jupiter::String_Type::str[index]) return false; - formatIndex++; - index++; - } - return index == Jupiter::String_Type::length; -} - -template bool Jupiter::String_Type::match(const Jupiter::String_Type &format) const -{ - return false; // Wildcard matching not supported for type. -} - -template<> bool inline Jupiter::String_Type::match(const std::basic_string &format) const -{ - size_t index = 0; - size_t formatIndex = 0; - while (formatIndex != format.size()) - { - if (format.at(formatIndex) == '*') - { - formatIndex++; - while (format.at(formatIndex) == '?') - { - if (Jupiter::String_Type::str[index] == 0) return false; - formatIndex++; - index++; - } - if (format.at(formatIndex) == 0) return true; - if (format.at(formatIndex) == '*') continue; - while (format.at(formatIndex) != Jupiter::String_Type::str[index]) - { - if (Jupiter::String_Type::str[index] == 0) return false; - index++; - } - } - else if (format.at(formatIndex) != '?' && format.at(formatIndex) != Jupiter::String_Type::str[index]) return false; - formatIndex++; - index++; - } - return index == Jupiter::String_Type::length; -} - -template<> bool inline Jupiter::String_Type::match(const std::basic_string &format) const -{ - size_t index = 0; - size_t formatIndex = 0; - while (formatIndex != format.size()) - { - if (format.at(formatIndex) == '*') - { - formatIndex++; - while (format.at(formatIndex) == '?') - { - if (Jupiter::String_Type::str[index] == 0) return false; - formatIndex++; - index++; - } - if (format.at(formatIndex) == 0) return true; - if (format.at(formatIndex) == '*') continue; - while (format.at(formatIndex) != Jupiter::String_Type::str[index]) - { - if (Jupiter::String_Type::str[index] == 0) return false; - index++; - } - } - else if (format.at(formatIndex) != '?' && format.at(formatIndex) != Jupiter::String_Type::str[index]) return false; - formatIndex++; - index++; - } - return index == Jupiter::String_Type::length; -} - -template bool Jupiter::String_Type::match(const std::basic_string &format) const -{ - return false; // Wildcard matching not supported for type. -} - -template<> inline bool Jupiter::String_Type::match(const char *format) const -{ - size_t index = 0; - while (*format != 0) - { - if (*format == '*') - { - format++; - while (*format == '?') - { - if (Jupiter::String_Type::str[index] == 0) return false; - format++; - index++; - } - if (*format == 0) return true; - if (*format == '*') continue; - while (*format != Jupiter::String_Type::str[index]) - { - if (Jupiter::String_Type::str[index] == 0) return false; - index++; - } - } - else if (*format != '?' && *format != Jupiter::String_Type::str[index]) return false; - format++; - index++; - } - return index == Jupiter::String_Type::length; -} - -template<> inline bool Jupiter::String_Type::match(const wchar_t *format) const -{ - size_t index = 0; - while (*format != 0) - { - if (*format == L'*') - { - format++; - while (*format == L'?') - { - if (Jupiter::String_Type::str[index] == 0) return false; - format++; - index++; - } - if (*format == 0) return true; - if (*format == L'*') continue; - while (*format != Jupiter::String_Type::str[index]) - { - if (Jupiter::String_Type::str[index] == 0) return false; - index++; - } - } - else if (*format != L'?' && *format != Jupiter::String_Type::str[index]) return false; - format++; - index++; - } - return index == Jupiter::String_Type::length; -} - -template bool Jupiter::String_Type::match(const T *format) const -{ - return false; // Wildcard matching not supported for type. -} - -// matchi() - -template<> bool inline Jupiter::String_Type::matchi(const Jupiter::String_Type &format) const -{ - int fUpper; - size_t index = 0; - size_t formatIndex = 0; - while (formatIndex != format.size()) - { - if (format.get(formatIndex) == L'*') - { - formatIndex++; - while (format.get(formatIndex) == L'?') - { - if (Jupiter::String_Type::str[index] == 0) return false; - formatIndex++; - index++; - } - if (format.get(formatIndex) == 0) return true; - if (format.get(formatIndex) == '*') continue; - fUpper = toupper(format.get(formatIndex)); - while (fUpper != toupper(Jupiter::String_Type::str[index])) - { - if (Jupiter::String_Type::str[index] == 0) return false; - index++; - } - } - else if (format.get(formatIndex) != L'?' && toupper(format.get(formatIndex)) != toupper(Jupiter::String_Type::str[index])) return false; - formatIndex++; - index++; - } - return index == Jupiter::String_Type::length; -} - -template<> bool inline Jupiter::String_Type::matchi(const Jupiter::String_Type &format) const -{ - wint_t fUpper; - size_t index = 0; - size_t formatIndex = 0; - while (formatIndex != format.size()) - { - if (format.get(formatIndex) == L'*') - { - formatIndex++; - while (format.get(formatIndex) == L'?') - { - if (Jupiter::String_Type::str[index] == 0) return false; - formatIndex++; - index++; - } - if (format.get(formatIndex) == 0) return true; - if (format.get(formatIndex) == '*') continue; - fUpper = towupper(format.get(formatIndex)); - while (fUpper != towupper(Jupiter::String_Type::str[index])) - { - if (Jupiter::String_Type::str[index] == 0) return false; - index++; - } - } - else if (format.get(formatIndex) != L'?' && towupper(format.get(formatIndex)) != towupper(Jupiter::String_Type::str[index])) return false; - formatIndex++; - index++; - } - return index == Jupiter::String_Type::length; -} - -template bool Jupiter::String_Type::matchi(const Jupiter::String_Type &format) const -{ - return false; // Wildcard matching not supported for type. Concept of "case" not supported for type. -} - -template<> bool inline Jupiter::String_Type::matchi(const std::basic_string &format) const -{ - int fUpper; - size_t index = 0; - size_t formatIndex = 0; - while (formatIndex != format.size()) - { - if (format.at(formatIndex) == L'*') - { - formatIndex++; - while (format.at(formatIndex) == L'?') - { - if (Jupiter::String_Type::str[index] == 0) return false; - formatIndex++; - index++; - } - if (format.at(formatIndex) == 0) return true; - if (format.at(formatIndex) == '*') continue; - fUpper = toupper(format.at(formatIndex)); - while (fUpper != toupper(Jupiter::String_Type::str[index])) - { - if (Jupiter::String_Type::str[index] == 0) return false; - index++; - } - } - else if (format.at(formatIndex) != L'?' && toupper(format.at(formatIndex)) != toupper(Jupiter::String_Type::str[index])) return false; - formatIndex++; - index++; - } - return index == Jupiter::String_Type::length; -} - -template<> bool inline Jupiter::String_Type::matchi(const std::basic_string &format) const -{ - wint_t fUpper; - size_t index = 0; - size_t formatIndex = 0; - while (formatIndex != format.size()) - { - if (format.at(formatIndex) == L'*') - { - formatIndex++; - while (format.at(formatIndex) == L'?') - { - if (Jupiter::String_Type::str[index] == 0) return false; - formatIndex++; - index++; - } - if (format.at(formatIndex) == 0) return true; - if (format.at(formatIndex) == '*') continue; - fUpper = towupper(format.at(formatIndex)); - while (fUpper != towupper(Jupiter::String_Type::str[index])) - { - if (Jupiter::String_Type::str[index] == 0) return false; - index++; - } - } - else if (format.at(formatIndex) != L'?' && towupper(format.at(formatIndex)) != towupper(Jupiter::String_Type::str[index])) return false; - formatIndex++; - index++; - } - return index == Jupiter::String_Type::length; -} - -template bool Jupiter::String_Type::matchi(const std::basic_string &format) const -{ - return false; // Wildcard matching not supported for type. Concept of "case" not supported for type. -} - -template<> bool inline Jupiter::String_Type::matchi(const char *format) const -{ - int fUpper; - size_t index = 0; - while (*format != 0) - { - if (*format == '*') - { - format++; - while (*format == '?') - { - if (Jupiter::String_Type::str[index] == 0) return false; - format++; - index++; - } - if (*format == 0) return true; - if (*format == '*') continue; - fUpper = toupper(*format); - while (fUpper != toupper(Jupiter::String_Type::str[index])) - { - if (Jupiter::String_Type::str[index] == 0) return false; - index++; - } - } - else if (*format != '?' && toupper(*format) != toupper(Jupiter::String_Type::str[index])) return false; - format++; - index++; - } - return index == Jupiter::String_Type::length; -} - -template<> bool inline Jupiter::String_Type::matchi(const wchar_t *format) const -{ - wint_t fUpper; - size_t index = 0; - while (*format != 0) - { - if (*format == L'*') - { - format++; - while (*format == L'?') - { - if (Jupiter::String_Type::str[index] == 0) return false; - format++; - index++; - } - if (*format == 0) return true; - if (*format == '*') continue; - fUpper = towupper(*format); - while (fUpper != towupper(Jupiter::String_Type::str[index])) - { - if (Jupiter::String_Type::str[index] == 0) return false; - index++; - } - } - else if (*format != L'?' && towupper(*format) != towupper(Jupiter::String_Type::str[index])) return false; - format++; - index++; - } - return index == Jupiter::String_Type::length; -} - -template bool Jupiter::String_Type::matchi(const T *format) const -{ - return false; // Wildcard matching not supported for type. Concept of "case" not supported for type. -} - -// wordCount() - -template unsigned int Jupiter::String_Type::wordCount(const T *whitespace) const -{ - unsigned int result = 0; - T *p = Jupiter::String_Type::str; - bool prev = true; - while (*p != 0) - { - if (Jupiter::strpbrk(whitespace, *p) == nullptr) // This isn't whitespace! - { - if (prev == true) // We just left whitespace! - { - prev = false; - result++; - } - } - else prev = true; // This is whitespace! - p++; - } - return result; -} - -// as - -template<> unsigned int inline Jupiter::String_Type::asUnsignedInt(int base) const -{ - return strtoui_s(Jupiter::String_Type::str, Jupiter::String_Type::length, base); -} - -template unsigned int Jupiter::String_Type::asUnsignedInt(int base) const -{ - return 0; -} - -template<> int inline Jupiter::String_Type::asInt(int base) const -{ - return strtoi_s(Jupiter::String_Type::str, Jupiter::String_Type::length, base); -} - -template int Jupiter::String_Type::asInt(int base) const -{ - return 0; -} - -// Stream output - -template size_t Jupiter::String_Type::print(FILE *out) const -{ - return fwrite(Jupiter::String_Type::str, sizeof(T), Jupiter::String_Type::length, out); -} - -template<> size_t inline Jupiter::String_Type::print(FILE *out) const -{ - size_t index = 0; - while (index != Jupiter::String_Type::length && fputwc(Jupiter::String_Type::str[index], out) != WEOF) index++; - return index; -} - -template size_t Jupiter::String_Type::print(std::basic_ostream &out) const -{ - size_t index = 0; - while (index != Jupiter::String_Type::length) - { - out << Jupiter::String_Type::str[index]; - index++; - } - return index; -} - -template size_t Jupiter::String_Type::println(FILE *out) const -{ - size_t r = Jupiter::String_Type::print(out); - if (r != Jupiter::String_Type::length) return r; - if (fputs("\r\n", out) != EOF) r += 2; - return r; -} - -template size_t Jupiter::String_Type::println(std::basic_ostream &out) const -{ - size_t r = Jupiter::String_Type::print(out); - if (r != Jupiter::String_Type::length) return r; - out << std::endl; - return r; -} - // format forwards template size_t Jupiter::String_Type::format(const String_Type &format, ...) diff --git a/Release/Jupiter.lib b/Release/Jupiter.lib index f92f4c1283ead6639cb95f42db8de2e48146ed6e..086217a4ec9c52ffad203533de36c6e82afe13b7 100644 GIT binary patch literal 203748 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�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 NX^36VUI|B*=RfV`D+T}n literal 194266 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
|iMW69E_){GAFLNeB&Oj3O+lQg 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 LoO