mirror of https://github.com/JAJames/Jupiter.git
36 changed files with 277 additions and 2053 deletions
@ -1,61 +0,0 @@ |
|||||
/**
|
|
||||
* Copyright (C) 2014-2015 Jessica James. |
|
||||
* |
|
||||
* Permission to use, copy, modify, and/or distribute this software for any |
|
||||
* purpose with or without fee is hereby granted, provided that the above |
|
||||
* copyright notice and this permission notice appear in all copies. |
|
||||
* |
|
||||
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES |
|
||||
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF |
|
||||
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY |
|
||||
* SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES |
|
||||
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION |
|
||||
* OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN |
|
||||
* CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. |
|
||||
* |
|
||||
* Written by Jessica James <jessica.aj@outlook.com> |
|
||||
*/ |
|
||||
|
|
||||
#if !defined _INVALIDINDEX_H_HEADER |
|
||||
#define _INVALIDINDEX_H_HEADER |
|
||||
|
|
||||
/**
|
|
||||
* @file InvalidIndex.h |
|
||||
* @brief Defines some constants for invalid indexes for unsigned types. |
|
||||
*/ |
|
||||
|
|
||||
#if defined __cplusplus |
|
||||
#include <cstdint> |
|
||||
#include <climits> |
|
||||
|
|
||||
namespace Jupiter |
|
||||
{ |
|
||||
static const size_t INVALID_INDEX = SIZE_MAX; |
|
||||
static const uint32_t INVALID_INDEX32 = UINT32_MAX; |
|
||||
static const uint64_t INVALID_INDEX64 = UINT64_MAX; |
|
||||
|
|
||||
static const unsigned int ERROR_INDICATOR = UINT_MAX; |
|
||||
static const uint32_t ERROR_INDICATOR32 = INVALID_INDEX32; |
|
||||
static const uint64_t ERROR_INDICATOR64 = INVALID_INDEX32; |
|
||||
} |
|
||||
|
|
||||
extern "C" |
|
||||
{ |
|
||||
#else |
|
||||
#include <stdint.h> |
|
||||
#include <limits.h> |
|
||||
#endif // __cplusplus
|
|
||||
|
|
||||
static const size_t JUPITER_INVALID_INDEX = SIZE_MAX; |
|
||||
static const uint32_t JUPITER_INVALID_INDEX32 = UINT32_MAX; |
|
||||
static const uint64_t JUPITER_INVALID_INDEX64 = UINT64_MAX; |
|
||||
|
|
||||
static const unsigned int JUPITER_ERROR_INDICATOR = UINT_MAX; |
|
||||
static const uint32_t JUPITER_ERROR_INDICATOR32 = JUPITER_INVALID_INDEX32; |
|
||||
static const uint64_t JUPITER_ERROR_INDICATOR64 = JUPITER_INVALID_INDEX32; |
|
||||
|
|
||||
#if defined __cplusplus |
|
||||
} |
|
||||
#endif // __cplusplus
|
|
||||
|
|
||||
#endif // _INVALIDINDEX_H_HEADER
|
|
||||
@ -1,45 +0,0 @@ |
|||||
/**
|
|
||||
* Copyright (C) 2014-2017 Jessica James. |
|
||||
* |
|
||||
* Permission to use, copy, modify, and/or distribute this software for any |
|
||||
* purpose with or without fee is hereby granted, provided that the above |
|
||||
* copyright notice and this permission notice appear in all copies. |
|
||||
* |
|
||||
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES |
|
||||
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF |
|
||||
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY |
|
||||
* SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES |
|
||||
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION |
|
||||
* OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN |
|
||||
* CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. |
|
||||
* |
|
||||
* Written by Jessica James <jessica.aj@outlook.com> |
|
||||
*/ |
|
||||
|
|
||||
#if !defined _REFERENCE_STRING_H_HEADER |
|
||||
#define _REFERENCE_STRING_H_HEADER |
|
||||
|
|
||||
/**
|
|
||||
* @file Reference_String.h |
|
||||
* @brief Provides the basis for String types, of any implementation. |
|
||||
* Note: DEPRECATED |
|
||||
*/ |
|
||||
|
|
||||
#include <string_view> |
|
||||
#include "Readable_String.h" |
|
||||
|
|
||||
namespace Jupiter { |
|
||||
/** DEPRECATED: Generic Reference String Type */ |
|
||||
using ReferenceString = std::string_view; |
|
||||
|
|
||||
namespace literals { |
|
||||
/** DEPRECATED: Reference_String literals */ |
|
||||
inline constexpr std::string_view operator"" _jrs(const char *str, size_t len) { return { str, len }; } |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
/** DEPRECATED */ |
|
||||
#define STRING_LITERAL_AS_REFERENCE(str) Jupiter::literals::operator"" _jrs(str, sizeof(str) - 1) |
|
||||
#define STRING_LITERAL_AS_NAMED_REFERENCE(name, str) Jupiter::ReferenceString name = STRING_LITERAL_AS_REFERENCE(str) |
|
||||
|
|
||||
#endif // _REFERENCE_STRING_H_HEADER
|
|
||||
@ -1,114 +0,0 @@ |
|||||
/**
|
|
||||
* Copyright (C) 2014-2015 Jessica James. |
|
||||
* |
|
||||
* Permission to use, copy, modify, and/or distribute this software for any |
|
||||
* purpose with or without fee is hereby granted, provided that the above |
|
||||
* copyright notice and this permission notice appear in all copies. |
|
||||
* |
|
||||
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES |
|
||||
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF |
|
||||
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY |
|
||||
* SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES |
|
||||
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION |
|
||||
* OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN |
|
||||
* CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. |
|
||||
* |
|
||||
* Written by Jessica James <jessica.aj@outlook.com> |
|
||||
*/ |
|
||||
|
|
||||
#if !defined _SHIFT_STRING_H_HEADER |
|
||||
#define _SHIFT_STRING_H_HEADER |
|
||||
|
|
||||
/**
|
|
||||
* @file Shift_String.h |
|
||||
* @brief Allows for separation of a string's representation from its memory base. |
|
||||
*/ |
|
||||
|
|
||||
#include "String_Type.h" |
|
||||
|
|
||||
/** Disable warning 4458 */ |
|
||||
#if defined _MSC_VER |
|
||||
#pragma warning(push) |
|
||||
#pragma warning(disable: 4458) // declaration of 'length' hides class member
|
|
||||
#endif |
|
||||
|
|
||||
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<typename T = char> class Shift_String_Type : public Jupiter::String_Type<T> |
|
||||
{ |
|
||||
public: |
|
||||
|
|
||||
/**
|
|
||||
* @brief Removes the first instance of an element from the string. |
|
||||
* |
|
||||
* @param value Value of the element to remove. |
|
||||
* @return True if an element was removed, false otherwise. |
|
||||
*/ |
|
||||
virtual bool remove(const T &value) override; |
|
||||
|
|
||||
/**
|
|
||||
* @brief Removes a number of elements starting at an index. |
|
||||
* |
|
||||
* @param index Index to start removing elements at. |
|
||||
* @param length Number of elements to remove. |
|
||||
*/ |
|
||||
virtual void remove(size_t index, size_t length) override; |
|
||||
|
|
||||
/**
|
|
||||
* @brief Removes all elements from the string. |
|
||||
*/ |
|
||||
void clear() override; |
|
||||
|
|
||||
/**
|
|
||||
* @brief Sets the internal buffer to be at least large enough to old a specified number of elements. |
|
||||
* Note: This does nothing if len is less than the string's current length. |
|
||||
* |
|
||||
* @param len Minimum number of elements the string buffer must be able to hold. |
|
||||
* @return True if a new buffer was allocated, false otherwise. |
|
||||
*/ |
|
||||
virtual bool setBufferSize(size_t len) override; |
|
||||
|
|
||||
/**
|
|
||||
* @brief Empties the string, and sets the internal buffer to be at least large enough to old a specified number of elements. |
|
||||
* Note: This still empties the string if len is less than the string's current length. |
|
||||
* |
|
||||
* @param len Minimum number of elements the string buffer must be able to hold. |
|
||||
* @return True if a new buffer was allocated, false otherwise. |
|
||||
*/ |
|
||||
virtual bool setBufferSizeNoCopy(size_t len) override; |
|
||||
|
|
||||
/**
|
|
||||
* @brief Default constructor for the Shift_String_Type class. |
|
||||
*/ |
|
||||
Shift_String_Type() {} |
|
||||
|
|
||||
/**
|
|
||||
* @brief Move constructor for the Shift_String_Type class. |
|
||||
*/ |
|
||||
Shift_String_Type(Jupiter::Shift_String_Type<T> &&source); |
|
||||
|
|
||||
/**
|
|
||||
* @brief Destructor for the Shift_String_Type class. |
|
||||
*/ |
|
||||
virtual ~Shift_String_Type(); |
|
||||
|
|
||||
protected: |
|
||||
T *base{ nullptr }; /** Base pointer for the underlying String's memory allocation */ |
|
||||
}; |
|
||||
} |
|
||||
|
|
||||
/** Re-enable warning */ |
|
||||
#if defined _MSC_VER |
|
||||
#pragma warning(pop) |
|
||||
#endif |
|
||||
|
|
||||
#include "Shift_String_Imp.h" |
|
||||
|
|
||||
#endif // _SHIFT_STRING_H_HEADER
|
|
||||
@ -1,102 +0,0 @@ |
|||||
/**
|
|
||||
* Copyright (C) 2014-2015 Jessica James. |
|
||||
* |
|
||||
* Permission to use, copy, modify, and/or distribute this software for any |
|
||||
* purpose with or without fee is hereby granted, provided that the above |
|
||||
* copyright notice and this permission notice appear in all copies. |
|
||||
* |
|
||||
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES |
|
||||
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF |
|
||||
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY |
|
||||
* SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES |
|
||||
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION |
|
||||
* OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN |
|
||||
* CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. |
|
||||
* |
|
||||
* Written by Jessica James <jessica.aj@outlook.com> |
|
||||
*/ |
|
||||
|
|
||||
#if !defined _SHIFT_STRING_IMP_H_HEADER |
|
||||
#define _SHIFT_STRING_IMP_H_HEADER |
|
||||
|
|
||||
/**
|
|
||||
* @file Shift_String_Imp.h |
|
||||
* @brief Provides the implementations for Shift_String_Type functions. |
|
||||
* Note: Modification of this file is not supported in any way. |
|
||||
*/ |
|
||||
|
|
||||
template<typename T> Jupiter::Shift_String_Type<T>::Shift_String_Type(Jupiter::Shift_String_Type<T> &&source) : Jupiter::String_Type<T>(std::move(source)) |
|
||||
{ |
|
||||
Jupiter::Shift_String_Type<T>::base = source.base; |
|
||||
source.base = nullptr; |
|
||||
} |
|
||||
|
|
||||
template<typename T> Jupiter::Shift_String_Type<T>::~Shift_String_Type() |
|
||||
{ |
|
||||
if (Jupiter::Shift_String_Type<T>::base != nullptr) delete[] Jupiter::Shift_String_Type<T>::base; |
|
||||
} |
|
||||
|
|
||||
template<typename T> bool Jupiter::Shift_String_Type<T>::remove(const T &value) |
|
||||
{ |
|
||||
if (Jupiter::String_Type<T>::length == 0) return false; |
|
||||
if (*Jupiter::String_Type<T>::str == value) |
|
||||
{ |
|
||||
if (Jupiter::String_Type<T>::length == 1) this->truncate(1); |
|
||||
else { |
|
||||
++Jupiter::String_Type<T>::str; |
|
||||
--Jupiter::String_Type<T>::length; |
|
||||
} |
|
||||
return true; |
|
||||
} |
|
||||
return Jupiter::String_Type<T>::remove(value); |
|
||||
} |
|
||||
|
|
||||
template<typename T> void Jupiter::Shift_String_Type<T>::remove(size_t index, size_t len) |
|
||||
{ |
|
||||
Jupiter::String_Type<T>::remove(index, len); |
|
||||
} |
|
||||
|
|
||||
template<typename T> void Jupiter::Shift_String_Type<T>::clear() |
|
||||
{ |
|
||||
Jupiter::String_Type<T>::clear(); |
|
||||
Jupiter::String_Type<T>::str = Jupiter::Shift_String_Type<T>::base; |
|
||||
} |
|
||||
|
|
||||
template<typename T> bool Jupiter::Shift_String_Type<T>::setBufferSize(size_t len) |
|
||||
{ |
|
||||
if (len > Jupiter::String_Type<T>::length) |
|
||||
{ |
|
||||
T *ptr = new T[len]; |
|
||||
for (unsigned int i = 0; i < Jupiter::String_Type<T>::length; i++) ptr[i] = Jupiter::String_Type<T>::str[i]; |
|
||||
delete[] Jupiter::Shift_String_Type<T>::base; |
|
||||
Jupiter::Shift_String_Type<T>::base = ptr; |
|
||||
Jupiter::String_Type<T>::str = Jupiter::Shift_String_Type<T>::base; |
|
||||
return true; |
|
||||
} |
|
||||
return false; |
|
||||
} |
|
||||
|
|
||||
template<typename T> bool Jupiter::Shift_String_Type<T>::setBufferSizeNoCopy(size_t len) |
|
||||
{ |
|
||||
if (len > Jupiter::String_Type<T>::length) |
|
||||
{ |
|
||||
Jupiter::String_Type<T>::length = 0; |
|
||||
delete[] Jupiter::Shift_String_Type<T>::base; |
|
||||
Jupiter::Shift_String_Type<T>::base = new T[len]; |
|
||||
Jupiter::String_Type<T>::str = Jupiter::Shift_String_Type<T>::base; |
|
||||
return true; |
|
||||
} |
|
||||
Jupiter::String_Type<T>::length = 0; |
|
||||
Jupiter::String_Type<T>::str = Jupiter::Shift_String_Type<T>::base; |
|
||||
return false; |
|
||||
} |
|
||||
|
|
||||
// Jupiter::DataBuffer specialization
|
|
||||
|
|
||||
template<> struct _Jupiter_DataBuffer_partial_specialization_impl<Jupiter::Shift_String_Type> { |
|
||||
template<typename Y> static void push(Jupiter::DataBuffer *buffer, const Jupiter::Shift_String_Type<Y> *data) { |
|
||||
_Jupiter_DataBuffer_partial_specialization_impl<Jupiter::String_Type>::push<Y>(buffer, data); |
|
||||
}; |
|
||||
}; |
|
||||
|
|
||||
#endif // _SHIFT_STRING_IMP_H_HEADER
|
|
||||
@ -1,185 +0,0 @@ |
|||||
/**
|
|
||||
* Copyright (C) 2013-2017 Jessica James. |
|
||||
* |
|
||||
* Permission to use, copy, modify, and/or distribute this software for any |
|
||||
* purpose with or without fee is hereby granted, provided that the above |
|
||||
* copyright notice and this permission notice appear in all copies. |
|
||||
* |
|
||||
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES |
|
||||
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF |
|
||||
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY |
|
||||
* SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES |
|
||||
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION |
|
||||
* OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN |
|
||||
* CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. |
|
||||
* |
|
||||
* Written by Jessica James <jessica.aj@outlook.com> |
|
||||
*/ |
|
||||
|
|
||||
#if !defined _STRING_H_HEADER |
|
||||
#define _STRING_H_HEADER |
|
||||
|
|
||||
/**
|
|
||||
* @file String.h |
|
||||
* @brief Defines the base String_Base, as well as a series of String types. |
|
||||
* Note: Functions which take "case" or "wildcards" into consideration will only function |
|
||||
* for types char and wchar_t; inputs with other types will simply return false. |
|
||||
*/ |
|
||||
|
|
||||
#include "Shift_String.h" |
|
||||
#include "Hash.h" |
|
||||
|
|
||||
/** Disable warning 4458 */ |
|
||||
#if defined _MSC_VER |
|
||||
#pragma warning(push) |
|
||||
#pragma warning(disable: 4458) // declaration of 'length' hides class member
|
|
||||
#endif |
|
||||
|
|
||||
namespace Jupiter |
|
||||
{ |
|
||||
|
|
||||
/**
|
|
||||
* @brief Provides a minimal String implementation (i.e: no extra variables). |
|
||||
* |
|
||||
* @param T Element type which the String will store. Defaults to char. |
|
||||
*/ |
|
||||
template<typename T = char> class String_Strict : public Shift_String_Type<T> |
|
||||
{ |
|
||||
public: |
|
||||
|
|
||||
/**
|
|
||||
* @brief Creates a partial copy of the string. |
|
||||
* |
|
||||
* @param pos Position in the string to start copying from. |
|
||||
* @return String containing a partial copy of the original string. |
|
||||
*/ |
|
||||
typename Jupiter::template String_Strict<T> substring(size_t pos) const; |
|
||||
|
|
||||
/**
|
|
||||
* @brief Creates a partial copy of the string. |
|
||||
* |
|
||||
* @param pos Position in the string to start copying from. |
|
||||
* @param length Number of characters to copy. |
|
||||
* @return String containing a partial copy of the original string. |
|
||||
*/ |
|
||||
typename Jupiter::template String_Strict<T> substring(size_t pos, size_t length) const; |
|
||||
|
|
||||
/**
|
|
||||
* @brief Creates a partial copy of the string. |
|
||||
* |
|
||||
* @param in String to get a partial copy of. |
|
||||
* @param pos Position in the string to start copying from. |
|
||||
* @return String containing a partial copy of the original string. |
|
||||
*/ |
|
||||
static typename Jupiter::template String_Strict<T> substring(const Jupiter::Readable_String<T> &in, size_t pos); |
|
||||
static typename Jupiter::template String_Strict<T> substring(const T *in, size_t pos); |
|
||||
|
|
||||
/**
|
|
||||
* @brief Creates a partial copy of the string. |
|
||||
* |
|
||||
* @param in String to get a partial copy of. |
|
||||
* @param pos Position in the string to start copying from. |
|
||||
* @param length Number of characters to copy. |
|
||||
* @return String containing a partial copy of the original string. |
|
||||
*/ |
|
||||
static typename Jupiter::template String_Strict<T> substring(const Jupiter::Readable_String<T> &in, size_t pos, size_t length); |
|
||||
static typename Jupiter::template String_Strict<T> substring(const T *in, size_t pos, size_t length); |
|
||||
|
|
||||
/** Default Constructor */ |
|
||||
String_Strict(); |
|
||||
|
|
||||
/**
|
|
||||
* @brief Size hint constructor. |
|
||||
* Note: For the String_Strict base class, this is only truly useful internally. |
|
||||
* |
|
||||
* @param size Minimum number of elements the string must be able to hold. |
|
||||
*/ |
|
||||
String_Strict(size_t size); |
|
||||
|
|
||||
/** Move Constructor */ |
|
||||
String_Strict(String_Strict<T> &&source); |
|
||||
|
|
||||
/** Copy Constructors */ |
|
||||
String_Strict(const String_Strict<T> &in); |
|
||||
String_Strict(const Readable_String<T> &in); |
|
||||
String_Strict(const std::basic_string<T> &in); |
|
||||
String_Strict(const T *in, size_t len); |
|
||||
String_Strict(const T *in); |
|
||||
String_Strict(const Jupiter::DataBuffer &in); |
|
||||
|
|
||||
/** Concatenation Constructors */ |
|
||||
String_Strict(const Readable_String<T> &lhs, const T &rhs); |
|
||||
String_Strict(const Readable_String<T> &lhs, const Readable_String<T> &rhs); |
|
||||
String_Strict(const Readable_String<T> &lhs, const std::basic_string<T> &rhs); |
|
||||
String_Strict(const Readable_String<T> &lhs, const T *rhs); |
|
||||
String_Strict(const Readable_String<T> &lhs, const T *rhs, size_t rhs_size); |
|
||||
|
|
||||
/** Addition Operators */ |
|
||||
inline String_Strict<T> operator+(const T &rhs) const; |
|
||||
inline String_Strict<T> operator+(const String_Strict<T> &rhs) const; |
|
||||
inline String_Strict<T> operator+(const Readable_String<T> &rhs) const; |
|
||||
inline String_Strict<T> operator+(const std::basic_string<T> &rhs) const; |
|
||||
inline String_Strict<T> operator+(const T *rhs) const; |
|
||||
|
|
||||
/** Assignment Operators */ |
|
||||
inline String_Strict<T> &operator=(const String_Strict<T> &right) { this->set(right); return *this; }; |
|
||||
inline String_Strict<T> &operator=(const Readable_String<T> &right) { this->set(right); return *this; }; |
|
||||
inline String_Strict<T> &operator=(const std::basic_string<T> &right) { this->set(right); return *this; }; |
|
||||
inline String_Strict<T> &operator=(const T *right) { this->set(right); return *this; }; |
|
||||
inline String_Strict<T> &operator=(const T right) { this->set(right); return *this; }; |
|
||||
}; |
|
||||
|
|
||||
/** String_Strict<T> Addition Operators */ |
|
||||
template<typename T> static inline Jupiter::String_Strict<T> operator+(const Jupiter::String_Type<T> &lhs, const Jupiter::String_Type<T> &rhs); |
|
||||
template<typename T> static inline Jupiter::String_Strict<T> operator+(const Jupiter::String_Type<T> &lhs, const T &rhs); |
|
||||
template<typename T> static inline Jupiter::String_Strict<T> operator+(const Jupiter::String_Type<T> &lhs, const Jupiter::String_Type<T> &rhs); |
|
||||
template<typename T> static inline Jupiter::String_Strict<T> operator+(const Jupiter::String_Type<T> &lhs, const std::basic_string<T> &rhs); |
|
||||
template<typename T> static inline Jupiter::String_Strict<T> operator+(const Jupiter::String_Type<T> &lhs, const std::basic_string_view<T> &rhs); |
|
||||
template<typename T> static inline Jupiter::String_Strict<T> operator+(const Jupiter::String_Type<T> &lhs, const T *rhs); |
|
||||
|
|
||||
/** Definition of a Strict String. */ |
|
||||
typedef String_Strict<char> StringS; |
|
||||
|
|
||||
/** Definition of a Loose String. */ |
|
||||
typedef String_Strict<char> StringL; |
|
||||
|
|
||||
/** Definition of a String. */ |
|
||||
typedef StringS String; |
|
||||
|
|
||||
namespace literals { |
|
||||
/** String_Strict literals */ |
|
||||
inline Jupiter::StringS operator""_jss(const char *str, size_t len) { return Jupiter::StringS(str, len); } |
|
||||
} |
|
||||
|
|
||||
template<typename CharT> |
|
||||
struct str_hash { |
|
||||
using is_transparent = std::true_type; |
|
||||
|
|
||||
// C++17 introduces a requirement that these two operators return the same values for same CharT type, but not
|
|
||||
// any requirement that std::hash<> be able to accept both key types. This just ties them for convenience
|
|
||||
auto operator()(std::basic_string_view<CharT> in_key) const noexcept { |
|
||||
return std::hash<std::basic_string_view<CharT>>()(in_key); |
|
||||
} |
|
||||
|
|
||||
auto operator()(const std::basic_string<CharT>& in_key) const noexcept { |
|
||||
return std::hash<std::basic_string<CharT>>()(in_key); |
|
||||
} |
|
||||
|
|
||||
// DEPRECATED:
|
|
||||
auto operator()(const String_Type<CharT>& in_key) const noexcept { |
|
||||
return operator()(static_cast<std::basic_string_view<CharT>>(in_key)); |
|
||||
} |
|
||||
}; |
|
||||
|
|
||||
using default_hash_function = str_hash<char>; |
|
||||
} |
|
||||
|
|
||||
/** Re-enable warning */ |
|
||||
#if defined _MSC_VER |
|
||||
#pragma warning(pop) |
|
||||
#endif |
|
||||
|
|
||||
/** Implementation for String_Strict and String_Loose. Very scary. */ |
|
||||
#include "String_Imp.h" |
|
||||
|
|
||||
#endif // _STRING_H_HEADER
|
|
||||
@ -1,250 +0,0 @@ |
|||||
/**
|
|
||||
* Copyright (C) 2013-2017 Jessica James. |
|
||||
* |
|
||||
* Permission to use, copy, modify, and/or distribute this software for any |
|
||||
* purpose with or without fee is hereby granted, provided that the above |
|
||||
* copyright notice and this permission notice appear in all copies. |
|
||||
* |
|
||||
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES |
|
||||
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF |
|
||||
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY |
|
||||
* SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES |
|
||||
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION |
|
||||
* OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN |
|
||||
* CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. |
|
||||
* |
|
||||
* Written by Jessica James <jessica.aj@outlook.com> |
|
||||
*/ |
|
||||
|
|
||||
#if !defined _STRING_IMP_H_HEADER |
|
||||
#define _STRING_IMP_H_HEADER |
|
||||
|
|
||||
/**
|
|
||||
* @file String_Imp.h |
|
||||
* @brief Provides the implementations for String_Strict and String_Loose. |
|
||||
*/ |
|
||||
|
|
||||
#include "String.hpp" |
|
||||
|
|
||||
/**
|
|
||||
* IMPLEMENTATION: |
|
||||
* String_Strict |
|
||||
*/ |
|
||||
|
|
||||
template<typename T> Jupiter::String_Strict<T>::String_Strict() |
|
||||
{ |
|
||||
} |
|
||||
|
|
||||
template<typename T> Jupiter::String_Strict<T>::String_Strict(size_t len) |
|
||||
{ |
|
||||
Jupiter::Shift_String_Type<T>::base = new T[len]; |
|
||||
Jupiter::String_Type<T>::str = Jupiter::Shift_String_Type<T>::base; |
|
||||
Jupiter::String_Type<T>::length = 0; |
|
||||
} |
|
||||
|
|
||||
template<typename T> Jupiter::String_Strict<T>::String_Strict(Jupiter::String_Strict<T> &&source) : Jupiter::Shift_String_Type<T>(std::move(source)) |
|
||||
{ |
|
||||
} |
|
||||
|
|
||||
template<typename T> Jupiter::String_Strict<T>::String_Strict(const Jupiter::String_Strict<T> &in) : Jupiter::String_Strict<T>::String_Strict( |
|
||||
in.data(), in.size()) |
|
||||
{ |
|
||||
} |
|
||||
|
|
||||
template<typename T> Jupiter::String_Strict<T>::String_Strict(const Jupiter::Readable_String<T> &in) : Jupiter::String_Strict<T>::String_Strict( |
|
||||
in.data(), in.size()) |
|
||||
{ |
|
||||
} |
|
||||
|
|
||||
template<typename T> Jupiter::String_Strict<T>::String_Strict(const std::basic_string<T> &in) : Jupiter::String_Strict<T>::String_Strict(in.data(), in.size()) |
|
||||
{ |
|
||||
} |
|
||||
|
|
||||
template<typename T> Jupiter::String_Strict<T>::String_Strict(const T *in, size_t len) : Jupiter::String_Strict<T>::String_Strict(len) |
|
||||
{ |
|
||||
while (Jupiter::String_Type<T>::length != len) |
|
||||
{ |
|
||||
Jupiter::String_Type<T>::str[Jupiter::String_Type<T>::length] = *in; |
|
||||
Jupiter::String_Type<T>::length++; |
|
||||
in++; |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
template<typename T> Jupiter::String_Strict<T>::String_Strict(const T *in) |
|
||||
{ |
|
||||
if (in == nullptr) Jupiter::String_Type<T>::length = 0; |
|
||||
else Jupiter::String_Type<T>::length = Jupiter::strlen<T>(in); |
|
||||
|
|
||||
Jupiter::Shift_String_Type<T>::base = new T[Jupiter::String_Type<T>::length]; |
|
||||
Jupiter::String_Type<T>::str = Jupiter::Shift_String_Type<T>::base; |
|
||||
for (size_t index = 0; index != Jupiter::String_Type<T>::length; index++, in++) Jupiter::String_Type<T>::str[index] = *in; |
|
||||
} |
|
||||
|
|
||||
template<typename T> Jupiter::String_Strict<T>::String_Strict(const Jupiter::DataBuffer &in) : String_Strict(reinterpret_cast<T *>(in.getHead()), in.size() / sizeof(T)) |
|
||||
{ |
|
||||
} |
|
||||
|
|
||||
template<typename T> Jupiter::String_Strict<T>::String_Strict(const Jupiter::Readable_String<T> &lhs, const T &rhs) : String_Strict<T>(lhs.size() + 1) |
|
||||
{ |
|
||||
const T *itr; |
|
||||
const T *end; |
|
||||
|
|
||||
if (!lhs.empty()) |
|
||||
{ |
|
||||
itr = lhs.data(); |
|
||||
end = itr + lhs.size(); |
|
||||
*Jupiter::String_Type<T>::str = *itr; |
|
||||
while (++itr != end) |
|
||||
*++Jupiter::String_Type<T>::str = *itr; |
|
||||
++Jupiter::String_Type<T>::str; |
|
||||
} |
|
||||
|
|
||||
*Jupiter::String_Type<T>::str = rhs; |
|
||||
|
|
||||
Jupiter::String_Type<T>::length = Jupiter::String_Type<T>::str - Jupiter::Shift_String_Type<T>::base + 1; |
|
||||
Jupiter::String_Type<T>::str = Jupiter::Shift_String_Type<T>::base; |
|
||||
} |
|
||||
|
|
||||
template<typename T> Jupiter::String_Strict<T>::String_Strict(const Jupiter::Readable_String<T> &lhs, const Jupiter::Readable_String<T> &rhs) : String_Strict<T>(lhs, |
|
||||
rhs.data(), rhs.size()) |
|
||||
{ |
|
||||
} |
|
||||
|
|
||||
template<typename T> Jupiter::String_Strict<T>::String_Strict(const Jupiter::Readable_String<T> &lhs, const std::basic_string<T> &rhs) : String_Strict<T>(lhs, rhs.data(), rhs.size()) |
|
||||
{ |
|
||||
} |
|
||||
|
|
||||
template<typename T> Jupiter::String_Strict<T>::String_Strict(const Jupiter::Readable_String<T> &lhs, const T *rhs) : String_Strict<T>(lhs, rhs, Jupiter::strlen<T>(rhs)) |
|
||||
{ |
|
||||
} |
|
||||
|
|
||||
template<typename T> Jupiter::String_Strict<T>::String_Strict(const Jupiter::Readable_String<T> &lhs, const T *rhs, size_t rhs_size) : String_Strict<T>(lhs.size() + rhs_size) |
|
||||
{ |
|
||||
const T *itr; |
|
||||
const T *end; |
|
||||
|
|
||||
if (!lhs.empty()) |
|
||||
{ |
|
||||
itr = lhs.data(); |
|
||||
end = itr + lhs.size(); |
|
||||
*Jupiter::String_Type<T>::str = *itr; |
|
||||
while (++itr != end) |
|
||||
*++Jupiter::String_Type<T>::str = *itr; |
|
||||
++Jupiter::String_Type<T>::str; |
|
||||
} |
|
||||
|
|
||||
if (rhs_size != 0) |
|
||||
{ |
|
||||
itr = rhs; |
|
||||
end = itr + rhs_size; |
|
||||
*Jupiter::String_Type<T>::str = *itr; |
|
||||
while (++itr != end) |
|
||||
*++Jupiter::String_Type<T>::str = *itr; |
|
||||
++Jupiter::String_Type<T>::str; |
|
||||
} |
|
||||
|
|
||||
Jupiter::String_Type<T>::length = Jupiter::String_Type<T>::str - Jupiter::Shift_String_Type<T>::base; |
|
||||
Jupiter::String_Type<T>::str = Jupiter::Shift_String_Type<T>::base; |
|
||||
} |
|
||||
|
|
||||
template<typename T> typename Jupiter::String_Strict<T> Jupiter::String_Strict<T>::substring(size_t pos) const |
|
||||
{ |
|
||||
return Jupiter::String_Strict<T>::substring(*this, pos); |
|
||||
} |
|
||||
|
|
||||
template<typename T> typename Jupiter::String_Strict<T> Jupiter::String_Strict<T>::substring(size_t pos, size_t len) const |
|
||||
{ |
|
||||
return Jupiter::String_Strict<T>::substring(*this, pos, len); |
|
||||
} |
|
||||
|
|
||||
template<typename T> typename Jupiter::String_Strict<T> Jupiter::String_Strict<T>::substring(const Jupiter::Readable_String<T> &in, size_t pos) |
|
||||
{ |
|
||||
return Jupiter::String_Type<T>::template substring<Jupiter::template String_Strict>(in, pos); |
|
||||
} |
|
||||
|
|
||||
template<typename T> typename Jupiter::String_Strict<T> Jupiter::String_Strict<T>::substring(const T *in, size_t pos) |
|
||||
{ |
|
||||
return Jupiter::String_Type<T>::template substring<Jupiter::template String_Strict>(in, pos); |
|
||||
} |
|
||||
|
|
||||
template<typename T> typename Jupiter::String_Strict<T> Jupiter::String_Strict<T>::substring(const Jupiter::Readable_String<T> &in, size_t pos, size_t len) |
|
||||
{ |
|
||||
return Jupiter::String_Type<T>::template substring<Jupiter::template String_Strict>(in, pos, len); |
|
||||
} |
|
||||
|
|
||||
template<typename T> typename Jupiter::String_Strict<T> Jupiter::String_Strict<T>::substring(const T *in, size_t pos, size_t len) |
|
||||
{ |
|
||||
return Jupiter::String_Type<T>::template substring<Jupiter::template String_Strict>(in, pos, len); |
|
||||
} |
|
||||
|
|
||||
// Operators
|
|
||||
|
|
||||
template<typename T> inline Jupiter::String_Strict<T> Jupiter::String_Strict<T>::operator+(const T &rhs) const |
|
||||
{ |
|
||||
return Jupiter::operator+(*this, rhs); |
|
||||
} |
|
||||
|
|
||||
template<typename T> inline Jupiter::String_Strict<T> Jupiter::String_Strict<T>::operator+(const Jupiter::String_Strict<T> &rhs) const |
|
||||
{ |
|
||||
return Jupiter::String_Strict<T>::operator+(reinterpret_cast<const Jupiter::Readable_String<T> &>(rhs)); |
|
||||
} |
|
||||
|
|
||||
template<typename T> inline Jupiter::String_Strict<T> Jupiter::String_Strict<T>::operator+(const Jupiter::Readable_String<T> &rhs) const |
|
||||
{ |
|
||||
return Jupiter::operator+(*this, rhs); |
|
||||
} |
|
||||
|
|
||||
template<typename T> inline Jupiter::String_Strict<T> Jupiter::String_Strict<T>::operator+(const std::basic_string<T> &rhs) const |
|
||||
{ |
|
||||
return Jupiter::operator+(*this, rhs); |
|
||||
} |
|
||||
|
|
||||
template<typename T> inline Jupiter::String_Strict<T> Jupiter::String_Strict<T>::operator+(const T *rhs) const |
|
||||
{ |
|
||||
return Jupiter::operator+(*this, rhs); |
|
||||
} |
|
||||
|
|
||||
template<typename T> static inline Jupiter::String_Strict<T> Jupiter::operator+(const Jupiter::String_Type<T> &lhs, const T &rhs) |
|
||||
{ |
|
||||
return Jupiter::String_Strict<T>(lhs, rhs); |
|
||||
} |
|
||||
|
|
||||
template<typename T> static inline Jupiter::String_Strict<T> Jupiter::operator+(const Jupiter::String_Type<T> &lhs, const Jupiter::String_Type<T> &rhs) |
|
||||
{ |
|
||||
return Jupiter::String_Strict<T>(lhs, rhs); |
|
||||
} |
|
||||
|
|
||||
template<typename T> static inline Jupiter::String_Strict<T> Jupiter::operator+(const Jupiter::String_Type<T> &lhs, const std::basic_string<T> &rhs) |
|
||||
{ |
|
||||
return Jupiter::String_Strict<T>(lhs, rhs); |
|
||||
} |
|
||||
|
|
||||
template<typename T> static inline Jupiter::String_Strict<T> Jupiter::operator+(const Jupiter::String_Type<T> &lhs, const std::basic_string_view<T> &rhs) |
|
||||
{ |
|
||||
return Jupiter::String_Strict<T>(lhs, rhs); |
|
||||
} |
|
||||
|
|
||||
template<typename T> static inline Jupiter::String_Strict<T> Jupiter::operator+(const Jupiter::String_Type<T> &lhs, const T *rhs) |
|
||||
{ |
|
||||
return Jupiter::String_Strict<T>(lhs, rhs); |
|
||||
} |
|
||||
|
|
||||
// Jupiter::DataBuffer specialization
|
|
||||
|
|
||||
template<> struct _Jupiter_DataBuffer_partial_specialization_impl<Jupiter::String_Strict> |
|
||||
{ |
|
||||
template<typename Y> static void push(Jupiter::DataBuffer *buffer, const Jupiter::String_Strict<Y> *data) { |
|
||||
_Jupiter_DataBuffer_partial_specialization_impl<Jupiter::String_Type>::push<Y>(buffer, data); |
|
||||
}; |
|
||||
|
|
||||
template<typename Y> static Jupiter::String_Strict<Y> interpret(uint8_t *&head) |
|
||||
{ |
|
||||
size_t size_ = *reinterpret_cast<size_t *>(head); |
|
||||
head += sizeof(size_t); |
|
||||
Jupiter::String_Strict<Y> r = Jupiter::String_Strict<Y>(reinterpret_cast<Y *>(head), size_); |
|
||||
head += size_; |
|
||||
return r; |
|
||||
} |
|
||||
}; |
|
||||
|
|
||||
#endif // _STRING_IMP_H_HEADER
|
|
||||
@ -1,326 +0,0 @@ |
|||||
/**
|
|
||||
* Copyright (C) 2013-2015 Jessica James. |
|
||||
* |
|
||||
* Permission to use, copy, modify, and/or distribute this software for any |
|
||||
* purpose with or without fee is hereby granted, provided that the above |
|
||||
* copyright notice and this permission notice appear in all copies. |
|
||||
* |
|
||||
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES |
|
||||
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF |
|
||||
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY |
|
||||
* SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES |
|
||||
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION |
|
||||
* OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN |
|
||||
* CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. |
|
||||
* |
|
||||
* Written by Jessica James <jessica.aj@outlook.com> |
|
||||
*/ |
|
||||
|
|
||||
#if !defined _STRING_TYPE_H_HEADER |
|
||||
#define _STRING_TYPE_H_HEADER |
|
||||
|
|
||||
/**
|
|
||||
* @file String_Type.h |
|
||||
* @brief Provides the basis for String types, of any implementation. |
|
||||
* 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 <cstdarg> // va_list |
|
||||
#include "Readable_String.h" |
|
||||
|
|
||||
/** Disable warning 4458 */ |
|
||||
#if defined _MSC_VER |
|
||||
#pragma warning(push) |
|
||||
#pragma warning(disable: 4458) // declaration of 'length' hides class member
|
|
||||
#endif |
|
||||
|
|
||||
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<typename T = char> class String_Type |
|
||||
{ |
|
||||
public: |
|
||||
|
|
||||
/**
|
|
||||
* @brief Returns the number of elements in the String. |
|
||||
* |
|
||||
* @return Number of elements in the string. |
|
||||
*/ |
|
||||
size_t size() const; |
|
||||
|
|
||||
/**
|
|
||||
* @brief Returns the maximum number of elements the String can contain, |
|
||||
* without expanding the socket buffer. This is generally the size of the |
|
||||
* underlying memory buffer. |
|
||||
* |
|
||||
* @return Number of elements the string can contain without reallocation. |
|
||||
*/ |
|
||||
virtual size_t capacity() const; |
|
||||
|
|
||||
/**
|
|
||||
* @brief Returns a pointer to the underlying string of elements. |
|
||||
* |
|
||||
* @return Pointer to the underlying string of elements. |
|
||||
*/ |
|
||||
const T *data() const; |
|
||||
|
|
||||
/**
|
|
||||
* @brief Truncates the string by a specified number of elements. |
|
||||
* |
|
||||
* @param n Number of elements to remove from the tail. |
|
||||
* @return New size of the String. |
|
||||
*/ |
|
||||
virtual size_t truncate(size_t n); |
|
||||
|
|
||||
/**
|
|
||||
* @brief Removes the first instance of an element from the string. |
|
||||
* |
|
||||
* @param value Value of the element to remove. |
|
||||
* @return True if an element was removed, false otherwise. |
|
||||
*/ |
|
||||
virtual bool remove(const T &value); |
|
||||
|
|
||||
/**
|
|
||||
* @brief Removes a number of elements starting at an index. |
|
||||
* |
|
||||
* @param index Index to start removing elements at. |
|
||||
* @param length Number of elements to remove. |
|
||||
*/ |
|
||||
virtual void remove(size_t index, size_t length); |
|
||||
|
|
||||
/**
|
|
||||
* @brief Removes all elements from the string. |
|
||||
*/ |
|
||||
virtual void clear(); |
|
||||
|
|
||||
/**
|
|
||||
* @brief Sets the value of an element at the specified index. |
|
||||
* Note: If the index is not in the string, it will be added. |
|
||||
* |
|
||||
* @param index Index of element to replace. |
|
||||
* @param in Value to set element to. |
|
||||
* @return New size of the String. |
|
||||
*/ |
|
||||
virtual size_t set(size_t index, const T &in); |
|
||||
virtual size_t set(size_t index, const T *in, size_t inSize); |
|
||||
virtual size_t set(size_t index, const Jupiter::Readable_String<T> &in); |
|
||||
virtual size_t set(size_t index, const std::basic_string<T> &in); |
|
||||
virtual size_t set(size_t index, const T *in); |
|
||||
|
|
||||
/**
|
|
||||
* @brief Copies the data from the input string to the String. |
|
||||
* |
|
||||
* @param in String containing the data to be copied. |
|
||||
* @return New size of the String. |
|
||||
*/ |
|
||||
virtual size_t set(const T *in, size_t inSize); |
|
||||
virtual size_t set(const Jupiter::Readable_String<T> &in); |
|
||||
virtual size_t set(const std::basic_string<T> &in); |
|
||||
virtual size_t set(const T *in); |
|
||||
virtual size_t set(const T &in); |
|
||||
|
|
||||
/**
|
|
||||
* @brief Inserts data into a position in the string. |
|
||||
* |
|
||||
* @param index Index to insert data to. |
|
||||
* @param value Value to insert. |
|
||||
*/ |
|
||||
virtual size_t insert(size_t index, const T &value); |
|
||||
virtual size_t insert(size_t index, const Jupiter::Readable_String<T> &value); |
|
||||
|
|
||||
/**
|
|
||||
* @brief Replaces data at an index with a specified value. |
|
||||
* |
|
||||
* @param index Index to start replacing at. |
|
||||
* @param length Number of elements to replace. |
|
||||
* @param value Value to write over the elements. |
|
||||
* @return New size of the string. |
|
||||
*/ |
|
||||
virtual size_t replace(size_t index, size_t length, const T &value); |
|
||||
virtual size_t replace(size_t index, size_t length, const T *value, size_t valueSize); |
|
||||
virtual size_t replace(size_t index, size_t length, std::basic_string_view<T> value); |
|
||||
|
|
||||
/**
|
|
||||
* @brief Replaces all instances of one value with another value. |
|
||||
* |
|
||||
* @param target Target to search for and replace. |
|
||||
* @param value Value to replace the target with. |
|
||||
* @return New size of the string. |
|
||||
*/ |
|
||||
virtual size_t replace(const T &target, const T &value); |
|
||||
virtual size_t replace(const T *target, size_t targetSize, const T &value); |
|
||||
virtual size_t replace(const Jupiter::Readable_String<T> &target, const T &value); |
|
||||
|
|
||||
virtual size_t replace(const T *target, size_t targetSize, const T *value, size_t valueSize); |
|
||||
virtual size_t replace(const T *target, size_t targetSize, const Jupiter::Readable_String<T> &value); |
|
||||
virtual size_t replace(const Jupiter::Readable_String<T> &target, const T *value, size_t valueSize); |
|
||||
virtual size_t replace(std::basic_string_view<T> target, std::basic_string_view<T> value); |
|
||||
|
|
||||
/**
|
|
||||
* @brief Copies the data from the input string and concatenates it to the end of String. |
|
||||
* |
|
||||
* @param in String containing the data to be concatenated. |
|
||||
* @return New size of the String. |
|
||||
*/ |
|
||||
virtual size_t concat(const T *in, size_t inSize); |
|
||||
virtual size_t concat(const Jupiter::Readable_String<T> &in); |
|
||||
virtual size_t concat(const std::basic_string<T> &in); |
|
||||
virtual size_t concat(const T *in); |
|
||||
virtual size_t concat(const T &in); |
|
||||
|
|
||||
/**
|
|
||||
* @brief Copies a part of an input string and returns it in an output type. |
|
||||
* |
|
||||
* @param R Type to return. Must be a subclass of String_Type. |
|
||||
* |
|
||||
* @param in String to get a partial copy of. |
|
||||
* @param pos Position to start copying from. |
|
||||
* @return Partial copy of the input string. |
|
||||
*/ |
|
||||
template<template<typename> class R> static R<T> substring(const Jupiter::Readable_String<T> &in, size_t pos); // REPLACE
|
|
||||
template<template<typename> class R> static R<T> substring(const T *in, size_t pos); // REPLACE
|
|
||||
|
|
||||
/**
|
|
||||
* @brief Copies a part of an input string and returns it in an output type. |
|
||||
* |
|
||||
* @param R Type to return. Must be a subclass of String_Type. |
|
||||
* |
|
||||
* @param in String to get a partial copy of. |
|
||||
* @param pos Position to start copying from. |
|
||||
* @param len Number of elements to copy. |
|
||||
* @return Partial copy of the input string. |
|
||||
*/ |
|
||||
template<template<typename> class R> static R<T> substring(const Jupiter::Readable_String<T> &in, size_t pos, size_t len); // REPLACE
|
|
||||
template<template<typename> class R> static R<T> substring(const T *in, size_t pos, size_t len); // REPLACE
|
|
||||
|
|
||||
/** Mutative operators */ |
|
||||
inline String_Type<T> &operator+=(const String_Type<T> &right) { this->concat(right); return *this; }; |
|
||||
inline String_Type<T> &operator+=(const std::basic_string<T> &right) { this->concat(right); return *this; }; |
|
||||
inline String_Type<T> &operator+=(const std::basic_string_view<T> &right) { this->concat(right); return *this; }; |
|
||||
inline String_Type<T> &operator+=(const T *right) { this->concat(right); return *this; }; |
|
||||
inline String_Type<T> &operator+=(const T right) { this->concat(right); return *this; }; |
|
||||
inline String_Type<T> &operator-=(size_t right) { this->truncate(right); return *this; }; |
|
||||
inline String_Type<T> &operator=(const String_Type<T> &right) { this->set(right); return *this; }; |
|
||||
inline String_Type<T> &operator=(const std::basic_string<T> &right) { this->set(right); return *this; }; |
|
||||
inline String_Type<T> &operator=(const std::basic_string_view<T> &right) { this->set(right.data(), right.size()); return *this; }; |
|
||||
inline String_Type<T> &operator=(const T *right) { this->set(right); return *this; }; |
|
||||
inline String_Type<T> &operator=(const T right) { this->set(right); return *this; }; |
|
||||
|
|
||||
/**
|
|
||||
* @brief Default constructor for the String_Type class. |
|
||||
*/ |
|
||||
String_Type() {} |
|
||||
|
|
||||
/**
|
|
||||
* @brief Move constructor for the String_Type class. |
|
||||
*/ |
|
||||
String_Type(Jupiter::String_Type<T> &&source); |
|
||||
|
|
||||
/**
|
|
||||
* The following constructors should exist: |
|
||||
* A default constructor |
|
||||
* A copy constructor for the same class. |
|
||||
* A copy constructor for Readable_String. |
|
||||
* A copy constructor for std::basic_string<T>. |
|
||||
* A copy constructor for C-style strings. |
|
||||
* A copy constructor for memory array strings. |
|
||||
* A conversion constructor for Jupiter::DataBuffer |
|
||||
*/ |
|
||||
|
|
||||
/**
|
|
||||
* @brief Destructor for the String_Type class. |
|
||||
*/ |
|
||||
virtual ~String_Type() = default; |
|
||||
|
|
||||
/**
|
|
||||
* Necessities when removing Readable_String & Reference_String |
|
||||
*/ |
|
||||
bool empty() const { return size() == 0; }; // KEEP
|
|
||||
|
|
||||
/** Access operator */ |
|
||||
inline const T &operator[](size_t index) const { return this->data()[index]; }; |
|
||||
|
|
||||
/** Conversion operators */ |
|
||||
explicit inline operator std::basic_string<T>() const { return std::basic_string<T>(this->data(), this->size()); } |
|
||||
inline operator std::basic_string_view<T>() const { return std::basic_string_view<T>(this->data(), this->size()); } |
|
||||
|
|
||||
/** Comparative operators */ |
|
||||
inline bool operator==(const String_Type<T>& right)const{ return operator==(std::basic_string_view<T>{right}); } |
|
||||
inline bool operator==(const std::basic_string<T>& right)const{ return operator==(std::basic_string_view<T>{right}); } |
|
||||
inline bool operator==(const std::basic_string_view<T>& right)const{ return std::basic_string_view<T>(data(), size()) == right; } |
|
||||
inline bool operator==(const T right)const{ return this->size() == 1 && this->get(0) == right; } |
|
||||
inline bool operator==(std::nullptr_t) = delete; |
|
||||
inline bool operator!=(const String_Type<T> &right)const{ return !operator==(right); } |
|
||||
inline bool operator!=(const std::basic_string<T> &right)const{ return !operator==(right); } |
|
||||
inline bool operator!=(const T right)const{ return !operator==(right); } |
|
||||
inline bool operator!=(std::nullptr_t) = delete; |
|
||||
inline bool operator<(const String_Type<T> &right)const{ return this->compare(right) < 0; } |
|
||||
inline bool operator<(const std::basic_string<T> &right)const{ return this->compare(right) < 0; } |
|
||||
inline bool operator<(const T right)const{ return this->compare(right) < 0; } |
|
||||
inline bool operator>(const String_Type<T> &right)const{ return this->compare(right) > 0; } |
|
||||
inline bool operator>(const std::basic_string<T> &right)const{ return this->compare(right) > 0; } |
|
||||
inline bool operator>(const T right)const{ return this->compare(right) > 0; } |
|
||||
inline bool operator<=(const String_Type<T> &right)const{ return !operator>(right); } |
|
||||
inline bool operator<=(const std::basic_string<T> &right)const{ return !operator>(right); } |
|
||||
inline bool operator<=(const T right)const{ return !operator>(right); } |
|
||||
inline bool operator>=(const String_Type<T> &right)const{ return !operator<(right); } |
|
||||
inline bool operator>=(const std::basic_string<T> &right)const{ return !operator<(right); } |
|
||||
inline bool operator>=(const T right)const{ return !operator<(right); } |
|
||||
|
|
||||
protected: // Things which cannot be removed right now
|
|
||||
T *str{}; /** Pointer for the underlying string of elements */ |
|
||||
size_t length{}; /** Number of representable elements in the string */ |
|
||||
|
|
||||
/**
|
|
||||
* @brief Sets the internal buffer to be at least large enough to old a specified number of elements. |
|
||||
* Note: This does nothing if len is less than the string's current length. |
|
||||
* |
|
||||
* @param len Minimum number of elements the string buffer must be able to hold. |
|
||||
* @return True if a new buffer was allocated, false otherwise. |
|
||||
*/ |
|
||||
virtual bool setBufferSize(size_t len) = 0; |
|
||||
|
|
||||
/**
|
|
||||
* @brief Empties the string, and sets the internal buffer to be at least large enough to old a specified number of elements. |
|
||||
* Note: This does nothing if len is less than the string's current length. |
|
||||
* |
|
||||
* @param len Minimum number of elements the string buffer must be able to hold. |
|
||||
* @return True if a new buffer was allocated, false otherwise. |
|
||||
*/ |
|
||||
virtual bool setBufferSizeNoCopy(size_t len) = 0; |
|
||||
}; |
|
||||
|
|
||||
namespace literals { |
|
||||
// Not truly a literal, but I just want this available in places I'm using literals
|
|
||||
template<typename T> |
|
||||
static inline std::basic_string<T> operator+(std::basic_string<T> lhs, std::basic_string_view<T> rhs) { |
|
||||
lhs += rhs; |
|
||||
return lhs; |
|
||||
} |
|
||||
|
|
||||
template<typename T> |
|
||||
static inline std::basic_string<T> operator+(std::basic_string<T> lhs, const String_Type<T>& rhs) { |
|
||||
lhs += std::basic_string_view<T>{rhs}; |
|
||||
return lhs; |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
/** Generic String Type */ |
|
||||
typedef String_Type<char> StringType; |
|
||||
} |
|
||||
|
|
||||
/** Re-enable warning */ |
|
||||
#if defined _MSC_VER |
|
||||
#pragma warning(pop) |
|
||||
#endif |
|
||||
|
|
||||
/** Implementation for String_Type. */ |
|
||||
#include "String_Type_Imp.h" |
|
||||
|
|
||||
#endif // _STRING_TYPE_H_HEADER
|
|
||||
@ -1,593 +0,0 @@ |
|||||
/**
|
|
||||
* Copyright (C) 2014-2016 Jessica James. |
|
||||
* |
|
||||
* Permission to use, copy, modify, and/or distribute this software for any |
|
||||
* purpose with or without fee is hereby granted, provided that the above |
|
||||
* copyright notice and this permission notice appear in all copies. |
|
||||
* |
|
||||
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES |
|
||||
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF |
|
||||
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY |
|
||||
* SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES |
|
||||
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION |
|
||||
* OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN |
|
||||
* CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. |
|
||||
* |
|
||||
* Written by Jessica James <jessica.aj@outlook.com> |
|
||||
*/ |
|
||||
|
|
||||
#if !defined _STRING_TYPE_IMP_H_HEADER |
|
||||
#define _STRING_TYPE_IMP_H_HEADER |
|
||||
|
|
||||
/**
|
|
||||
* @file String_Type_Imp.h |
|
||||
* @brief Provides the implementations for String_Type functions. |
|
||||
* Note: Modification of this file is not supported in any way. |
|
||||
*/ |
|
||||
|
|
||||
#include "String_Type.h" |
|
||||
#include "Functions.h" |
|
||||
|
|
||||
/**
|
|
||||
* IMPLEMENTATION: |
|
||||
* String_Type |
|
||||
*/ |
|
||||
|
|
||||
template<typename T> Jupiter::String_Type<T>::String_Type(Jupiter::String_Type<T> &&source) |
|
||||
{ |
|
||||
Jupiter::String_Type<T>::str = source.str; |
|
||||
Jupiter::String_Type<T>::length = source.length; |
|
||||
source.length = 0; |
|
||||
source.str = nullptr; |
|
||||
} |
|
||||
|
|
||||
template<typename T> size_t Jupiter::String_Type<T>::size() const |
|
||||
{ |
|
||||
return Jupiter::String_Type<T>::length; |
|
||||
} |
|
||||
|
|
||||
template<typename T> size_t Jupiter::String_Type<T>::capacity() const |
|
||||
{ |
|
||||
return this->size(); |
|
||||
} |
|
||||
|
|
||||
template<typename T> const T *Jupiter::String_Type<T>::data() const |
|
||||
{ |
|
||||
return Jupiter::String_Type<T>::str; |
|
||||
} |
|
||||
|
|
||||
// truncate base
|
|
||||
|
|
||||
template<typename T> size_t Jupiter::String_Type<T>::truncate(size_t n) |
|
||||
{ |
|
||||
if (n >= Jupiter::String_Type<T>::length) return (Jupiter::String_Type<T>::length = 0); |
|
||||
return (Jupiter::String_Type<T>::length -= n); |
|
||||
} |
|
||||
|
|
||||
// remove base
|
|
||||
|
|
||||
template<typename T> bool Jupiter::String_Type<T>::remove(const T &value) |
|
||||
{ |
|
||||
for (size_t i = 0; i < Jupiter::String_Type<T>::length - 1; i++) |
|
||||
{ |
|
||||
if (Jupiter::String_Type<T>::str[i] == value) |
|
||||
{ |
|
||||
while (i < Jupiter::String_Type<T>::length) |
|
||||
{ |
|
||||
i++; |
|
||||
Jupiter::String_Type<T>::str[i - 1] = Jupiter::String_Type<T>::str[i]; |
|
||||
} |
|
||||
Jupiter::String_Type<T>::length--; |
|
||||
return true; |
|
||||
} |
|
||||
} |
|
||||
if (Jupiter::String_Type<T>::str[Jupiter::String_Type<T>::length - 1] == value) |
|
||||
{ |
|
||||
this->truncate(1); |
|
||||
return true; |
|
||||
} |
|
||||
return false; |
|
||||
} |
|
||||
|
|
||||
template<typename T> void Jupiter::String_Type<T>::remove(size_t index, size_t len) |
|
||||
{ |
|
||||
if (index >= Jupiter::String_Type<T>::length) |
|
||||
return; |
|
||||
|
|
||||
if (index + len >= Jupiter::String_Type<T>::length) |
|
||||
Jupiter::String_Type<T>::length = index; |
|
||||
else |
|
||||
{ |
|
||||
Jupiter::String_Type<T>::length -= len; |
|
||||
len += index; |
|
||||
|
|
||||
Jupiter::String_Type<T>::str[index] = Jupiter::String_Type<T>::str[len]; |
|
||||
while (++index != Jupiter::String_Type<T>::length) |
|
||||
Jupiter::String_Type<T>::str[index] = Jupiter::String_Type<T>::str[++len]; |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
// erase
|
|
||||
|
|
||||
template<typename T> void Jupiter::String_Type<T>::clear() |
|
||||
{ |
|
||||
Jupiter::String_Type<T>::length = 0; |
|
||||
} |
|
||||
|
|
||||
// set
|
|
||||
|
|
||||
template<typename T> size_t Jupiter::String_Type<T>::set(size_t index, const T &in) |
|
||||
{ |
|
||||
if (index == Jupiter::String_Type<T>::length) |
|
||||
return this->concat(in); |
|
||||
|
|
||||
if (index > Jupiter::String_Type<T>::length) |
|
||||
{ |
|
||||
this->setBufferSize(index + 1); |
|
||||
while (Jupiter::String_Type<T>::length != index) |
|
||||
Jupiter::String_Type<T>::str[Jupiter::String_Type<T>::length++] = 0; |
|
||||
Jupiter::String_Type<T>::length++; |
|
||||
} |
|
||||
Jupiter::String_Type<T>::str[index] = in; |
|
||||
return Jupiter::String_Type<T>::length; |
|
||||
} |
|
||||
|
|
||||
template<typename T> size_t Jupiter::String_Type<T>::set(size_t index, const T *in, size_t inSize) |
|
||||
{ |
|
||||
if (index == Jupiter::String_Type<T>::length) |
|
||||
return this->concat(in); |
|
||||
|
|
||||
if (index > Jupiter::String_Type<T>::length) |
|
||||
{ |
|
||||
this->setBufferSize(index + inSize); |
|
||||
while (Jupiter::String_Type<T>::length != index) |
|
||||
Jupiter::String_Type<T>::str[Jupiter::String_Type<T>::length++] = 0; |
|
||||
index = 0; |
|
||||
while (index != inSize) |
|
||||
Jupiter::String_Type<T>::str[Jupiter::String_Type<T>::length++] = in[index]; |
|
||||
} |
|
||||
else |
|
||||
{ |
|
||||
index += inSize; |
|
||||
if (index > Jupiter::String_Type<T>::length) |
|
||||
{ |
|
||||
this->setBufferSize(index); |
|
||||
Jupiter::String_Type<T>::length = index; |
|
||||
} |
|
||||
while (inSize != 0) |
|
||||
Jupiter::String_Type<T>::str[--index] = in[--inSize]; |
|
||||
} |
|
||||
return Jupiter::String_Type<T>::length; |
|
||||
} |
|
||||
|
|
||||
template<typename T> size_t Jupiter::String_Type<T>::set(size_t index, const Jupiter::Readable_String<T> &in) |
|
||||
{ |
|
||||
return this->set(index, in.data(), in.size()); |
|
||||
} |
|
||||
|
|
||||
template<typename T> size_t Jupiter::String_Type<T>::set(size_t index, const std::basic_string<T> &in) |
|
||||
{ |
|
||||
return this->set(index, in.c_str(), in.size()); |
|
||||
} |
|
||||
|
|
||||
template<typename T> size_t Jupiter::String_Type<T>::set(size_t index, const T *in) |
|
||||
{ |
|
||||
return this->set(index, in, Jupiter::strlen<T>(in)); |
|
||||
} |
|
||||
|
|
||||
template<typename T> size_t Jupiter::String_Type<T>::set(const T *in, size_t inSize) |
|
||||
{ |
|
||||
this->setBufferSizeNoCopy(inSize); |
|
||||
Jupiter::String_Type<T>::length = inSize; |
|
||||
while (inSize-- != 0) |
|
||||
*Jupiter::String_Type<T>::str++ = *in++; |
|
||||
Jupiter::String_Type<T>::str -= Jupiter::String_Type<T>::length; |
|
||||
return Jupiter::String_Type<T>::length; |
|
||||
} |
|
||||
|
|
||||
template<typename T> size_t Jupiter::String_Type<T>::set(const Jupiter::Readable_String<T> &in) |
|
||||
{ |
|
||||
return this->set(in.data(), in.size()); |
|
||||
} |
|
||||
|
|
||||
template<typename T> size_t Jupiter::String_Type<T>::set(const std::basic_string<T> &in) |
|
||||
{ |
|
||||
return this->set(in.c_str(), in.size()); |
|
||||
} |
|
||||
|
|
||||
template<typename T> size_t Jupiter::String_Type<T>::set(const T *in) |
|
||||
{ |
|
||||
return this->set(in, Jupiter::strlen<T>(in)); |
|
||||
} |
|
||||
|
|
||||
template<typename T> size_t Jupiter::String_Type<T>::set(const T &in) |
|
||||
{ |
|
||||
this->setBufferSizeNoCopy(1); |
|
||||
*Jupiter::String_Type<T>::str = in; |
|
||||
return Jupiter::String_Type<T>::length = 1; |
|
||||
} |
|
||||
|
|
||||
// insert
|
|
||||
|
|
||||
template<typename T> size_t Jupiter::String_Type<T>::insert(size_t index, const T &value) |
|
||||
{ |
|
||||
if (index >= Jupiter::String_Type<T>::length) |
|
||||
return this->concat(value); |
|
||||
|
|
||||
this->setBufferSize(Jupiter::String_Type<T>::length + 1); |
|
||||
for (size_t i = Jupiter::String_Type<T>::length; i != index; i--) |
|
||||
Jupiter::String_Type<T>::str[i] = operator[](i-1); |
|
||||
|
|
||||
Jupiter::String_Type<T>::str[index] = value; |
|
||||
return ++Jupiter::String_Type<T>::length; |
|
||||
} |
|
||||
|
|
||||
template<typename T> size_t Jupiter::String_Type<T>::insert(size_t index, const Jupiter::Readable_String<T> &value) |
|
||||
{ |
|
||||
if (index >= Jupiter::String_Type<T>::length) |
|
||||
return this->concat(value); |
|
||||
|
|
||||
if (value.empty()) |
|
||||
return Jupiter::String_Type<T>::length; |
|
||||
|
|
||||
if (value.size() == 1) |
|
||||
return this->insert(index, value[0]); |
|
||||
|
|
||||
this->setBufferSize(Jupiter::String_Type<T>::length + value.size()); |
|
||||
size_t i; |
|
||||
for (i = Jupiter::String_Type<T>::length + value.size() - 1; i != index + value.size() - 1; i--) |
|
||||
Jupiter::String_Type<T>::str[i] = operator[](i - value.size()); |
|
||||
|
|
||||
while (i != index) |
|
||||
{ |
|
||||
Jupiter::String_Type<T>::str[i] = value[i - index]; |
|
||||
i--; |
|
||||
} |
|
||||
Jupiter::String_Type<T>::str[index] = value[0]; |
|
||||
|
|
||||
return Jupiter::String_Type<T>::length += value.size(); |
|
||||
} |
|
||||
|
|
||||
// replace
|
|
||||
|
|
||||
template<typename T> size_t Jupiter::String_Type<T>::replace(size_t index, size_t targetSize, const T &value) |
|
||||
{ |
|
||||
if (targetSize != 0) |
|
||||
{ |
|
||||
if (index >= Jupiter::String_Type<T>::length) |
|
||||
return this->set(index, value); |
|
||||
|
|
||||
if (index + targetSize > Jupiter::String_Type<T>::length) |
|
||||
{ |
|
||||
Jupiter::String_Type<T>::str[index] = value; |
|
||||
return Jupiter::String_Type<T>::length = index + 1; |
|
||||
} |
|
||||
|
|
||||
if (targetSize == 1) |
|
||||
return this->set(index, value); |
|
||||
|
|
||||
Jupiter::String_Type<T>::str[index] = value; |
|
||||
Jupiter::String_Type<T>::length -= targetSize - 1; |
|
||||
while (++index != Jupiter::String_Type<T>::length) |
|
||||
Jupiter::String_Type<T>::str[index] = Jupiter::String_Type<T>::str[index + targetSize - 1]; |
|
||||
} |
|
||||
return Jupiter::String_Type<T>::length; |
|
||||
} |
|
||||
|
|
||||
template<typename T> size_t Jupiter::String_Type<T>::replace(size_t index, size_t targetSize, const T *value, size_t valueSize) |
|
||||
{ |
|
||||
if (valueSize == 1) |
|
||||
return this->replace(index, targetSize, *value); |
|
||||
|
|
||||
if (valueSize == 0) |
|
||||
{ |
|
||||
this->remove(index, targetSize); |
|
||||
return Jupiter::String_Type<T>::length; |
|
||||
} |
|
||||
|
|
||||
if (targetSize != 0) |
|
||||
{ |
|
||||
if (index >= Jupiter::String_Type<T>::length) |
|
||||
return this->set(index, value); |
|
||||
|
|
||||
if (index + targetSize > Jupiter::String_Type<T>::length) |
|
||||
{ |
|
||||
if (index + valueSize > Jupiter::String_Type<T>::length) |
|
||||
this->setBufferSize(index + valueSize); |
|
||||
|
|
||||
Jupiter::String_Type<T>::length = index + valueSize; |
|
||||
Jupiter::String_Type<T>::str[index] = *value; |
|
||||
while (++index != Jupiter::String_Type<T>::length) |
|
||||
Jupiter::String_Type<T>::str[index] = *++value; |
|
||||
return Jupiter::String_Type<T>::length; |
|
||||
} |
|
||||
|
|
||||
if (targetSize == valueSize) |
|
||||
return this->set(index, value, valueSize); |
|
||||
|
|
||||
if (valueSize < targetSize) |
|
||||
{ |
|
||||
targetSize -= valueSize; |
|
||||
Jupiter::String_Type<T>::length -= targetSize; |
|
||||
|
|
||||
Jupiter::String_Type<T>::str[index] = *value; |
|
||||
while (--valueSize != 0) |
|
||||
Jupiter::String_Type<T>::str[++index] = *++value; |
|
||||
|
|
||||
while (++index != Jupiter::String_Type<T>::length) |
|
||||
Jupiter::String_Type<T>::str[index] = Jupiter::String_Type<T>::str[index + targetSize]; |
|
||||
} |
|
||||
else |
|
||||
{ |
|
||||
size_t i = Jupiter::String_Type<T>::length; |
|
||||
valueSize -= targetSize; |
|
||||
this->setBufferSize(Jupiter::String_Type<T>::length + valueSize); |
|
||||
Jupiter::String_Type<T>::length += valueSize; |
|
||||
|
|
||||
index += targetSize; |
|
||||
while (i-- != index) |
|
||||
Jupiter::String_Type<T>::str[i + valueSize] = Jupiter::String_Type<T>::str[i]; |
|
||||
index -= targetSize; |
|
||||
valueSize += targetSize; |
|
||||
|
|
||||
Jupiter::String_Type<T>::str[index] = *value; |
|
||||
while (--valueSize != 0) |
|
||||
Jupiter::String_Type<T>::str[++index] = *++value; |
|
||||
} |
|
||||
} |
|
||||
return Jupiter::String_Type<T>::length; |
|
||||
} |
|
||||
|
|
||||
template<typename T> size_t Jupiter::String_Type<T>::replace(size_t index, size_t targetSize, std::basic_string_view<T> value) { |
|
||||
return this->replace(index, targetSize, value.data(), value.size()); |
|
||||
} |
|
||||
|
|
||||
template<typename T> size_t Jupiter::String_Type<T>::replace(const T &target, const T &value) |
|
||||
{ |
|
||||
for (size_t i = 0; i != Jupiter::String_Type<T>::length; i++) |
|
||||
{ |
|
||||
if (operator[](i) == target) |
|
||||
Jupiter::String_Type<T>::str[i] = value; |
|
||||
} |
|
||||
return Jupiter::String_Type<T>::length; |
|
||||
} |
|
||||
|
|
||||
template<typename T> size_t Jupiter::String_Type<T>::replace(const T *target, size_t targetSize, const T &value) |
|
||||
{ |
|
||||
if (targetSize != 0) |
|
||||
{ |
|
||||
if (targetSize == 1) |
|
||||
return this->replace(*target, value); |
|
||||
|
|
||||
if (targetSize < Jupiter::String_Type<T>::length) |
|
||||
{ |
|
||||
size_t i = 0, j = 0, k; |
|
||||
while (j <= Jupiter::String_Type<T>::length - targetSize) |
|
||||
{ |
|
||||
k = 0; |
|
||||
while (operator[](j + k) == target[k]) |
|
||||
{ |
|
||||
if (++k == targetSize) // match found
|
|
||||
{ |
|
||||
Jupiter::String_Type<T>::str[i] = value; |
|
||||
i += 1; |
|
||||
j += k; |
|
||||
break; |
|
||||
} |
|
||||
} |
|
||||
if (k != targetSize) |
|
||||
Jupiter::String_Type<T>::str[i++] = Jupiter::String_Type<T>::str[j++]; |
|
||||
} |
|
||||
while (j < Jupiter::String_Type<T>::length) |
|
||||
Jupiter::String_Type<T>::str[i++] = Jupiter::String_Type<T>::str[j++]; |
|
||||
|
|
||||
Jupiter::String_Type<T>::length = i; |
|
||||
} |
|
||||
else if (targetSize == Jupiter::String_Type<T>::length && *this == std::basic_string_view<T>(target, targetSize)) |
|
||||
return this->set(value); |
|
||||
} |
|
||||
return Jupiter::String_Type<T>::length; |
|
||||
} |
|
||||
|
|
||||
template<typename T> size_t Jupiter::String_Type<T>::replace(const Jupiter::Readable_String<T> &target, const T &value) |
|
||||
{ |
|
||||
return this->replace(target.data(), target.size(), value); |
|
||||
} |
|
||||
|
|
||||
template<typename T> size_t Jupiter::String_Type<T>::replace(const T *target, size_t targetSize, const T *value, size_t valueSize) |
|
||||
{ |
|
||||
if (valueSize == 1) |
|
||||
return this->replace(target, targetSize, *value); |
|
||||
|
|
||||
if (targetSize != 0) |
|
||||
{ |
|
||||
//if (targetSize == 1)
|
|
||||
// return this->replace(*target, value, valueSize);
|
|
||||
|
|
||||
if (targetSize < Jupiter::String_Type<T>::length) |
|
||||
{ |
|
||||
if (valueSize > targetSize) |
|
||||
{ |
|
||||
size_t instancesSize = 4; |
|
||||
size_t *instances = new size_t[instancesSize]; |
|
||||
// pass 1 (count instances)
|
|
||||
size_t instanceCount = 0, i = 0, j; |
|
||||
while (i <= Jupiter::String_Type<T>::length - targetSize) |
|
||||
{ |
|
||||
j = 0; |
|
||||
while (operator[](i + j) == target[j]) |
|
||||
{ |
|
||||
if (++j == targetSize) |
|
||||
{ |
|
||||
i += targetSize; |
|
||||
if (instanceCount == instancesSize) |
|
||||
{ |
|
||||
size_t *tInstances = new size_t[instancesSize * 2]; |
|
||||
for (instanceCount = 0; instanceCount != instancesSize; instanceCount++) |
|
||||
tInstances[instanceCount] = instances[instanceCount]; |
|
||||
delete[] instances; |
|
||||
instances = tInstances; |
|
||||
instancesSize *= 2; |
|
||||
} |
|
||||
instances[instanceCount] = i; |
|
||||
instanceCount++; |
|
||||
break; |
|
||||
} |
|
||||
} |
|
||||
if (j != targetSize) |
|
||||
i++; |
|
||||
} |
|
||||
|
|
||||
if (instanceCount != 0) |
|
||||
{ |
|
||||
// pass 2 (adjust string and replace values)
|
|
||||
size_t endSize = Jupiter::String_Type<T>::length + (valueSize - targetSize) * instanceCount; |
|
||||
this->setBufferSize(endSize); |
|
||||
instancesSize = endSize; // Repurposing. Now used as just another index.
|
|
||||
j = Jupiter::String_Type<T>::length; |
|
||||
while (instanceCount != 0) |
|
||||
{ |
|
||||
i = instances[--instanceCount]; |
|
||||
while (j != i) |
|
||||
Jupiter::String_Type<T>::str[--instancesSize] = Jupiter::String_Type<T>::str[--j]; |
|
||||
|
|
||||
j = valueSize; |
|
||||
while (j != 0) |
|
||||
Jupiter::String_Type<T>::str[--instancesSize] = value[--j]; |
|
||||
j = i - targetSize; |
|
||||
} |
|
||||
Jupiter::String_Type<T>::length = endSize; |
|
||||
} |
|
||||
delete[] instances; |
|
||||
} |
|
||||
else |
|
||||
{ |
|
||||
size_t i = 0, j = 0, k, l; |
|
||||
while (j <= Jupiter::String_Type<T>::length - targetSize) |
|
||||
{ |
|
||||
k = 0; |
|
||||
while (operator[](j + k) == target[k]) |
|
||||
{ |
|
||||
if (++k == targetSize) // match found
|
|
||||
{ |
|
||||
for (l = 0; l != valueSize; l++) |
|
||||
Jupiter::String_Type<T>::str[i + l] = value[l]; |
|
||||
i += valueSize; |
|
||||
j += k; |
|
||||
break; |
|
||||
} |
|
||||
} |
|
||||
if (k != targetSize) |
|
||||
Jupiter::String_Type<T>::str[i++] = Jupiter::String_Type<T>::str[j++]; |
|
||||
} |
|
||||
while (j < Jupiter::String_Type<T>::length) |
|
||||
Jupiter::String_Type<T>::str[i++] = Jupiter::String_Type<T>::str[j++]; |
|
||||
|
|
||||
Jupiter::String_Type<T>::length = i; |
|
||||
} |
|
||||
} |
|
||||
else if (targetSize == Jupiter::String_Type<T>::length && *this == std::basic_string_view<T>(target, targetSize)) |
|
||||
return this->set(value); |
|
||||
} |
|
||||
return Jupiter::String_Type<T>::length; |
|
||||
} |
|
||||
|
|
||||
template<typename T> size_t Jupiter::String_Type<T>::replace(const T *target, size_t targetSize, const Jupiter::Readable_String<T> &value) |
|
||||
{ |
|
||||
return this->replace(target, targetSize, value.data(), value.size()); |
|
||||
} |
|
||||
|
|
||||
template<typename T> size_t Jupiter::String_Type<T>::replace(const Jupiter::Readable_String<T> &target, const T *value, size_t valueSize) |
|
||||
{ |
|
||||
return this->replace(target.data(), target.size(), value, valueSize); |
|
||||
} |
|
||||
|
|
||||
template<typename T> size_t Jupiter::String_Type<T>::replace(std::basic_string_view<T> target, std::basic_string_view<T> value) |
|
||||
{ |
|
||||
return this->replace(target.data(), target.size(), value.data(), value.size()); |
|
||||
} |
|
||||
|
|
||||
// concat
|
|
||||
|
|
||||
template<typename T> size_t Jupiter::String_Type<T>::concat(const T *in, size_t inSize) |
|
||||
{ |
|
||||
this->setBufferSize(Jupiter::String_Type<T>::length + inSize); |
|
||||
while (inSize-- != 0) |
|
||||
Jupiter::String_Type<T>::str[Jupiter::String_Type<T>::length++] = *in++; |
|
||||
return Jupiter::String_Type<T>::length; |
|
||||
} |
|
||||
|
|
||||
template<typename T> size_t Jupiter::String_Type<T>::concat(const Jupiter::Readable_String<T> &in) |
|
||||
{ |
|
||||
return this->concat(in.data(), in.size()); |
|
||||
} |
|
||||
|
|
||||
template<typename T> size_t Jupiter::String_Type<T>::concat(const std::basic_string<T> &in) |
|
||||
{ |
|
||||
return this->concat(in.c_str(), in.size()); |
|
||||
} |
|
||||
|
|
||||
template<typename T> size_t Jupiter::String_Type<T>::concat(const T *in) |
|
||||
{ |
|
||||
return this->concat(in, Jupiter::strlen<T>(in)); |
|
||||
} |
|
||||
|
|
||||
template<typename T> size_t Jupiter::String_Type<T>::concat(const T &c) |
|
||||
{ |
|
||||
this->setBufferSize(Jupiter::String_Type<T>::length + 1); |
|
||||
Jupiter::String_Type<T>::str[Jupiter::String_Type<T>::length] = c; |
|
||||
return ++Jupiter::String_Type<T>::length; |
|
||||
} |
|
||||
|
|
||||
/**
|
|
||||
* IMPLEMENTATION: |
|
||||
* String helper templates |
|
||||
*/ |
|
||||
|
|
||||
// substring
|
|
||||
|
|
||||
template<typename T> template<template<typename> class R> R<T> Jupiter::String_Type<T>::substring(const Jupiter::Readable_String<T> &in, size_t pos) |
|
||||
{ |
|
||||
if (pos >= in.size()) return R<T>(); |
|
||||
R<T> r = R<T>(in.size() - pos); |
|
||||
for (r.length = 0; pos + r.length != in.size(); r.length++) r.str[r.length] = in[pos + r.length]; |
|
||||
return r; |
|
||||
} |
|
||||
|
|
||||
template<typename T> template<template<typename> class R> R<T> Jupiter::String_Type<T>::substring(const Jupiter::Readable_String<T> &in, size_t pos, size_t len) |
|
||||
{ |
|
||||
if (pos + len >= in.size()) return R<T>::substring(in, pos); |
|
||||
R<T> r = R<T>(len); |
|
||||
for (r.length = 0; r.length != len; r.length++) r.str[r.length] = in[pos + r.length]; |
|
||||
return r; |
|
||||
} |
|
||||
|
|
||||
template<typename T> template<template<typename> class R> R<T> Jupiter::String_Type<T>::substring(const T *in, size_t pos) |
|
||||
{ |
|
||||
size_t strLen = Jupiter::strlen<T>(in); |
|
||||
if (pos >= strLen) return R<T>(); |
|
||||
R<T> r = R<T>(strLen - pos); |
|
||||
in += pos; |
|
||||
for (r.length = 0; *in != 0; r.length++, in++) r.str[r.length] = *in; |
|
||||
return r; |
|
||||
} |
|
||||
|
|
||||
template<typename T> template<template<typename> class R> R<T> Jupiter::String_Type<T>::substring(const T *in, size_t pos, size_t len) |
|
||||
{ |
|
||||
R<T> r = R<T>(len); |
|
||||
in += pos; |
|
||||
for (r.length = 0; r.length != len; r.length++, in++) r.str[r.length] = *in; |
|
||||
return r; |
|
||||
} |
|
||||
|
|
||||
// Jupiter::DataBuffer specialization
|
|
||||
|
|
||||
template<> struct _Jupiter_DataBuffer_partial_specialization_impl<Jupiter::String_Type> { |
|
||||
template<typename Y> static void push(Jupiter::DataBuffer *buffer, const Jupiter::String_Type<Y> *data) { |
|
||||
buffer->secure(sizeof(size_t) + data->size() * sizeof(Y)); |
|
||||
buffer->push<size_t>(data->size()); |
|
||||
buffer->push(reinterpret_cast<const uint8_t *>(data->data()), data->size() * sizeof(Y)); |
|
||||
}; |
|
||||
}; |
|
||||
|
|
||||
#endif // _STRING_TYPE_IMP_H_HEADER
|
|
||||
@ -1 +1 @@ |
|||||
Subproject commit d7e4f337c786184a68b095449176261ce1700295 |
Subproject commit bce3bfefc6323754656d8153630b80155e4644e2 |
||||
Loading…
Reference in new issue