Update to new Arbutils

2020-06-26 17:08:23 +02:00 · 2020-06-26 17:08:23 +02:00 · 48639eeee5
parent f50f76e993
commit 48639eeee5
44 changed files with 177 additions and 200 deletions
--- a/CInterface/Battling/Battle.cpp
+++ b/CInterface/Battling/Battle.cpp
@ -56,21 +56,21 @@ export BattleParty* const* CreatureLib_Battle_GetParties(const Battle* p) {
 }

 export Script* CreatureLib_Battle_GetVolatileScript(Battle* p, const char* key) {
-    return p->GetVolatileScript(ConstString::GetHash(key)).GetRaw();
+    return p->GetVolatileScript(ArbUt::StringView::CalculateHash(key)).GetRaw();
 }
 export uint8_t CreatureLib_Battle_AddVolatileScriptByName(Battle* p, const char* key) {
-    Try(p->AddVolatileScript(ConstString(key));)
+    Try(p->AddVolatileScript(ArbUt::StringView(key));)
 }
 export uint8_t CreatureLib_Battle_AddVolatileScript(Battle* p, Script* script) { Try(p->AddVolatileScript(script);) }

 export uint8_t CreatureLib_Battle_RemoveVolatileScript(Battle* p, const char* key) {
-    Try(p->RemoveVolatileScript(ConstString::GetHash(key));)
+    Try(p->RemoveVolatileScript(ArbUt::StringView::CalculateHash(key));)
 }
 export uint8_t CreatureLib_Battle_RemoveVolatileScriptWithScript(Battle* p, Script* script) {
    Try(p->RemoveVolatileScript(script);)
 }
 export bool CreatureLib_Battle_HasVolatileScript(Battle* p, const char* key) {
-    return p->HasVolatileScript(ConstString::GetHash(key));
+    return p->HasVolatileScript(ArbUt::StringView::CalculateHash(key));
 }

 export uint8_t CreatureLib_Battle_RegisterEventListener(Battle* p, void (*func)(const EventData*)) {
--- a/CInterface/Battling/Creature.cpp
+++ b/CInterface/Battling/Creature.cpp
@ -36,12 +36,12 @@ SIMPLE_GET_FUNC(Creature, GetGender, CreatureLib::Library::Gender);
 SIMPLE_GET_FUNC(Creature, GetColoring, uint8_t);

 export bool CreatureLib_Creature_HasHeldItem(const Creature* p, const char* name) {
-    return p->HasHeldItem(ArbUt::CaseInsensitiveConstString(name));
+    return p->HasHeldItem(ArbUt::StringView(name));
 }
 export bool CreatureLib_Creature_HasHeldItemWithHash(const Creature* p, uint32_t hash) { return p->HasHeldItem(hash); }
 SIMPLE_GET_FUNC_SMART_PTR(Creature, GetHeldItem, const CreatureLib::Library::Item*);
 export uint8_t CreatureLib_Creature_SetHeldItem(Creature* p, const char* name) {
-    Try(p->SetHeldItem(ArbUt::CaseInsensitiveConstString(name));)
+    Try(p->SetHeldItem(ArbUt::StringView(name));)
 }
 export uint8_t CreatureLib_Creature_SetHeldItemWithHash(Creature* p, uint32_t hash) { Try(p->SetHeldItem(hash);) }
 export void CreatureLib_Creature_SetHeldItemFromItem(Creature* p, const CreatureLib::Library::Item* item) {
@ -51,7 +51,7 @@ SIMPLE_GET_FUNC(Creature, GetCurrentHealth, uint32_t);
 SIMPLE_GET_FUNC_SMART_PTR(Creature, GetBattle, Battle*);
 SIMPLE_GET_FUNC_SMART_PTR(Creature, GetBattleSide, BattleSide*);
 SIMPLE_GET_FUNC(Creature, IsOnBattleField, bool);
-export const char* CreatureLib_Creature_GetNickname(Creature* p) { return p->GetNickname().c_str(); }
+export const char* CreatureLib_Creature_GetNickname(Creature* p) { return p->GetNickname().data(); }
 export bool CreatureLib_Creature_HasType(Creature* p, uint8_t type) { return p->HasType(type); }
 SIMPLE_GET_FUNC(Creature, GetMaxHealth, uint32_t);
 export uint8_t CreatureLib_Creature_ChangeLevelBy(Creature* p, int8_t level) { Try(p->ChangeLevelBy(level);) }
@ -62,26 +62,26 @@ export uint8_t CreatureLib_Creature_Heal(Creature* p, uint32_t health, bool canR
    Try(p->Heal(health, canRevive);)
 }
 export uint8_t CreatureLib_Creature_OverrideActiveTalent(Creature* p, const char* talent) {
-    Try(p->OverrideActiveTalent(ArbUt::CaseInsensitiveConstString(talent));)
+    Try(p->OverrideActiveTalent(ArbUt::StringView(talent));)
 }
 export uint8_t CreatureLib_Creature_AddExperience(Creature* p, uint32_t experience) {
    Try(p->AddExperience(experience);)
 }
 export uint8_t CreatureLib_Creature_ClearVolatileScripts(Creature* p) { Try(p->ClearVolatileScripts();) }
 export uint8_t CreatureLib_Creature_AddVolatileScriptByName(Creature* p, const char* scriptName) {
-    Try(p->AddVolatileScript(ArbUt::CaseInsensitiveConstString(scriptName));)
+    Try(p->AddVolatileScript(ArbUt::StringView(scriptName));)
 }
 export uint8_t CreatureLib_Creature_AddVolatileScript(Creature* p, Script* script) {
    Try(p->AddVolatileScript(script);)
 }
 export uint8_t CreatureLib_Creature_RemoveVolatileScriptByName(Creature* p, const char* scriptName) {
-    Try(p->RemoveVolatileScript(ArbUt::CaseInsensitiveConstString(scriptName));)
+    Try(p->RemoveVolatileScript(ArbUt::StringView(scriptName));)
 }
 export uint8_t CreatureLib_Creature_RemoveVolatileScript(Creature* p, Script* script) {
    Try(p->RemoveVolatileScript(script);)
 }
 export bool CreatureLib_Creature_HasVolatileScript(Creature* p, const char* scriptName) {
-    return p->HasVolatileScript(ArbUt::CaseInsensitiveConstString(scriptName));
+    return p->HasVolatileScript(ArbUt::StringView(scriptName));
 }
 export size_t CreatureLib_Creature_GetAttacksCount(Creature* p) { return p->GetAttacks().Count(); }
 export LearnedAttack* const* CreatureLib_Creature_GetAttack(Creature* p, size_t index) {
--- a/CInterface/Battling/Script.cpp
+++ b/CInterface/Battling/Script.cpp
@ -11,8 +11,7 @@ export const char* CreatureLib_Script_GetName(Script* p) { return p->GetName().c
 export uint8_t CreatureLib_Script_OnBeforeTurn(Script* p, const BaseTurnChoice* choice) {
    Try(p->OnBeforeTurn(choice));
 }
-export uint8_t CreatureLib_Script_ChangeAttack(Script* p, AttackTurnChoice* choice,
-                                               ArbUt::CaseInsensitiveConstString* outAttack) {
+export uint8_t CreatureLib_Script_ChangeAttack(Script* p, AttackTurnChoice* choice, ArbUt::StringView* outAttack) {
    Try(p->ChangeAttack(choice, outAttack));
 }
 export uint8_t CreatureLib_Script_PreventAttack(Script* p, ExecutingAttack* attack, bool* outResult) {
--- a/CInterface/Battling/ScriptResolver.cpp
+++ b/CInterface/Battling/ScriptResolver.cpp
@ -11,5 +11,5 @@ export uint8_t CreatureLib_ScriptResolver_Initialize(ScriptResolver* p, BattleLi
 };
 export uint8_t CreatureLib_ScriptResolver_LoadScript(Script*& out, ScriptResolver* p, ScriptCategory category,
                                                     const char* scriptName) {
-    Try(out = p->LoadScript(category, ArbUt::CaseInsensitiveConstString(scriptName));)
+    Try(out = p->LoadScript(category, ArbUt::StringView(scriptName));)
 };
--- a/CInterface/Library/AttackData.cpp
+++ b/CInterface/Library/AttackData.cpp
@ -11,18 +11,17 @@ export uint8_t CreatureLib_AttackData_Construct(AttackData*& out, const char* na
    Try({
        std::unordered_set<uint32_t> conversedFlags(flagsCount);
        for (size_t i = 0; i < flagsCount; i++) {
-            conversedFlags.insert(ArbUt::CaseInsensitiveConstString::GetHash(flags[i]));
+            conversedFlags.insert(ArbUt::StringView::CalculateHash(flags[i]));
        }
        ArbUt::List<EffectParameter*> effectParameterList(effectParameterCount);
        for (size_t i = 0; i < effectParameterCount; i++) {
            effectParameterList[i] = effectParameters[i];
        }

-        auto effect =
-            new SecondaryEffect(effectChance, ArbUt::CaseInsensitiveConstString(effectName), effectParameterList);
+        auto effect = new SecondaryEffect(effectChance, ArbUt::StringView(effectName), effectParameterList);

-        out = new AttackData(ArbUt::CaseInsensitiveConstString(name), type, category, power, accuracy, baseUsage,
-                             target, priority, effect, conversedFlags);
+        out = new AttackData(ArbUt::StringView(name), type, category, power, accuracy, baseUsage, target, priority,
+                             effect, conversedFlags);
    })
 };

@ -51,7 +50,7 @@ export const char* CreatureLib_AttackData_GetSecondaryEffectName(const AttackDat
 }

 export bool CreatureLib_AttackData_HasFlag(const AttackData* p, const char* key) {
-    return p->HasFlag(ArbUt::CaseInsensitiveConstString::GetHash(key));
+    return p->HasFlag(ArbUt::StringView::CalculateHash(key));
 }

 #undef SIMPLE_GET_FUNC
--- a/CInterface/Library/BaseLibrary.cpp
+++ b/CInterface/Library/BaseLibrary.cpp
@ -2,7 +2,7 @@

 #define BASELIBRARY(simpleName, fullname, returnType)                                                                  \
    export uint8_t simpleName##_Insert(fullname* p, const char* name, returnType* t) {                                 \
-        Try(p->Insert(ArbUt::CaseInsensitiveConstString::GetHash(name), t);)                                           \
+        Try(p->Insert(ArbUt::StringView::CalculateHash(name), t);)                                                     \
    }                                                                                                                  \
                                                                                                                       \
    export uint8_t simpleName##_InsertWithHash(fullname* p, uint32_t hashedKey, returnType* t) {                       \
@ -10,14 +10,14 @@
    }                                                                                                                  \
                                                                                                                       \
    export uint8_t simpleName##_Delete(fullname* p, const char* name) {                                                \
-        Try(p->Delete(ArbUt::CaseInsensitiveConstString::GetHash(name));)                                              \
+        Try(p->Delete(ArbUt::StringView::CalculateHash(name));)                                                        \
    }                                                                                                                  \
                                                                                                                       \
    export uint8_t simpleName##_DeleteWithHash(fullname* p, uint32_t hashedKey) { Try(p->Delete(hashedKey);) }         \
                                                                                                                       \
    export bool simpleName##_TryGet(fullname* p, const char* name, const returnType*& out) {                           \
        ArbUt::BorrowedPtr<const returnType> o;                                                                        \
-        auto v = p->TryGet(ArbUt::CaseInsensitiveConstString::GetHash(name), o);                                       \
+        auto v = p->TryGet(ArbUt::StringView::CalculateHash(name), o);                                                 \
        out = o.operator->();                                                                                          \
        return v;                                                                                                      \
    }                                                                                                                  \
@ -30,7 +30,7 @@
    }                                                                                                                  \
                                                                                                                       \
    export uint8_t simpleName##_Get(fullname* p, const char* name, const returnType*& out) {                           \
-        Try(out = p->Get(ArbUt::CaseInsensitiveConstString::GetHash(name)).operator->();)                              \
+        Try(out = p->Get(ArbUt::StringView::CalculateHash(name)).operator->();)                                        \
    }                                                                                                                  \
                                                                                                                       \
    export uint8_t simpleName##_GetWithHash(fullname* p, uint32_t hashedKey, const returnType*& out) {                 \
--- a/CInterface/Library/CreatureSpecies.cpp
+++ b/CInterface/Library/CreatureSpecies.cpp
@ -6,8 +6,8 @@ export uint8_t CreatureLib_CreatureSpecies_Construct(CreatureSpecies*& out, uint
                                                     SpeciesVariant* defaultVariant, float genderRatio,
                                                     const char* growthRate, uint8_t captureRate) {

-    Try(out = new CreatureSpecies(id, ArbUt::CaseInsensitiveConstString(name), defaultVariant, genderRatio,
-                                  ArbUt::CaseInsensitiveConstString(growthRate), captureRate);)
+    Try(out = new CreatureSpecies(id, ArbUt::StringView(name), defaultVariant, genderRatio,
+                                  ArbUt::StringView(growthRate), captureRate);)
 }

 export void CreatureLib_CreatureSpecies_Destruct(const CreatureSpecies* p) { delete p; }
@ -23,7 +23,7 @@ export const char* CreatureLib_CreatureSpecies_GetGrowthRate(const CreatureSpeci
    return p->GetGrowthRate().c_str();
 }
 export bool CreatureLib_CreatureSpecies_HasVariant(const CreatureSpecies* p, const char* name) {
-    return p->HasVariant(ArbUt::CaseInsensitiveConstString::GetHash(name));
+    return p->HasVariant(ArbUt::StringView::CalculateHash(name));
 }
 export bool CreatureLib_CreatureSpecies_HasVariantWithHash(const CreatureSpecies* p, uint32_t hash) {
    return p->HasVariant(hash);
@ -31,7 +31,7 @@ export bool CreatureLib_CreatureSpecies_HasVariantWithHash(const CreatureSpecies
 export bool CreatureLib_CreatureSpecies_TryGetVariant(const CreatureSpecies* p, const char* name,
                                                      const SpeciesVariant*& out) {
    ArbUt::BorrowedPtr<const SpeciesVariant> o;
-    auto res = p->TryGetVariant(ArbUt::CaseInsensitiveConstString::GetHash(name), o);
+    auto res = p->TryGetVariant(ArbUt::StringView::CalculateHash(name), o);
    out = o.GetRaw();
    return res;
 }
@ -45,14 +45,14 @@ export bool CreatureLib_CreatureSpecies_TryGetVariantWithHash(const CreatureSpec

 export uint8_t CreatureLib_CreatureSpecies_GetVariant(const SpeciesVariant*& out, const CreatureSpecies* p,
                                                      const char* name) {
-    Try(out = p->GetVariant(ArbUt::CaseInsensitiveConstString::GetHash(name)).GetRaw();)
+    Try(out = p->GetVariant(ArbUt::StringView::CalculateHash(name)).GetRaw();)
 }
 export uint8_t CreatureLib_CreatureSpecies_GetVariantWithHash(const SpeciesVariant* out, const CreatureSpecies* p,
                                                              uint32_t hash) {
    Try(out = p->GetVariant(hash).GetRaw();)
 }
 export uint8_t CreatureLib_CreatureSpecies_SetVariant(CreatureSpecies* p, const char* name, SpeciesVariant* variant) {
-    Try(p->SetVariant(ArbUt::CaseInsensitiveConstString(name), variant);)
+    Try(p->SetVariant(ArbUt::StringView(name), variant);)
 }

 #undef SIMPLE_GET_FUNC
--- a/CInterface/Library/EffectParameter.cpp
+++ b/CInterface/Library/EffectParameter.cpp
@ -6,7 +6,7 @@ export EffectParameter* CreatureLib_EffectParameter_FromBool(bool b) { return ne
 export EffectParameter* CreatureLib_EffectParameter_FromInt(int64_t i) { return new EffectParameter(i); }
 export EffectParameter* CreatureLib_EffectParameter_FromFloat(float f) { return new EffectParameter(f); }
 export EffectParameter* CreatureLib_EffectParameter_FromString(const char* c) {
-    return new EffectParameter(ArbUt::CaseInsensitiveConstString(c));
+    return new EffectParameter(ArbUt::StringView(c));
 }

 export void CreatureLib_EffectParameter_Destruct(const EffectParameter* p) { delete p; }
--- a/CInterface/Library/GrowthRateLibrary.cpp
+++ b/CInterface/Library/GrowthRateLibrary.cpp
@ -10,7 +10,7 @@ export void CreatureLib_GrowthRateLibrary_Destruct(GrowthRateLibrary* p) { delet

 export uint8_t CreatureLib_GrowthRateLibrary_CalculateLevel(uint8_t& out, GrowthRateLibrary* library,
                                                            const char* growthRate, uint32_t experience) {
-    Try(out = library->CalculateLevel(ArbUt::CaseInsensitiveConstString::GetHash(growthRate), experience);)
+    Try(out = library->CalculateLevel(ArbUt::StringView::CalculateHash(growthRate), experience);)
 }
 export uint8_t CreatureLib_GrowthRateLibrary_CalculateLevelWithHash(uint8_t& out, GrowthRateLibrary* library,
                                                                    uint32_t growthRateHash, uint32_t experience) {
@ -19,7 +19,7 @@ export uint8_t CreatureLib_GrowthRateLibrary_CalculateLevelWithHash(uint8_t& out

 export uint8_t CreatureLib_GrowthRateLibrary_CalculateExperience(uint32_t& out, GrowthRateLibrary* library,
                                                                 const char* growthRate, uint8_t level) {
-    Try(out = library->CalculateExperience(ArbUt::CaseInsensitiveConstString::GetHash(growthRate), level);)
+    Try(out = library->CalculateExperience(ArbUt::StringView::CalculateHash(growthRate), level);)
 }

 export uint8_t CreatureLib_GrowthRateLibrary_CalculateExperienceWithHash(uint32_t& out, GrowthRateLibrary* library,
@ -28,7 +28,7 @@ export uint8_t CreatureLib_GrowthRateLibrary_CalculateExperienceWithHash(uint32_
 }
 export uint8_t CreatureLib_GrowthRateLibrary_AddGrowthRate(GrowthRateLibrary* library, const char* growthRateName,
                                                           GrowthRate* growthRate) {
-    Try(library->AddGrowthRate(ArbUt::CaseInsensitiveConstString::GetHash(growthRateName), growthRate);)
+    Try(library->AddGrowthRate(ArbUt::StringView::CalculateHash(growthRateName), growthRate);)
 }

 export uint8_t CreatureLib_GrowthRateLibrary_AddGrowthRateWithHash(GrowthRateLibrary* library, uint32_t growthRateHash,
--- a/CInterface/Library/Item.cpp
+++ b/CInterface/Library/Item.cpp
@ -1,16 +1,15 @@
 #include "../../src/Library/Items/Item.hpp"
 #include "../Core.hpp"
 using namespace CreatureLib::Library;
-using ConstString = ArbUt::CaseInsensitiveConstString;

 export Item* CreatureLib_Item_Construct(const char* name, ItemCategory category, BattleItemCategory battleCategory,
                                        int32_t price, const char* flags[], size_t flagsCount) {
    std::unordered_set<uint32_t> conversedFlags(flagsCount);
    for (size_t i = 0; i < flagsCount; i++) {
-        conversedFlags.insert(ConstString::GetHash(flags[i]));
+        conversedFlags.insert(ArbUt::StringView::CalculateHash(flags[i]));
    }

-    return new Item(ConstString(name), category, battleCategory, price, conversedFlags);
+    return new Item(ArbUt::StringView(name), category, battleCategory, price, conversedFlags);
 };

 export void CreatureLib_Item_Destruct(const Item* p) { delete p; }
@ -23,6 +22,8 @@ SIMPLE_GET_FUNC(Item, GetCategory, ItemCategory);
 SIMPLE_GET_FUNC(Item, GetBattleCategory, BattleItemCategory);
 SIMPLE_GET_FUNC(Item, GetPrice, int32_t);

-export bool CreatureLib_Item_HasFlag(const Item* p, const char* key) { return p->HasFlag(ConstString::GetHash(key)); }
+export bool CreatureLib_Item_HasFlag(const Item* p, const char* key) {
+    return p->HasFlag(ArbUt::StringView::CalculateHash(key));
+}

 #undef SIMPLE_GET_FUNC
--- a/CInterface/Library/SpeciesVariant.cpp
+++ b/CInterface/Library/SpeciesVariant.cpp
@ -9,21 +9,20 @@ export SpeciesVariant* CreatureLib_SpeciesVariant_Construct(
    uint16_t baseMagicalDefense, uint16_t baseSpeed, const char* talents[], size_t talentsLength,
    const char* secretTalents[], size_t secretTalentsLength, const LearnableAttacks* attacks) {

-    auto talentsWrapped = ArbUt::List<ArbUt::CaseInsensitiveConstString>(talentsLength);
+    auto talentsWrapped = ArbUt::List<ArbUt::StringView>(talentsLength);
    for (size_t i = 0; i < talentsLength; i++) {
-        talentsWrapped.Append(ArbUt::CaseInsensitiveConstString(talents[i]));
+        talentsWrapped.Append(ArbUt::StringView(talents[i]));
    }
-    auto secretTalentsWrapped = ArbUt::List<ArbUt::CaseInsensitiveConstString>(secretTalentsLength);
+    auto secretTalentsWrapped = ArbUt::List<ArbUt::StringView>(secretTalentsLength);
    for (size_t i = 0; i < secretTalentsLength; i++) {
-        secretTalentsWrapped.Append(ArbUt::CaseInsensitiveConstString(secretTalents[i]));
+        secretTalentsWrapped.Append(ArbUt::StringView(secretTalents[i]));
    }

-    return new SpeciesVariant(ArbUt::CaseInsensitiveConstString(name), height, weight, baseExperience,
-                              ArbUt::List<uint8_t>(types, types + typeLength),
-                              CreatureLib::Library::StatisticSet<uint16_t>(baseHealth, baseAttack, baseDefense,
-                                                                           baseMagicalAttack, baseMagicalDefense,
-                                                                           baseSpeed),
-                              talentsWrapped, secretTalentsWrapped, attacks);
+    return new SpeciesVariant(
+        ArbUt::StringView(name), height, weight, baseExperience, ArbUt::List<uint8_t>(types, types + typeLength),
+        CreatureLib::Library::StatisticSet<uint16_t>(baseHealth, baseAttack, baseDefense, baseMagicalAttack,
+                                                     baseMagicalDefense, baseSpeed),
+        talentsWrapped, secretTalentsWrapped, attacks);
 }

 export void CreatureLib_SpeciesVariant_Destruct(SpeciesVariant* p) { delete p; }
--- a/CInterface/Library/TypeLibrary.cpp
+++ b/CInterface/Library/TypeLibrary.cpp
@ -9,14 +9,14 @@ export TypeLibrary* CreatureLib_TypeLibrary_Construct(size_t initialCapacity) {
 export void CreatureLib_TypeLibrary_Destruct(const TypeLibrary* p) { delete p; }

 export uint8_t CreatureLib_TypeLibrary_GetTypeId(uint8_t& out, const TypeLibrary* p, const char* type) {
-    Try(out = p->GetTypeId(ArbUt::CaseInsensitiveConstString::GetHash(type));)
+    Try(out = p->GetTypeId(ArbUt::StringView::CalculateHash(type));)
 }
 export uint8_t CreatureLib_TypeLibrary_GetTypeIdWithHash(uint8_t& out, const TypeLibrary* p, uint32_t type) {
    Try(out = p->GetTypeId(type);)
 }

 export uint8_t CreatureLib_TypeLibrary_RegisterType(uint8_t& out, TypeLibrary* p, const char* type) {
-    Try(out = p->RegisterType(ArbUt::CaseInsensitiveConstString::GetHash(type));)
+    Try(out = p->RegisterType(ArbUt::StringView::CalculateHash(type));)
 }
 export uint8_t CreatureLib_TypeLibrary_RegisterTypeWithHash(uint8_t& out, TypeLibrary* p, uint32_t type) {
    Try(out = p->RegisterType(type);)
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@ -5,7 +5,7 @@ set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Werror")

 project(CreatureLib)

-set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD 20)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)

 if (NOT EXISTS ${CMAKE_BINARY_DIR}/conanbuildinfo.cmake)
--- a/src/Battling/EventHooks/EventData.hpp
+++ b/src/Battling/EventHooks/EventData.hpp
@ -55,12 +55,12 @@ namespace CreatureLib::Battling {
    };

    class DisplayTextEvent : public EventData {
-        const std::string _text;
+        const ArbUt::StringView _text;

    public:
-        DisplayTextEvent(const std::string& text) noexcept : _text(text) {}
+        DisplayTextEvent(const ArbUt::StringView& text) noexcept : _text(text) {}
        EventDataKind GetKind() const noexcept override { return EventDataKind ::DisplayText; }
-        const std::string& GetText() const noexcept { return _text; }
+        const ArbUt::StringView& GetText() const noexcept { return _text; }
    };

 }
--- a/src/Battling/Library/BattleLibrary.cpp
+++ b/src/Battling/Library/BattleLibrary.cpp
@ -1,4 +1,5 @@
 #include "BattleLibrary.hpp"
+#include <Arbutils/Assert.hpp>

 using namespace CreatureLib::Battling;

@ -43,6 +44,6 @@ const std::unique_ptr<const DamageLibrary>& BattleLibrary::GetDamageLibrary() co

 const std::unique_ptr<const MiscLibrary>& BattleLibrary::GetMiscLibrary() const noexcept { return _miscLibrary; }

-Script* BattleLibrary::LoadScript(ScriptCategory category, const ArbUt::CaseInsensitiveConstString& scriptName) const {
+Script* BattleLibrary::LoadScript(ScriptCategory category, const ArbUt::BasicStringView& scriptName) const {
    return _scriptResolver->LoadScript(category, scriptName);
 }
--- a/src/Battling/Library/BattleLibrary.hpp
+++ b/src/Battling/Library/BattleLibrary.hpp
@ -41,8 +41,7 @@ namespace CreatureLib::Battling {
            return _experienceLibrary;
        }

-        [[nodiscard]] Script* LoadScript(ScriptCategory category,
-                                         const ArbUt::CaseInsensitiveConstString& scriptName) const;
+        [[nodiscard]] Script* LoadScript(ScriptCategory category, const ArbUt::BasicStringView& scriptName) const;
    };
 }

--- a/src/Battling/Models/Battle.cpp
+++ b/src/Battling/Models/Battle.cpp
@ -129,7 +129,7 @@ void Battle::ValidateBattleState() {
    this->_battleResult = BattleResult::Conclusive(winningSide);
    this->_hasEnded = true;
 }
-void Battle::AddVolatileScript(const ConstString& key) {
+void Battle::AddVolatileScript(const ArbUt::BasicStringView& key) {
    auto script = _volatile.Get(key);
    if (script != nullptr) {
        script->Stack();
@ -145,4 +145,4 @@ void Battle::AddVolatileScript(const ConstString& key) {
 }
 void Battle::AddVolatileScript(Script* script) { return _volatile.Add(script); }
 void Battle::RemoveVolatileScript(Script* script) { _volatile.Remove(script->GetName()); }
-void Battle::DisplayText(const std::string& text) const { TriggerEventListener(new DisplayTextEvent(text)); }
+void Battle::DisplayText(const ArbUt::StringView& text) const { TriggerEventListener(new DisplayTextEvent(text)); }
--- a/src/Battling/Models/Battle.hpp
+++ b/src/Battling/Models/Battle.hpp
@ -83,17 +83,17 @@ namespace CreatureLib::Battling {

        const ArbUt::UniquePtrList<BattleParty>& GetParties() const noexcept { return _parties; }
        const ArbUt::UniquePtrList<BattleSide>& GetSides() const noexcept { return _sides; }
-        ArbUt::BorrowedPtr<Script> GetVolatileScript(const ConstString& key) const { return _volatile.Get(key); }
+        ArbUt::BorrowedPtr<Script> GetVolatileScript(const ArbUt::StringView& key) const { return _volatile.Get(key); }
        ArbUt::BorrowedPtr<Script> GetVolatileScript(uint32_t keyHash) const noexcept { return _volatile.Get(keyHash); }
-        void AddVolatileScript(const ConstString& key);
+        void AddVolatileScript(const ArbUt::BasicStringView& key);
        void AddVolatileScript(Script* script);
-        void RemoveVolatileScript(const ConstString& name) { _volatile.Remove(name); }
+        void RemoveVolatileScript(const ArbUt::BasicStringView& name) { _volatile.Remove(name); }
        void RemoveVolatileScript(uint32_t keyHash) { _volatile.Remove(keyHash); }
        void RemoveVolatileScript(Script* script);
-        bool HasVolatileScript(const ConstString& name) const { return _volatile.Has(name); }
+        bool HasVolatileScript(const ArbUt::BasicStringView& name) const { return _volatile.Has(name); }
        bool HasVolatileScript(uint32_t keyHash) const { return _volatile.Has(keyHash); }

-        void DisplayText(const std::string& text) const;
+        void DisplayText(const ArbUt::StringView& text) const;
        void RegisterEventListener(EVENT_HOOK_FUNC(listener)) { this->_eventHook.RegisterListener(listener); }
        void TriggerEventListener(EventData* data) const { this->_eventHook.TriggerEvent(data); }
    };
--- a/src/Battling/Models/CreateCreature.cpp
+++ b/src/Battling/Models/CreateCreature.cpp
@ -5,7 +5,7 @@

 using namespace CreatureLib::Battling;

-CreateCreature CreateCreature::WithVariant(const ArbUt::CaseInsensitiveConstString& variant) {
+CreateCreature CreateCreature::WithVariant(const ArbUt::StringView& variant) {
    this->_variant = variant;
    return *this;
 }
@ -20,8 +20,7 @@ CreateCreature CreateCreature::WithGender(Library::Gender gender) {
    return *this;
 }

-CreateCreature CreateCreature::WithAttack(const ArbUt::CaseInsensitiveConstString& attackName,
-                                          AttackLearnMethod learnMethod) {
+CreateCreature CreateCreature::WithAttack(const ArbUt::StringView& attackName, AttackLearnMethod learnMethod) {
    if (_attacks.Count() >= _library->GetSettings()->GetMaximalMoves())
        throw CreatureException("You have already set the maximum amount of allowed moves.");

--- a/src/Battling/Models/CreateCreature.hpp
+++ b/src/Battling/Models/CreateCreature.hpp
@ -9,28 +9,27 @@
 namespace CreatureLib::Battling {
    class CreateCreature {
        ArbUt::BorrowedPtr<const BattleLibrary> _library;
-        ArbUt::CaseInsensitiveConstString _species;
-        ArbUt::CaseInsensitiveConstString _variant = "default"_cnc;
+        ArbUt::StringView _species;
+        ArbUt::StringView _variant = "default"_cnc;
        uint8_t _level;
        std::string _nickname = "";

-        ArbUt::CaseInsensitiveConstString _talent = ""_cnc;
+        ArbUt::StringView _talent = ""_cnc;
        Library::Gender _gender = static_cast<Library::Gender>(-1);
        uint8_t _coloring = 0;
-        ArbUt::CaseInsensitiveConstString _heldItem = ""_cnc;
+        ArbUt::StringView _heldItem = ""_cnc;
        uint32_t _identifier = 0;
        ArbUt::List<std::tuple<ArbUt::BorrowedPtr<const Library::AttackData>, AttackLearnMethod>> _attacks;

    public:
-        CreateCreature(ArbUt::BorrowedPtr<const BattleLibrary> library,
-                       const ArbUt::CaseInsensitiveConstString& species, uint8_t level)
+        CreateCreature(ArbUt::BorrowedPtr<const BattleLibrary> library, const ArbUt::StringView& species, uint8_t level)
            : _library(library), _species(species), _level(level), _attacks(library->GetSettings()->GetMaximalMoves()) {
        }

-        CreateCreature WithVariant(const ArbUt::CaseInsensitiveConstString& variant);
+        CreateCreature WithVariant(const ArbUt::StringView& variant);
        CreateCreature WithNickname(std::string nickname);
        CreateCreature WithGender(Library::Gender gender);
-        CreateCreature WithAttack(const ArbUt::CaseInsensitiveConstString& attackName, AttackLearnMethod learnMethod);
+        CreateCreature WithAttack(const ArbUt::StringView& attackName, AttackLearnMethod learnMethod);

        Creature* Create();
    };
--- a/src/Battling/Models/Creature.cpp
+++ b/src/Battling/Models/Creature.cpp
@ -10,7 +10,7 @@ Battling::Creature::Creature(ArbUt::BorrowedPtr<const BattleLibrary> library,
                             const ArbUt::BorrowedPtr<const Library::CreatureSpecies>& species,
                             const ArbUt::BorrowedPtr<const Library::SpeciesVariant>& variant, uint8_t level,
                             uint32_t experience, uint32_t uid, Library::Gender gender, uint8_t coloring,
-                             const ArbUt::BorrowedPtr<const Library::Item> heldItem, std::string nickname,
+                             const ArbUt::BorrowedPtr<const Library::Item> heldItem, const std::string_view& nickname,
                             const Library::TalentIndex& talent, const std::vector<LearnedAttack*>& attacks,
                             bool allowedExperienceGain)
    : _library(library), _species(species), _variant(variant), _level(level), _experience(experience),
@ -68,7 +68,7 @@ void Battling::Creature::ChangeLevelBy(int8_t amount) {
    RecalculateFlatStats();
 }

-const ConstString& Battling::Creature::GetActiveTalent() const {
+const ArbUt::StringView& Battling::Creature::GetActiveTalent() const {
    if (_hasOverridenTalent) {
        return _overridenTalentName;
    }
@ -169,7 +169,7 @@ void Battling::Creature::Heal(uint32_t amount, bool canRevive) {
    _currentHealth = newHealth;
 }

-void Battling::Creature::OverrideActiveTalent(const ConstString& talent) {
+void Battling::Creature::OverrideActiveTalent(const ArbUt::StringView& talent) {
    _hasOverridenTalent = true;
    _activeTalent->OnRemove();
    _overridenTalentName = talent;
@ -224,7 +224,7 @@ ArbUt::BorrowedPtr<const Library::SpeciesVariant> Battling::Creature::GetDisplay
        variant = _variant;
    return variant;
 }
-void Battling::Creature::SetHeldItem(const ConstString& itemName) {
+void Battling::Creature::SetHeldItem(const ArbUt::BasicStringView& itemName) {
    ArbUt::BorrowedPtr<const Library::Item> item;
    if (!_library->GetItemLibrary()->TryGet(itemName.GetHash(), item)) {
        throw CreatureException("Item not found.");
@ -239,7 +239,7 @@ void Battling::Creature::SetHeldItem(uint32_t itemNameHash) {
    _heldItem = item;
 }

-void Battling::Creature::AddVolatileScript(const ConstString& name) {
+void Battling::Creature::AddVolatileScript(const ArbUt::BasicStringView& name) {
    auto script = _volatile.Get(name);
    if (script != nullptr) {
        script->Stack();
@ -255,6 +255,6 @@ void Battling::Creature::AddVolatileScript(const ConstString& name) {
 }

 void Battling::Creature::AddVolatileScript(Script* script) { _volatile.Add(script); }
-void Battling::Creature::RemoveVolatileScript(const ConstString& name) { _volatile.Remove(name); }
+void Battling::Creature::RemoveVolatileScript(const ArbUt::BasicStringView& name) { _volatile.Remove(name); }
 void Battling::Creature::RemoveVolatileScript(Battling::Script* script) { _volatile.Remove(script->GetName()); }
-bool Battling::Creature::HasVolatileScript(const ConstString& name) const { return _volatile.Has(name); }
+bool Battling::Creature::HasVolatileScript(const ArbUt::BasicStringView& name) const { return _volatile.Has(name); }
--- a/src/Battling/Models/Creature.hpp
+++ b/src/Battling/Models/Creature.hpp
@ -45,12 +45,12 @@ namespace CreatureLib::Battling {
        ArbUt::BorrowedPtr<BattleSide> _side = nullptr;
        bool _onBattleField = false;

-        std::string _nickname = "";
+        std::string_view _nickname = "";
        CreatureLib::Library::TalentIndex _talentIndex;
        std::unique_ptr<Script> _activeTalent = nullptr;

        bool _hasOverridenTalent;
-        ArbUt::CaseInsensitiveConstString _overridenTalentName = ""_cnc;
+        ArbUt::StringView _overridenTalentName = ""_cnc;
        std::unordered_set<ArbUt::BorrowedPtr<Creature>> _seenOpponents;

        ArbUt::UniquePtrList<LearnedAttack> _attacks;
@ -69,7 +69,7 @@ namespace CreatureLib::Battling {
                 const ArbUt::BorrowedPtr<const Library::CreatureSpecies>& species,
                 const ArbUt::BorrowedPtr<const Library::SpeciesVariant>& variant, uint8_t level, uint32_t experience,
                 uint32_t uid, Library::Gender gender, uint8_t coloring,
-                 const ArbUt::BorrowedPtr<const Library::Item> heldItem, std::string nickname,
+                 const ArbUt::BorrowedPtr<const Library::Item> heldItem, const std::string_view& nickname,
                 const Library::TalentIndex& talent, const std::vector<LearnedAttack*>& attacks,
                 bool allowedExperienceGain = true);

@ -89,14 +89,14 @@ namespace CreatureLib::Battling {
        inline uint32_t GetExperience() const noexcept { return _experience; }
        inline Library::Gender GetGender() const noexcept { return _gender; }
        inline uint8_t GetColoring() const noexcept { return _coloring; }
-        inline bool HasHeldItem(const ArbUt::CaseInsensitiveConstString& name) const noexcept {
+        inline bool HasHeldItem(const ArbUt::BasicStringView& name) const noexcept {
            return _heldItem != nullptr && _heldItem->GetName() == name;
        }
        inline bool HasHeldItem(uint32_t nameHash) const noexcept {
            return _heldItem != nullptr && _heldItem->GetName() == nameHash;
        }
        inline const ArbUt::BorrowedPtr<const Library::Item>& GetHeldItem() const noexcept { return _heldItem; }
-        void SetHeldItem(const ArbUt::CaseInsensitiveConstString& itemName);
+        void SetHeldItem(const ArbUt::BasicStringView& itemName);
        void SetHeldItem(uint32_t itemNameHash);
        inline void SetHeldItem(const ArbUt::BorrowedPtr<const Library::Item>& item) noexcept { _heldItem = item; };

@ -108,8 +108,8 @@ namespace CreatureLib::Battling {
        inline void SetOnBattleField(bool value) { _onBattleField = value; }
        inline bool IsOnBattleField() const { return _onBattleField; }

-        inline const std::string& GetNickname() const noexcept { return _nickname; }
-        const ArbUt::CaseInsensitiveConstString& GetActiveTalent() const;
+        inline const std::string_view& GetNickname() const noexcept { return _nickname; }
+        const ArbUt::StringView& GetActiveTalent() const;

        [[nodiscard]] bool IsFainted() const noexcept;
        [[nodiscard]] const std::unordered_set<uint8_t>& GetTypes() const noexcept;
@ -119,7 +119,7 @@ namespace CreatureLib::Battling {
        void ChangeLevelBy(int8_t amount);
        void Damage(uint32_t damage, DamageSource source);
        void Heal(uint32_t amount, bool canRevive = false);
-        void OverrideActiveTalent(const ArbUt::CaseInsensitiveConstString& talent);
+        void OverrideActiveTalent(const ArbUt::StringView& talent);
        void AddExperience(uint32_t amount);

        void MarkOpponentAsSeen(ArbUt::BorrowedPtr<Creature> creature) { _seenOpponents.insert(creature); }
@ -128,11 +128,11 @@ namespace CreatureLib::Battling {
        size_t ScriptCount() const override;
        void GetActiveScripts(ArbUt::List<ScriptWrapper>& scripts) override;
        void ClearVolatileScripts();
-        void AddVolatileScript(const ArbUt::CaseInsensitiveConstString& name);
+        void AddVolatileScript(const ArbUt::BasicStringView& name);
        void AddVolatileScript(Script* script);
-        void RemoveVolatileScript(const ArbUt::CaseInsensitiveConstString& name);
+        void RemoveVolatileScript(const ArbUt::BasicStringView& name);
        void RemoveVolatileScript(Script* script);
-        bool HasVolatileScript(const ArbUt::CaseInsensitiveConstString& name) const;
+        bool HasVolatileScript(const ArbUt::BasicStringView& name) const;

        const ArbUt::UniquePtrList<LearnedAttack>& GetAttacks() noexcept { return _attacks; }

--- a/src/Battling/ScriptHandling/Script.hpp
+++ b/src/Battling/ScriptHandling/Script.hpp
@ -2,7 +2,7 @@
 #define CREATURELIB_SCRIPT_HPP

 #include <Arbutils/Collections/List.hpp>
-#include <Arbutils/ConstString.hpp>
+#include <Arbutils/StringView.hpp>
 #include "../../Library/EffectParameter.hpp"

 namespace CreatureLib::Battling {
@ -19,13 +19,13 @@ namespace CreatureLib::Battling {
        virtual void Stack(){};
        virtual void OnRemove(){};

-        virtual const ArbUt::CaseInsensitiveConstString& GetName() const noexcept = 0;
+        virtual const ArbUt::StringView& GetName() const noexcept = 0;

        virtual void OnInitialize(const ArbUt::List<CreatureLib::Library::EffectParameter*>& parameters){};
        virtual void OnBeforeTurn(const BaseTurnChoice* choice){};

        virtual void ChangePriority(AttackTurnChoice* choice, int8_t* priority){};
-        virtual void ChangeAttack(AttackTurnChoice* choice, ArbUt::CaseInsensitiveConstString* outAttack){};
+        virtual void ChangeAttack(AttackTurnChoice* choice, ArbUt::StringView* outAttack){};
        virtual void PreventAttack(ExecutingAttack* attack, bool* outResult){};
        virtual void FailAttack(ExecutingAttack* attack, bool* outFailed){};
        virtual void StopBeforeAttack(ExecutingAttack* attack, bool* outResult){};
--- a/src/Battling/ScriptHandling/ScriptResolver.hpp
+++ b/src/Battling/ScriptHandling/ScriptResolver.hpp
@ -14,7 +14,7 @@ namespace CreatureLib::Battling {
        virtual ~ScriptResolver() = default;

        virtual void Initialize(BattleLibrary* library){};
-        virtual Script* LoadScript(ScriptCategory category, const ArbUt::CaseInsensitiveConstString& scriptName) {
+        virtual Script* LoadScript(ScriptCategory category, const ArbUt::BasicStringView& scriptName) {
            return nullptr;
        };
    };
--- a/src/Battling/ScriptHandling/ScriptSet.hpp
+++ b/src/Battling/ScriptHandling/ScriptSet.hpp
@ -29,9 +29,7 @@ namespace CreatureLib::Battling {
            _lookup.Insert(script->GetName(), _scripts.Count() - 1);
        }

-        ArbUt::BorrowedPtr<Script> Get(const ArbUt::CaseInsensitiveConstString& key) const {
-            return Get(key.GetHash());
-        }
+        ArbUt::BorrowedPtr<Script> Get(const ArbUt::BasicStringView& key) const { return Get(key.GetHash()); }

        ArbUt::BorrowedPtr<Script> Get(uint32_t keyHash) const noexcept {
            size_t v;
@ -41,7 +39,7 @@ namespace CreatureLib::Battling {
            return nullptr;
        }

-        void Remove(const ArbUt::CaseInsensitiveConstString& key) { Remove(key.GetHash()); }
+        void Remove(const ArbUt::BasicStringView& key) { Remove(key.GetHash()); }

        void Remove(uint32_t keyHash) {
            size_t v;
@ -62,7 +60,7 @@ namespace CreatureLib::Battling {
            _lookup.Clear();
        }

-        bool Has(const ArbUt::CaseInsensitiveConstString& key) const { return _lookup.Has(key); }
+        bool Has(const ArbUt::BasicStringView& key) const { return _lookup.Has(key); }

        bool Has(uint32_t keyHash) const { return _lookup.Has(keyHash); }

--- a/src/Library/Attacks/AttackData.cpp
+++ b/src/Library/Attacks/AttackData.cpp
@ -1,7 +1,7 @@
 #include "AttackData.hpp"
 #include <utility>

-CreatureLib::Library::AttackData::AttackData(const ArbUt::CaseInsensitiveConstString& name, uint8_t type,
+CreatureLib::Library::AttackData::AttackData(const ArbUt::StringView& name, uint8_t type,
                                             CreatureLib::Library::AttackCategory category, uint8_t power,
                                             uint8_t accuracy, uint8_t baseUsage,
                                             CreatureLib::Library::AttackTarget target, int8_t priority,
--- a/src/Library/Attacks/AttackData.hpp
+++ b/src/Library/Attacks/AttackData.hpp
@ -1,7 +1,7 @@
 #ifndef CREATURELIB_ATTACKDATA_HPP
 #define CREATURELIB_ATTACKDATA_HPP

-#include <Arbutils/ConstString.hpp>
+#include <Arbutils/StringView.hpp>
 #include <memory>
 #include <string>
 #include <unordered_set>
@ -12,7 +12,7 @@
 namespace CreatureLib::Library {
    class AttackData {
    protected:
-        ArbUt::CaseInsensitiveConstString _name;
+        ArbUt::StringView _name;
        uint8_t _type;
        AttackCategory _category;
        uint8_t _basePower;
@ -24,12 +24,12 @@ namespace CreatureLib::Library {
        std::unordered_set<uint32_t> _flags;

    public:
-        AttackData(const ArbUt::CaseInsensitiveConstString& name, uint8_t type, AttackCategory category, uint8_t power,
+        AttackData(const ArbUt::StringView& name, uint8_t type, AttackCategory category, uint8_t power,
                   uint8_t accuracy, uint8_t baseUsage, AttackTarget target, int8_t priority,
                   const SecondaryEffect* effect, std::unordered_set<uint32_t> flags);
        virtual ~AttackData() = default;

-        inline const ArbUt::CaseInsensitiveConstString& GetName() const noexcept { return _name; }
+        inline const ArbUt::StringView& GetName() const noexcept { return _name; }
        inline const uint8_t GetType() const noexcept { return _type; }
        inline AttackCategory GetCategory() const noexcept { return _category; }
        inline uint8_t GetBasePower() const noexcept { return _basePower; }
@ -42,7 +42,7 @@ namespace CreatureLib::Library {
        }
        inline const std::unique_ptr<const SecondaryEffect>& GetSecondaryEffect() const noexcept { return _effect; }

-        inline bool HasFlag(const ArbUt::CaseInsensitiveConstString& key) const noexcept {
+        inline bool HasFlag(const ArbUt::StringView& key) const noexcept {
            return this->_flags.find(key) != this->_flags.end();
        }
        inline bool HasFlag(uint32_t keyHash) const noexcept {
--- a/src/Library/Attacks/SecondaryEffect.hpp
+++ b/src/Library/Attacks/SecondaryEffect.hpp
@ -2,7 +2,7 @@
 #define CREATURELIB_SECONDARYEFFECT_HPP

 #include <Arbutils/Collections/List.hpp>
-#include <Arbutils/ConstString.hpp>
+#include <Arbutils/StringView.hpp>
 #include <any>
 #include "../EffectParameter.hpp"

@ -10,12 +10,12 @@ namespace CreatureLib::Library {
    class SecondaryEffect {
    private:
        float _chance;
-        ArbUt::CaseInsensitiveConstString _effectName;
+        ArbUt::StringView _effectName;
        ArbUt::List<EffectParameter*> _parameters;

    public:
        SecondaryEffect() noexcept : _chance(0), _effectName() {}
-        SecondaryEffect(float chance, const ArbUt::CaseInsensitiveConstString& effectName,
+        SecondaryEffect(float chance, const ArbUt::StringView& effectName,
                        const ArbUt::List<EffectParameter*>& parameters) noexcept
            : _chance(chance), _effectName(effectName), _parameters(parameters) {}

@ -26,7 +26,7 @@ namespace CreatureLib::Library {
        }

        constexpr inline float GetChance() const noexcept { return _chance; }
-        constexpr inline const ArbUt::CaseInsensitiveConstString& GetEffectName() const noexcept { return _effectName; }
+        constexpr inline const ArbUt::StringView& GetEffectName() const noexcept { return _effectName; }
        const inline ArbUt::List<EffectParameter*>& GetParameters() const noexcept { return _parameters; }
    };
 }
--- a/src/Library/BaseLibrary.hpp
+++ b/src/Library/BaseLibrary.hpp
@ -4,9 +4,9 @@
 #include <Arbutils/Assert.hpp>
 #include <Arbutils/Collections/Dictionary.hpp>
 #include <Arbutils/Collections/List.hpp>
-#include <Arbutils/ConstString.hpp>
 #include <Arbutils/Memory/BorrowedPtr.hpp>
 #include <Arbutils/Random.hpp>
+#include <Arbutils/StringView.hpp>
 #include <algorithm>
 #include <memory>
 #include <string>
@ -22,7 +22,7 @@ namespace CreatureLib::Library {

        virtual ~BaseLibrary() noexcept { _values.Clear(); }

-        inline void Insert(const ArbUt::CaseInsensitiveConstString& key, const T* value) {
+        inline void Insert(const ArbUt::StringView& key, const T* value) {
            AssertNotNull(value)
            _values.GetStdMap().insert({key.GetHash(), std::unique_ptr<const T>(value)});
            _listValues.Append(key);
@ -33,7 +33,7 @@ namespace CreatureLib::Library {
            _listValues.Append(hashedKey);
        }

-        inline void Delete(const ArbUt::CaseInsensitiveConstString& key) noexcept {
+        inline void Delete(const ArbUt::StringView& key) noexcept {
            _values.erase(key.GetHash());
            auto k = _listValues.IndexOf(key);
            _listValues.Remove(k);
@ -44,7 +44,7 @@ namespace CreatureLib::Library {
            _listValues.Remove(k);
        }

-        bool TryGet(const ArbUt::CaseInsensitiveConstString& name, ArbUt::BorrowedPtr<const T>& out) const noexcept {
+        bool TryGet(const ArbUt::BasicStringView& name, ArbUt::BorrowedPtr<const T>& out) const noexcept {
            return TryGet(name.GetHash(), out);
        }
        bool TryGet(uint32_t hashedKey, ArbUt::BorrowedPtr<const T>& out) const noexcept {
@ -55,15 +55,14 @@ namespace CreatureLib::Library {
            return true;
        }

-        [[nodiscard]] inline ArbUt::BorrowedPtr<const T> Get(const ArbUt::CaseInsensitiveConstString& name) const {
+        [[nodiscard]] inline ArbUt::BorrowedPtr<const T> Get(const ArbUt::BasicStringView& name) const {
            return _values.Get(name.GetHash());
        }
        [[nodiscard]] inline ArbUt::BorrowedPtr<const T> Get(uint32_t hashedKey) const {
            return _values.Get(hashedKey);
        }

-        [[nodiscard]] inline ArbUt::BorrowedPtr<const T>
-        operator[](const ArbUt::CaseInsensitiveConstString& name) const {
+        [[nodiscard]] inline ArbUt::BorrowedPtr<const T> operator[](const ArbUt::BasicStringView& name) const {
            return Get(name);
        }
        [[nodiscard]] inline ArbUt::BorrowedPtr<const T> operator[](uint32_t hashedKey) const { return Get(hashedKey); }
--- a/src/Library/CreatureData/CreatureSpecies.cpp
+++ b/src/Library/CreatureData/CreatureSpecies.cpp
@ -3,18 +3,13 @@

 using namespace CreatureLib::Library;

-CreatureSpecies::CreatureSpecies(uint16_t id, const ArbUt::CaseInsensitiveConstString& name,
-                                 const SpeciesVariant* defaultVariant, float genderRatio,
-                                 const ArbUt::CaseInsensitiveConstString& growthRate, uint8_t captureRate)
+CreatureSpecies::CreatureSpecies(uint16_t id, const ArbUt::StringView& name, const SpeciesVariant* defaultVariant,
+                                 float genderRatio, const ArbUt::StringView& growthRate, uint8_t captureRate)
    : _name(name), _id(id), _genderRate(genderRatio), _growthRate(growthRate), _captureRate(captureRate), _variants(1) {
    AssertNotNull(defaultVariant)
    SetVariant("default"_cnc, defaultVariant);
 }

-bool CreatureSpecies::TryGetVariant(const ArbUt::CaseInsensitiveConstString& name,
-                                    ArbUt::BorrowedPtr<const SpeciesVariant>& out) const noexcept {
-    return TryGetVariant(name.GetHash(), out);
-}
 bool CreatureSpecies::TryGetVariant(uint32_t hash, ArbUt::BorrowedPtr<const SpeciesVariant>& out) const noexcept {
    auto find = _variants.GetStdMap().find(hash);
    if (find == _variants.end())
@ -23,7 +18,7 @@ bool CreatureSpecies::TryGetVariant(uint32_t hash, ArbUt::BorrowedPtr<const Spec
    return true;
 }

-void CreatureSpecies::SetVariant(const ArbUt::CaseInsensitiveConstString& name, const SpeciesVariant* variant) {
+void CreatureSpecies::SetVariant(const ArbUt::StringView& name, const SpeciesVariant* variant) {
    _variants.GetStdMap().insert({name, std::unique_ptr<const SpeciesVariant>(variant)});
 }

--- a/src/Library/CreatureData/CreatureSpecies.hpp
+++ b/src/Library/CreatureData/CreatureSpecies.hpp
@ -2,8 +2,8 @@
 #define CREATURELIB_CREATURESPECIES_HPP

 #include <Arbutils/Collections/Dictionary.hpp>
-#include <Arbutils/ConstString.hpp>
 #include <Arbutils/Memory/BorrowedPtr.hpp>
+#include <Arbutils/StringView.hpp>
 #include <memory>
 #include <string>
 #include <unordered_map>
@ -16,43 +16,44 @@ namespace CreatureLib::Library {
    creatures with.
     */
    class CreatureSpecies {
-        const ArbUt::CaseInsensitiveConstString _name;
+        const ArbUt::StringView _name;
        uint16_t _id;
        float _genderRate;
-        const ArbUt::CaseInsensitiveConstString _growthRate;
+        const ArbUt::StringView _growthRate;
        uint8_t _captureRate;
        ArbUt::Dictionary<uint32_t, std::unique_ptr<const SpeciesVariant>> _variants;

    public:
-        CreatureSpecies(uint16_t id, const ArbUt::CaseInsensitiveConstString& name,
-                        const SpeciesVariant* defaultVariant, float genderRatio,
-                        const ArbUt::CaseInsensitiveConstString& growthRate, uint8_t captureRate);
+        CreatureSpecies(uint16_t id, const ArbUt::StringView& name, const SpeciesVariant* defaultVariant,
+                        float genderRatio, const ArbUt::StringView& growthRate, uint8_t captureRate);

        virtual ~CreatureSpecies() noexcept { _variants.Clear(); }

        inline uint16_t GetId() const noexcept { return _id; }
        inline float GetGenderRate() const noexcept { return _genderRate; }
-        inline const ArbUt::CaseInsensitiveConstString& GetGrowthRate() const noexcept { return _growthRate; }
+        inline const ArbUt::StringView& GetGrowthRate() const noexcept { return _growthRate; }
        inline uint8_t GetCaptureRate() const noexcept { return _captureRate; }

-        [[nodiscard]] inline bool HasVariant(const ArbUt::CaseInsensitiveConstString& key) const noexcept {
+        [[nodiscard]] inline bool HasVariant(const ArbUt::BasicStringView& key) const noexcept {
            return _variants.Has(key);
        }
        [[nodiscard]] inline bool HasVariant(uint32_t hash) const noexcept { return _variants.Has(hash); }
-        [[nodiscard]] bool TryGetVariant(const ArbUt::CaseInsensitiveConstString& name,
-                                         ArbUt::BorrowedPtr<const SpeciesVariant>& out) const noexcept;
+        [[nodiscard]] inline bool TryGetVariant(const ArbUt::BasicStringView& name,
+                                                ArbUt::BorrowedPtr<const SpeciesVariant>& out) const noexcept {
+            return TryGetVariant(name.GetHash(), out);
+        }
        [[nodiscard]] bool TryGetVariant(uint32_t hash, ArbUt::BorrowedPtr<const SpeciesVariant>& out) const noexcept;
        [[nodiscard]] inline ArbUt::BorrowedPtr<const SpeciesVariant>
-        GetVariant(const ArbUt::CaseInsensitiveConstString& key) const {
+        GetVariant(const ArbUt::BasicStringView& key) const {
            return _variants.Get(key);
        }
        [[nodiscard]] inline ArbUt::BorrowedPtr<const SpeciesVariant> GetVariant(uint32_t key) const {
            return _variants.Get(key);
        }
        [[nodiscard]] Gender GetRandomGender(ArbUt::Random& rand) const noexcept;
-        [[nodiscard]] inline const ArbUt::CaseInsensitiveConstString& GetName() const { return _name; }
+        [[nodiscard]] inline const ArbUt::StringView& GetName() const { return _name; }

-        void SetVariant(const ArbUt::CaseInsensitiveConstString& name, const SpeciesVariant* variant);
+        void SetVariant(const ArbUt::StringView& name, const SpeciesVariant* variant);

        inline const ArbUt::Dictionary<uint32_t, std::unique_ptr<const SpeciesVariant>>& GetVariantsIterator() const {
            return _variants;
--- a/src/Library/CreatureData/SpeciesVariant.cpp
+++ b/src/Library/CreatureData/SpeciesVariant.cpp
@ -2,7 +2,7 @@
 #include <algorithm>

 const CreatureLib::Library::TalentIndex
-CreatureLib::Library::SpeciesVariant::GetTalentIndex(const ArbUt::CaseInsensitiveConstString& talent) const {
+CreatureLib::Library::SpeciesVariant::GetTalentIndex(const ArbUt::StringView& talent) const {
    for (size_t i = 0; i < _talents.Count(); i++) {
        if (_talents.At(i) == talent) {
            return TalentIndex(false, i);
--- a/src/Library/CreatureData/SpeciesVariant.hpp
+++ b/src/Library/CreatureData/SpeciesVariant.hpp
@ -16,7 +16,7 @@ namespace CreatureLib::Library {
     */
    class SpeciesVariant {
    protected:
-        ArbUt::CaseInsensitiveConstString _name;
+        ArbUt::StringView _name;
        float _height;
        float _weight;
        uint32_t _baseExperience;
@ -24,22 +24,20 @@ namespace CreatureLib::Library {
    private:
        ArbUt::List<uint8_t> _types;
        Library::StatisticSet<uint16_t> _baseStatistics;
-        ArbUt::List<ArbUt::CaseInsensitiveConstString> _talents;
-        ArbUt::List<ArbUt::CaseInsensitiveConstString> _secretTalents;
+        ArbUt::List<ArbUt::StringView> _talents;
+        ArbUt::List<ArbUt::StringView> _secretTalents;
        std::unique_ptr<const LearnableAttacks> _attacks;

    public:
-        SpeciesVariant(const ArbUt::CaseInsensitiveConstString& name, float height, float weight,
-                       uint32_t baseExperience, const ArbUt::List<uint8_t>& types,
-                       Library::StatisticSet<uint16_t> baseStats,
-                       const ArbUt::List<ArbUt::CaseInsensitiveConstString>& talents,
-                       const ArbUt::List<ArbUt::CaseInsensitiveConstString>& secretTalents,
-                       const LearnableAttacks* attacks)
+        SpeciesVariant(const ArbUt::StringView& name, float height, float weight, uint32_t baseExperience,
+                       const ArbUt::List<uint8_t>& types, Library::StatisticSet<uint16_t> baseStats,
+                       const ArbUt::List<ArbUt::StringView>& talents,
+                       const ArbUt::List<ArbUt::StringView>& secretTalents, const LearnableAttacks* attacks)
            : _name(name), _height(height), _weight(weight), _baseExperience(baseExperience), _types((types)),
              _baseStatistics(baseStats), _talents(talents), _secretTalents(secretTalents), _attacks(attacks){};
        virtual ~SpeciesVariant() = default;

-        inline const ArbUt::CaseInsensitiveConstString& GetName() const { return _name; }
+        inline const ArbUt::StringView& GetName() const { return _name; }
        inline float GetHeight() const { return _height; }
        inline float GetWeight() const { return _weight; }
        inline uint32_t GetBaseExperience() const { return _baseExperience; }
@ -52,7 +50,7 @@ namespace CreatureLib::Library {
        }
        [[nodiscard]] inline const size_t GetTalentCount() const noexcept { return _talents.Count(); }
        [[nodiscard]] inline const size_t GetSecretTalentCount() const noexcept { return _secretTalents.Count(); }
-        [[nodiscard]] const ArbUt::CaseInsensitiveConstString& GetTalent(const TalentIndex& index) const {
+        [[nodiscard]] const ArbUt::StringView& GetTalent(const TalentIndex& index) const {
            if (index.IsSecret() && _secretTalents.Count() > 0) {
                auto i = index.GetIndex();
                if (i > _secretTalents.Count())
@ -64,7 +62,7 @@ namespace CreatureLib::Library {
                i = _talents.Count();
            return _talents.At(i);
        }
-        [[nodiscard]] const TalentIndex GetTalentIndex(const ArbUt::CaseInsensitiveConstString& talent) const;
+        [[nodiscard]] const TalentIndex GetTalentIndex(const ArbUt::StringView& talent) const;

        [[nodiscard]] inline ArbUt::BorrowedPtr<const CreatureLib::Library::LearnableAttacks>
        GetLearnableAttacks() const {
@ -73,12 +71,8 @@ namespace CreatureLib::Library {
        [[nodiscard]] inline TalentIndex GetRandomTalent(ArbUt::Random* rand) const noexcept {
            return TalentIndex(false, rand->Get(_talents.Count()));
        }
-        [[nodiscard]] inline const ArbUt::List<ArbUt::CaseInsensitiveConstString>& GetTalents() const {
-            return _talents;
-        }
-        [[nodiscard]] inline const ArbUt::List<ArbUt::CaseInsensitiveConstString>& GetSecretTalents() const {
-            return _secretTalents;
-        }
+        [[nodiscard]] inline const ArbUt::List<ArbUt::StringView>& GetTalents() const { return _talents; }
+        [[nodiscard]] inline const ArbUt::List<ArbUt::StringView>& GetSecretTalents() const { return _secretTalents; }
    };
 }

--- a/src/Library/EffectParameter.hpp
+++ b/src/Library/EffectParameter.hpp
@ -1,7 +1,7 @@
 #ifndef CREATURELIB_EFFECTPARAMETER_HPP
 #define CREATURELIB_EFFECTPARAMETER_HPP
-#include <Arbutils/ConstString.hpp>
 #include <Arbutils/Enum.hpp>
+#include <Arbutils/StringView.hpp>
 #include <variant>
 #include "Exceptions/CreatureException.hpp"

@ -11,15 +11,14 @@ namespace CreatureLib::Library {
    class EffectParameter {
    private:
        EffectParameterType _type = EffectParameterType::None;
-        std::variant<bool, int64_t, float, ArbUt::CaseInsensitiveConstString> _value;
+        std::variant<bool, int64_t, float, ArbUt::StringView> _value;

    public:
        inline EffectParameter() : _type(EffectParameterType::None){};
        inline explicit EffectParameter(bool b) : _type(EffectParameterType::Bool), _value(b){};
        inline explicit EffectParameter(int64_t i) : _type(EffectParameterType::Int), _value(i){};
        inline explicit EffectParameter(float f) : _type(EffectParameterType::Float), _value(f){};
-        inline explicit EffectParameter(const ArbUt::CaseInsensitiveConstString& s)
-            : _type(EffectParameterType::String), _value(s){};
+        inline explicit EffectParameter(const ArbUt::StringView& s) : _type(EffectParameterType::String), _value(s){};
        EffectParameter(const EffectParameter& other) = delete;
        EffectParameter& operator=(const EffectParameter& other) = delete;

@ -54,13 +53,13 @@ namespace CreatureLib::Library {
            }
            return std::get<float>(_value);
        }
-        const ArbUt::CaseInsensitiveConstString& AsString() const {
+        const ArbUt::StringView& AsString() const {
            if (_type != EffectParameterType::String) {
                std::stringstream ss;
                ss << "Cast effect parameter to string, but was " << EffectParameterTypeHelper::ToString(_type);
                throw CreatureException(ss.str());
            }
-            return std::get<ArbUt::CaseInsensitiveConstString>(_value);
+            return std::get<ArbUt::StringView>(_value);
        }
    };
 }
--- a/src/Library/GrowthRates/GrowthRateLibrary.cpp
+++ b/src/Library/GrowthRates/GrowthRateLibrary.cpp
@ -1,7 +1,7 @@
 #include "GrowthRateLibrary.hpp"
 #include "../Exceptions/CreatureException.hpp"

-uint8_t CreatureLib::Library::GrowthRateLibrary::CalculateLevel(const ConstString& growthRate,
+uint8_t CreatureLib::Library::GrowthRateLibrary::CalculateLevel(const ArbUt::BasicStringView& growthRate,
                                                                uint32_t experience) const {
    auto find = _growthRates.find(growthRate);
    if (find == _growthRates.end()) {
@ -18,7 +18,7 @@ uint8_t CreatureLib::Library::GrowthRateLibrary::CalculateLevel(uint32_t hash, u
    return find->second->CalculateLevel(experience);
 }

-uint32_t CreatureLib::Library::GrowthRateLibrary::CalculateExperience(const ConstString& growthRate,
+uint32_t CreatureLib::Library::GrowthRateLibrary::CalculateExperience(const ArbUt::BasicStringView& growthRate,
                                                                      uint8_t level) const {
    auto find = _growthRates.find(growthRate);
    if (find == _growthRates.end()) {
@ -35,7 +35,7 @@ uint32_t CreatureLib::Library::GrowthRateLibrary::CalculateExperience(uint32_t h
    return find->second->CalculateExperience(level);
 }

-void CreatureLib::Library::GrowthRateLibrary::AddGrowthRate(const ConstString& name,
+void CreatureLib::Library::GrowthRateLibrary::AddGrowthRate(const ArbUt::StringView& name,
                                                            CreatureLib::Library::GrowthRate* rate) {
    _growthRates.insert({name, std::unique_ptr<const GrowthRate>(rate)});
 }
--- a/src/Library/GrowthRates/GrowthRateLibrary.hpp
+++ b/src/Library/GrowthRates/GrowthRateLibrary.hpp
@ -1,15 +1,13 @@
 #ifndef CREATURELIB_GROWTHRATELIBRARY_HPP
 #define CREATURELIB_GROWTHRATELIBRARY_HPP

-#include <Arbutils/ConstString.hpp>
+#include <Arbutils/StringView.hpp>
 #include <cstdint>
 #include <memory>
 #include <string>
 #include <unordered_map>
 #include "GrowthRate.hpp"

-using ConstString = ArbUt::CaseInsensitiveConstString;
-
 namespace CreatureLib::Library {
    class GrowthRateLibrary {
    private:
@ -21,13 +19,13 @@ namespace CreatureLib::Library {

        virtual ~GrowthRateLibrary() = default;

-        [[nodiscard]] uint8_t CalculateLevel(const ConstString& growthRate, uint32_t experience) const;
+        [[nodiscard]] uint8_t CalculateLevel(const ArbUt::BasicStringView& growthRate, uint32_t experience) const;
        [[nodiscard]] uint8_t CalculateLevel(uint32_t hash, uint32_t experience) const;
-        [[nodiscard]] uint32_t CalculateExperience(const ConstString& growthRate, uint8_t level) const;
+        [[nodiscard]] uint32_t CalculateExperience(const ArbUt::BasicStringView& growthRate, uint8_t level) const;
        [[nodiscard]] uint32_t CalculateExperience(uint32_t hash, uint8_t level) const;

        void AddGrowthRate(uint32_t hash, GrowthRate* rate);
-        void AddGrowthRate(const ConstString& name, GrowthRate* rate);
+        void AddGrowthRate(const ArbUt::StringView& name, GrowthRate* rate);
    };
 }

--- a/src/Library/Items/Item.hpp
+++ b/src/Library/Items/Item.hpp
@ -1,7 +1,7 @@
 #ifndef CREATURELIB_ITEM_HPP
 #define CREATURELIB_ITEM_HPP

-#include <Arbutils/ConstString.hpp>
+#include <Arbutils/StringView.hpp>
 #include <string>
 #include <unordered_set>
 #include "BattleItemCategory.hpp"
@ -10,27 +10,24 @@
 namespace CreatureLib::Library {
    class Item {
    protected:
-        ArbUt::CaseInsensitiveConstString _name;
+        ArbUt::StringView _name;
        ItemCategory _category;
        BattleItemCategory _battleCategory;
        int32_t _price;
        std::unordered_set<uint32_t> _flags;

    public:
-        inline Item(const ArbUt::CaseInsensitiveConstString& name, ItemCategory category,
-                    BattleItemCategory battleCategory, int32_t price,
-                    const std::unordered_set<uint32_t>& flags) noexcept
+        inline Item(const ArbUt::StringView& name, ItemCategory category, BattleItemCategory battleCategory,
+                    int32_t price, const std::unordered_set<uint32_t>& flags) noexcept
            : _name(name), _category(category), _battleCategory(battleCategory), _price(price), _flags(flags) {}

-        inline const ArbUt::CaseInsensitiveConstString& GetName() const noexcept { return _name; }
+        inline const ArbUt::StringView& GetName() const noexcept { return _name; }
        inline ItemCategory GetCategory() const noexcept { return _category; }
        inline BattleItemCategory GetBattleCategory() const noexcept { return _battleCategory; }
        inline const int32_t GetPrice() const noexcept { return _price; }

-        bool HasFlag(const ArbUt::CaseInsensitiveConstString& flag) const noexcept {
-            return this->_flags.find(flag) != this->_flags.end();
-        }
-        bool HasFlag(uint32_t flag) const noexcept { return this->_flags.find(flag) != this->_flags.end(); }
+        bool HasFlag(const ArbUt::BasicStringView& flag) const noexcept { return this->_flags.contains(flag); }
+        bool HasFlag(uint32_t flag) const noexcept { return this->_flags.contains(flag); }
    };
 }

--- a/src/Library/TypeLibrary.cpp
+++ b/src/Library/TypeLibrary.cpp
@ -3,7 +3,7 @@

 using namespace CreatureLib::Library;

-uint8_t TypeLibrary::RegisterType(const ArbUt::CaseInsensitiveConstString& key) {
+uint8_t TypeLibrary::RegisterType(const ArbUt::StringView& key) {
    _types.Insert(key, _types.Count());
    _effectiveness.Resize(_types.Count());
    for (auto& eff : _effectiveness) {
--- a/src/Library/TypeLibrary.hpp
+++ b/src/Library/TypeLibrary.hpp
@ -3,7 +3,7 @@

 #include <Arbutils/Collections/Dictionary.hpp>
 #include <Arbutils/Collections/List.hpp>
-#include <Arbutils/ConstString.hpp>
+#include <Arbutils/StringView.hpp>
 #include <numeric>
 #include <unordered_set>
 #include <vector>
@ -16,7 +16,7 @@ namespace CreatureLib::Library {
    public:
        TypeLibrary(size_t initialCapacity = 20) : _types(ArbUt::Dictionary<uint32_t, uint8_t>(initialCapacity)) {}

-        inline uint8_t GetTypeId(const ArbUt::CaseInsensitiveConstString& key) const { return _types.Get(key); }
+        inline uint8_t GetTypeId(const ArbUt::BasicStringView& key) const { return _types.Get(key); }
        inline uint8_t GetTypeId(uint32_t s) const { return _types.Get(s); }
        [[nodiscard]] inline float GetSingleEffectiveness(uint8_t attacking, uint8_t defensive) const {
            return _effectiveness[attacking][defensive];
@ -29,7 +29,7 @@ namespace CreatureLib::Library {
                                   });
        }

-        uint8_t RegisterType(const ArbUt::CaseInsensitiveConstString& typeName);
+        uint8_t RegisterType(const ArbUt::StringView& typeName);
        uint8_t RegisterType(uint32_t typeHash);
        void SetEffectiveness(uint8_t attacking, uint8_t defensive, float effectiveness);
    };
--- a/tests/BattleTests/ScriptTests/ScriptAggregatorTests.cpp
+++ b/tests/BattleTests/ScriptTests/ScriptAggregatorTests.cpp
@ -9,11 +9,11 @@ using namespace CreatureLib::Battling;

 class TestScript : public Script {
 private:
-    ArbUt::CaseInsensitiveConstString _name;
+    ArbUt::StringView _name;

 public:
    explicit TestScript(std::string name) : _name(std::move(name)){};
-    const ArbUt::CaseInsensitiveConstString& GetName() const noexcept override { return _name; }
+    const ArbUt::StringView& GetName() const noexcept override { return _name; }

    void TestMethod(int& runCount) { runCount++; }
 };
--- a/tests/BattleTests/ScriptTests/ScriptSetTests.cpp
+++ b/tests/BattleTests/ScriptTests/ScriptSetTests.cpp
@ -9,11 +9,11 @@ using namespace CreatureLib::Battling;

 class TestScript : public Script {
 private:
-    ArbUt::CaseInsensitiveConstString _name;
+    ArbUt::StringView _name;

 public:
    explicit TestScript(std::string name) : _name(std::move(name)){};
-    const ArbUt::CaseInsensitiveConstString& GetName() const noexcept override { return _name; }
+    const ArbUt::StringView& GetName() const noexcept override { return _name; }
 };

 TEST_CASE("Empty script set count == 0", "[Battling, Scripting]") {
--- a/tests/BattleTests/ScriptTests/ScriptSourceTest.cpp
+++ b/tests/BattleTests/ScriptTests/ScriptSourceTest.cpp
@ -10,11 +10,11 @@ using namespace CreatureLib::Battling;

 class TestScript : public Script {
 private:
-    ArbUt::CaseInsensitiveConstString _name;
+    ArbUt::StringView _name;

 public:
    explicit TestScript(std::string name) : _name(std::move(name)){};
-    const ArbUt::CaseInsensitiveConstString& GetName() const noexcept override { return _name; }
+    const ArbUt::StringView& GetName() const noexcept override { return _name; }

    void TestMethod(int& runCount) { runCount++; }
 };
--- a/tests/Integration/BattleIntegrations.cpp
+++ b/tests/Integration/BattleIntegrations.cpp
@ -232,23 +232,23 @@ TEST_CASE("Switch Creature in, mark as seen opponent for opponent", "[Integratio

    auto seen = c3->GetSeenOpponents();
    REQUIRE(seen.size() == 1);
-    REQUIRE(seen.find(c1) != seen.end());
+    REQUIRE(seen.contains(c1));

    battle.TrySetChoice(new SwitchTurnChoice(c1, c2));
    battle.TrySetChoice(new PassTurnChoice(c3));

    seen = c3->GetSeenOpponents();
    REQUIRE(seen.size() == 2);
-    REQUIRE(seen.find(c1) != seen.end());
-    REQUIRE(seen.find(c2) != seen.end());
+    REQUIRE(seen.contains(c1));
+    REQUIRE(seen.contains(c2));

    battle.TrySetChoice(new SwitchTurnChoice(c2, c1));
    battle.TrySetChoice(new PassTurnChoice(c3));

    seen = c3->GetSeenOpponents();
    REQUIRE(seen.size() == 2);
-    REQUIRE(seen.find(c1) != seen.end());
-    REQUIRE(seen.find(c2) != seen.end());
+    REQUIRE(seen.contains(c1));
+    REQUIRE(seen.contains(c2));
 }

 TEST_CASE("Flee Battle", "[Integrations]") {
--- a/tests/LibraryTests/EffectParameterTests.cpp
+++ b/tests/LibraryTests/EffectParameterTests.cpp
@ -17,7 +17,7 @@ TEST_CASE("Int EffectParameter", "[Library]") {
 }

 TEST_CASE("String EffectParameter", "[Library]") {
-    auto p = EffectParameter((ArbUt::CaseInsensitiveConstString) "foobar"_cnc);
+    auto p = EffectParameter((ArbUt::StringView) "foobar"_cnc);
    REQUIRE(p.AsString() == "foobar");
 }