Cleanup after RYML merge (#6785)

Speeded things up even more by making use of C++'s reference feature.
Fixed #6770 warning while at it.
Added back support for case insensitive booleans.
Fixed a very rare issue with cached databases.
Removed .children() calls
Added back type safety reports
Added ryml to login-server makefile

Thanks to @aleos89, @Atemo and @idk-whoami

src/char/int_guild.cpp

@@ -744,7 +744,7 @@ const std::string GuildExpDatabase::getDefaultLocation() {
 	return std::string(db_path) + "/exp_guild.yml";
 }
 
-uint64 GuildExpDatabase::parseBodyNode(const ryml::NodeRef node) {
+uint64 GuildExpDatabase::parseBodyNode(const ryml::NodeRef& node) {
 	if (!this->nodesExist(node, { "Level", "Exp" })) {
 		return 0;
 	}

src/char/int_guild.hpp

@@ -39,7 +39,7 @@ public:
 	}
 
 	const std::string getDefaultLocation() override;
-	uint64 parseBodyNode(const ryml::NodeRef node) override;
+	uint64 parseBodyNode(const ryml::NodeRef& node) override;
 	void loadingFinished() override;
 
 	// Additional

src/char/inter.cpp

@@ -898,7 +898,7 @@ const std::string InterServerDatabase::getDefaultLocation(){
  * @param node: YAML node containing the entry.
  * @return count of successfully parsed rows
  */
-uint64 InterServerDatabase::parseBodyNode( const ryml::NodeRef node ){
+uint64 InterServerDatabase::parseBodyNode( const ryml::NodeRef& node ){
 	uint32 id;
 
 	if( !this->asUInt32( node, "ID", id ) ){

src/char/inter.hpp

@@ -21,7 +21,7 @@ public:
 	}
 
 	const std::string getDefaultLocation() override;
-	uint64 parseBodyNode( const ryml::NodeRef node ) override;
+	uint64 parseBodyNode( const ryml::NodeRef& node ) override;
 };
 
 extern InterServerDatabase interServerDb;

src/common/core.cpp

@@ -366,7 +366,7 @@ int main (int argc, char **argv)
 	Sql_Init();
 	db_init();
 	signals_init();
-
+	do_init_database();
 #ifdef _WIN32
 	cevents_init();
 #endif

src/common/database.cpp

@@ -3,17 +3,20 @@
 
 #include "database.hpp"
 
+#include <iostream>
+#include <sstream>
+
 #include "malloc.hpp"
 #include "showmsg.hpp"
+#include "utilities.hpp"
 
-#include <iostream>
-#include <sstream>
+using namespace rathena;
 
-bool YamlDatabase::nodeExists( const ryml::NodeRef node, const std::string& name ){
+bool YamlDatabase::nodeExists( const ryml::NodeRef& node, const std::string& name ){
 	return (node.num_children() > 0 && node.has_child(c4::to_csubstr(name)));
 }
 
-bool YamlDatabase::nodesExist( const ryml::NodeRef node, std::initializer_list<const std::string> names ){
+bool YamlDatabase::nodesExist( const ryml::NodeRef& node, std::initializer_list<const std::string> names ){
 	bool missing = false;
 
 	for( const std::string& name : names ){
@@ -37,17 +40,14 @@ bool YamlDatabase::verifyCompatibility( const ryml::Tree& tree ){
 		return false;
 	}
 
-	const ryml::NodeRef headerNode = tree["Header"];
+	const ryml::NodeRef& headerNode = tree["Header"];
 
-	if( !this->nodeExists( headerNode, "Type" ) ){
-		ShowError( "No database \"Type\" was found.\n" );
+	std::string tmpType;
+
+	if( !this->asString( headerNode, "Type", tmpType ) ){
 		return false;
 	}
 
-	const ryml::NodeRef typeNode = headerNode["Type"];
-	std::string tmpType;
-	typeNode >> tmpType;
-
 	if( this->type != tmpType ){
 		ShowError( "Database type mismatch: %s != %s.\n", this->type.c_str(), tmpType.c_str() );
 		return false;
@@ -56,7 +56,6 @@ bool YamlDatabase::verifyCompatibility( const ryml::Tree& tree ){
 	uint16 tmpVersion;
 
 	if( !this->asUInt16( headerNode, "Version", tmpVersion ) ){
-		ShowError("Invalid header \"Version\" type for %s database.\n", this->type.c_str());
 		return false;
 	}
 
@@ -91,7 +90,6 @@ bool YamlDatabase::reload(){
 }
 
 bool YamlDatabase::load(const std::string& path) {
-	char* buf = nullptr;
 	ShowStatus("Loading '" CL_WHITE "%s" CL_RESET "'..." CL_CLL "\r", path.c_str());
 	FILE* f = fopen(path.c_str(), "r");
 	if (f == nullptr) {
@@ -100,10 +98,11 @@ bool YamlDatabase::load(const std::string& path) {
 	}
 	fseek(f, 0, SEEK_END);
 	size_t size = ftell(f);
-	buf = (char *)aMalloc(size+1);
-	memset(buf, 0, size+1);
+	char* buf = (char *)aMalloc(size+1);
 	rewind(f);
-	fread(buf, sizeof(char), size, f);
+	size_t real_size = fread(buf, sizeof(char), size, f);
+	// Zero terminate
+	buf[real_size] = '\0';
 	fclose(f);
 
 	parser = {};
@@ -118,7 +117,7 @@ bool YamlDatabase::load(const std::string& path) {
 		return false;
 	}
 
-	const ryml::NodeRef header = tree["Header"];
+	const ryml::NodeRef& header = tree["Header"];
 
 	if( this->nodeExists( header, "Clear" ) ){
 		bool clear;
@@ -144,12 +143,12 @@ void YamlDatabase::parse( const ryml::Tree& tree ){
 	uint64 count = 0;
 
 	if( this->nodeExists( tree.rootref(), "Body" ) ){
-		const ryml::NodeRef bodyNode = tree["Body"];
+		const ryml::NodeRef& bodyNode = tree["Body"];
 		size_t childNodesCount = bodyNode.num_children();
 		size_t childNodesProgressed = 0;
 		const char* fileName = this->currentFile.c_str();
 
-		for( const ryml::NodeRef &node : bodyNode.children() ){
+		for( const ryml::NodeRef &node : bodyNode ){
 			count += this->parseBodyNode( node );
 
 			ShowStatus( "Loading [%" PRIdPTR "/%" PRIdPTR "] entries from '" CL_WHITE "%s" CL_RESET "'" CL_CLL "\r", ++childNodesProgressed, childNodesCount, fileName );
@@ -161,12 +160,12 @@ void YamlDatabase::parse( const ryml::Tree& tree ){
 
 void YamlDatabase::parseImports( const ryml::Tree& rootNode ){
 	if( this->nodeExists( rootNode.rootref(), "Footer" ) ){
-		const ryml::NodeRef footerNode = rootNode["Footer"];
+		const ryml::NodeRef& footerNode = rootNode["Footer"];
 
 		if( this->nodeExists( footerNode, "Imports") ){
-			const ryml::NodeRef importsNode = footerNode["Imports"];
+			const ryml::NodeRef& importsNode = footerNode["Imports"];
 
-			for( const ryml::NodeRef &node : importsNode.children() ){
+			for( const ryml::NodeRef &node : importsNode ){
 				std::string importFile;
 
 				if( !this->asString( node, "Path", importFile ) ){
@@ -198,16 +197,21 @@ void YamlDatabase::parseImports( const ryml::Tree& rootNode ){
 	}
 }
 
-template <typename R> bool YamlDatabase::asType( const ryml::NodeRef node, const std::string& name, R& out ){
+template <typename R> bool YamlDatabase::asType( const ryml::NodeRef& node, const std::string& name, R& out ){
 	if( this->nodeExists( node, name ) ){
-		const ryml::NodeRef dataNode = node[c4::to_csubstr(name)];
+		const ryml::NodeRef& dataNode = node[c4::to_csubstr(name)];
 
 		if (dataNode.val_is_null()) {
 			this->invalidWarning(node, "Node \"%s\" is missing a value.\n", name.c_str());
 			return false;
 		}
 
-		dataNode >> out;
+		try{
+			dataNode >> out;
+		}catch( std::runtime_error const& ){
+			this->invalidWarning( node, "Node \"%s\" cannot be parsed as %s.\n", name.c_str(), typeid( R ).name() );
+			return false;
+		}
 
 		return true;
 	}else{
@@ -216,62 +220,69 @@ template <typename R> bool YamlDatabase::asType( const ryml::NodeRef node, const
 	}
 }
 
-bool YamlDatabase::asBool(const ryml::NodeRef node, const std::string &name, bool &out) {
-	const auto targetNode = node[c4::to_csubstr(name)];
+bool YamlDatabase::asBool(const ryml::NodeRef& node, const std::string &name, bool &out) {
+	const ryml::NodeRef& targetNode = node[c4::to_csubstr(name)];
 
 	if (targetNode.val_is_null()) {
 		this->invalidWarning(node, "Node \"%s\" is missing a value.\n", name.c_str());
 		return false;
 	}
 
-	if (targetNode.val() == "true") {
+	std::string str;
+
+	targetNode >> str;
+
+	util::tolower( str );
+
+	if( str == "true" ){
 		out = true;
 		return true;
-	}
-	else if (targetNode.val() == "false") {
+	}else if( str == "false" ){
 		out = false;
 		return true;
+	}else{
+		this->invalidWarning( targetNode, "Unknown boolean value: \"%s\".\n", str.c_str() );
+		return false;
 	}
-	return false;
 }
 
-bool YamlDatabase::asInt16( const ryml::NodeRef node, const std::string& name, int16& out ){
+bool YamlDatabase::asInt16( const ryml::NodeRef& node, const std::string& name, int16& out ){
 	return asType<int16>( node, name, out);
 }
 
-bool YamlDatabase::asUInt16(const ryml::NodeRef node, const std::string& name, uint16& out) {
+bool YamlDatabase::asUInt16(const ryml::NodeRef& node, const std::string& name, uint16& out) {
 	return asType<uint16>(node, name, out);
 }
 
-bool YamlDatabase::asInt32(const ryml::NodeRef node, const std::string &name, int32 &out) {
+bool YamlDatabase::asInt32(const ryml::NodeRef& node, const std::string &name, int32 &out) {
 	return asType<int32>(node, name, out);
 }
 
-bool YamlDatabase::asUInt32(const ryml::NodeRef node, const std::string &name, uint32 &out) {
+bool YamlDatabase::asUInt32(const ryml::NodeRef& node, const std::string &name, uint32 &out) {
 	return asType<uint32>(node, name, out);
 }
 
-bool YamlDatabase::asInt64(const ryml::NodeRef node, const std::string &name, int64 &out) {
+bool YamlDatabase::asInt64(const ryml::NodeRef& node, const std::string &name, int64 &out) {
 	return asType<int64>(node, name, out);
 }
 
-bool YamlDatabase::asUInt64(const ryml::NodeRef node, const std::string &name, uint64 &out) {
+bool YamlDatabase::asUInt64(const ryml::NodeRef& node, const std::string &name, uint64 &out) {
 	return asType<uint64>(node, name, out);
 }
 
-bool YamlDatabase::asFloat(const ryml::NodeRef node, const std::string &name, float &out) {
+bool YamlDatabase::asFloat(const ryml::NodeRef& node, const std::string &name, float &out) {
 	return asType<float>(node, name, out);
 }
 
-bool YamlDatabase::asDouble(const ryml::NodeRef node, const std::string &name, double &out) {
+bool YamlDatabase::asDouble(const ryml::NodeRef& node, const std::string &name, double &out) {
 	return asType<double>(node, name, out);
 }
 
-bool YamlDatabase::asString(const ryml::NodeRef node, const std::string &name, std::string &out) {
+bool YamlDatabase::asString(const ryml::NodeRef& node, const std::string &name, std::string &out) {
 	return asType<std::string>(node, name, out);
 }
 
-bool YamlDatabase::asUInt16Rate( const ryml::NodeRef node, const std::string& name, uint16& out, uint16 maximum ){
+bool YamlDatabase::asUInt16Rate( const ryml::NodeRef& node, const std::string& name, uint16& out, uint16 maximum ){
 	if( this->asUInt16( node, name, out ) ){
 		if( out > maximum ){
 			this->invalidWarning( node[c4::to_csubstr(name)], "Node \"%s\" with value %" PRIu16 " exceeds maximum of %" PRIu16 ".\n", name.c_str(), out, maximum );
@@ -289,7 +300,7 @@ bool YamlDatabase::asUInt16Rate( const ryml::NodeRef node, const std::string& na
 	}
 }
 
-bool YamlDatabase::asUInt32Rate( const ryml::NodeRef node, const std::string& name, uint32& out, uint32 maximum ){
+bool YamlDatabase::asUInt32Rate( const ryml::NodeRef& node, const std::string& name, uint32& out, uint32 maximum ){
 	if( this->asUInt32( node, name, out ) ){
 		if( out > maximum ){
 			this->invalidWarning( node[c4::to_csubstr(name)], "Node \"%s\" with value %" PRIu32 " exceeds maximum of %" PRIu32 ".\n", name.c_str(), out, maximum );
@@ -307,15 +318,15 @@ bool YamlDatabase::asUInt32Rate( const ryml::NodeRef node, const std::string& na
 	}
 }
 
-int32 YamlDatabase::getLineNumber(const ryml::NodeRef node) {
+int32 YamlDatabase::getLineNumber(const ryml::NodeRef& node) {
 	return parser.source().has_str() ? (int32)parser.location(node).line : 0;
 }
 
-int32 YamlDatabase::getColumnNumber(const ryml::NodeRef node) {
+int32 YamlDatabase::getColumnNumber(const ryml::NodeRef& node) {
 	return parser.source().has_str() ? (int32)parser.location(node).col : 0;
 }
 
-void YamlDatabase::invalidWarning( const ryml::NodeRef node, const char* fmt, ... ){
+void YamlDatabase::invalidWarning( const ryml::NodeRef& node, const char* fmt, ... ){
 	va_list ap;
 
 	va_start(ap, fmt);
@@ -337,3 +348,11 @@ void YamlDatabase::invalidWarning( const ryml::NodeRef node, const char* fmt, ..
 std::string YamlDatabase::getCurrentFile(){
 	return this->currentFile;
 }
+
+void on_yaml_error( const char* msg, size_t len, ryml::Location loc, void *user_data ){
+	throw std::runtime_error( msg );
+}
+
+void do_init_database(){
+	ryml::set_callbacks( ryml::Callbacks( nullptr, nullptr, nullptr, on_yaml_error ) );
+}

src/common/database.hpp

@@ -28,38 +28,38 @@ private:
 	bool load( const std::string& path );
 	void parse( const ryml::Tree& rootNode );
 	void parseImports( const ryml::Tree& rootNode );
-	template <typename R> bool asType( const ryml::NodeRef node, const std::string& name, R& out );
+	template <typename R> bool asType( const ryml::NodeRef& node, const std::string& name, R& out );
 
 // These should be visible/usable by the implementation provider
 protected:
 	ryml::Parser parser;
 
 	// Helper functions
-	bool nodeExists( const ryml::NodeRef node, const std::string& name );
-	bool nodesExist( const ryml::NodeRef node, std::initializer_list<const std::string> names );
-	int32 getLineNumber(const ryml::NodeRef node);
-	int32 getColumnNumber(const ryml::NodeRef node);
-	void invalidWarning( const ryml::NodeRef node, const char* fmt, ... );
+	bool nodeExists( const ryml::NodeRef& node, const std::string& name );
+	bool nodesExist( const ryml::NodeRef& node, std::initializer_list<const std::string> names );
+	int32 getLineNumber(const ryml::NodeRef& node);
+	int32 getColumnNumber(const ryml::NodeRef& node);
+	void invalidWarning( const ryml::NodeRef& node, const char* fmt, ... );
 	std::string getCurrentFile();
 
 	// Conversion functions
-	bool asBool(const ryml::NodeRef node, const std::string &name, bool &out);
-	bool asInt16(const ryml::NodeRef node, const std::string& name, int16& out );
-	bool asUInt16(const ryml::NodeRef node, const std::string& name, uint16& out);
-	bool asInt32(const ryml::NodeRef node, const std::string &name, int32 &out);
-	bool asUInt32(const ryml::NodeRef node, const std::string &name, uint32 &out);
-	bool asInt64(const ryml::NodeRef node, const std::string &name, int64 &out);
-	bool asUInt64(const ryml::NodeRef node, const std::string &name, uint64 &out);
-	bool asFloat(const ryml::NodeRef node, const std::string &name, float &out);
-	bool asDouble(const ryml::NodeRef node, const std::string &name, double &out);
-	bool asString(const ryml::NodeRef node, const std::string &name, std::string &out);
-	bool asUInt16Rate(const ryml::NodeRef node, const std::string& name, uint16& out, uint16 maximum=10000);
-	bool asUInt32Rate(const ryml::NodeRef node, const std::string& name, uint32& out, uint32 maximum=10000);
+	bool asBool(const ryml::NodeRef& node, const std::string &name, bool &out);
+	bool asInt16(const ryml::NodeRef& node, const std::string& name, int16& out );
+	bool asUInt16(const ryml::NodeRef& node, const std::string& name, uint16& out);
+	bool asInt32(const ryml::NodeRef& node, const std::string &name, int32 &out);
+	bool asUInt32(const ryml::NodeRef& node, const std::string &name, uint32 &out);
+	bool asInt64(const ryml::NodeRef& node, const std::string &name, int64 &out);
+	bool asUInt64(const ryml::NodeRef& node, const std::string &name, uint64 &out);
+	bool asFloat(const ryml::NodeRef& node, const std::string &name, float &out);
+	bool asDouble(const ryml::NodeRef& node, const std::string &name, double &out);
+	bool asString(const ryml::NodeRef& node, const std::string &name, std::string &out);
+	bool asUInt16Rate(const ryml::NodeRef& node, const std::string& name, uint16& out, uint16 maximum=10000);
+	bool asUInt32Rate(const ryml::NodeRef& node, const std::string& name, uint32& out, uint32 maximum=10000);
 
 	virtual void loadingFinished();
 
 public:
-	YamlDatabase( const std::string type_, uint16 version_, uint16 minimumVersion_ ){
+	YamlDatabase( const std::string& type_, uint16 version_, uint16 minimumVersion_ ){
 		this->type = type_;
 		this->version = version_;
 		this->minimumVersion = minimumVersion_;
@@ -75,7 +75,7 @@ public:
 	// Functions that need to be implemented for each type
 	virtual void clear() = 0;
 	virtual const std::string getDefaultLocation() = 0;
-	virtual uint64 parseBodyNode( const ryml::NodeRef node ) = 0;
+	virtual uint64 parseBodyNode( const ryml::NodeRef& node ) = 0;
 };
 
 template <typename keytype, typename datatype> class TypesafeYamlDatabase : public YamlDatabase{
@@ -83,7 +83,7 @@ protected:
 	std::unordered_map<keytype, std::shared_ptr<datatype>> data;
 
 public:
-	TypesafeYamlDatabase( const std::string type_, uint16 version_, uint16 minimumVersion_ ) : YamlDatabase( type_, version_, minimumVersion_ ){
+	TypesafeYamlDatabase( const std::string& type_, uint16 version_, uint16 minimumVersion_ ) : YamlDatabase( type_, version_, minimumVersion_ ){
 	}
 
 	TypesafeYamlDatabase( const std::string& type_, uint16 version_ ) : YamlDatabase( type_, version_, version_ ){
@@ -145,7 +145,7 @@ private:
 	std::vector<std::shared_ptr<datatype>> cache;
 
 public:
-	TypesafeCachedYamlDatabase( const std::string type_, uint16 version_, uint16 minimumVersion_ ) : TypesafeYamlDatabase<keytype, datatype>( type_, version_, minimumVersion_ ){
+	TypesafeCachedYamlDatabase( const std::string& type_, uint16 version_, uint16 minimumVersion_ ) : TypesafeYamlDatabase<keytype, datatype>( type_, version_, minimumVersion_ ){
 
 	}
 
@@ -177,7 +177,7 @@ public:
 			size_t key = this->calculateCacheKey(pair.first);
 
 			// Check if the key fits into the current cache size
-			if (this->cache.capacity() < key) {
+			if (this->cache.capacity() <= key) {
 				// Double the current size, so we do not have to resize that often
 				size_t new_size = key * 2;
 
@@ -194,4 +194,6 @@ public:
 	}
 };
 
+void do_init_database();
+
 #endif /* DATABASE_HPP */

src/login/Makefile.in

@@ -11,6 +11,12 @@ LOGIN_OBJ = $(shell ls *.cpp | sed -e "s/\.cpp/\.o/g")
 LOGIN_DIR_OBJ = $(LOGIN_OBJ:%=obj/%)
 LOGIN_H = $(shell ls *.hpp)
 
+RAPIDYAML_OBJ = $(shell find ../../3rdparty/rapidyaml/ -type f -name "*.cpp" | sed -e "s/\.cpp/\.o/g" )
+RAPIDYAML_DIR_OBJ = $(RAPIDYAML_OBJ:%=obj/%)
+RAPIDYAML_AR = ../../3rdparty/rapidyaml/obj/ryml.a
+RAPIDYAML_H = $(shell find ../../3rdparty/rapidyaml/ -type f -name "*.h*")
+RAPIDYAML_INCLUDE = -I../../3rdparty/rapidyaml/src -I../../3rdparty/rapidyaml/ext/c4core/src
+
 HAVE_MYSQL=@HAVE_MYSQL@
 ifeq ($(HAVE_MYSQL),yes)
 	SERVER_DEPENDS=login-server
@@ -53,15 +59,15 @@ obj:
 
 #executables
 
-login-server: obj $(LOGIN_DIR_OBJ) $(COMMON_AR)
+login-server: obj $(LOGIN_DIR_OBJ) $(COMMON_AR) $(RAPIDYAML_AR)
 	@echo "	LD	@OLOG@@EXEEXT@"
-	@@CXX@ @LDFLAGS@ -o ../../@OLOG@@EXEEXT@ $(LOGIN_DIR_OBJ) $(COMMON_AR) $(LIBCONFIG_AR) @LIBS@ @MYSQL_LIBS@
+	@@CXX@ @LDFLAGS@ -o ../../@OLOG@@EXEEXT@ $(LOGIN_DIR_OBJ) $(COMMON_AR) $(LIBCONFIG_AR) $(RAPIDYAML_AR) @LIBS@ @MYSQL_LIBS@
 
 # login object files
 
-obj/%.o: %.cpp $(LOGIN_H) $(COMMON_H) $(LIBCONFIG_H)
+obj/%.o: %.cpp $(LOGIN_H) $(COMMON_H) $(LIBCONFIG_H) $(RAPIDYAML_H)
 	@echo "	CXX	$<"
-	@@CXX@ @CXXFLAGS@ $(COMMON_INCLUDE) $(LIBCONFIG_INCLUDE) -DWITH_SQL @MYSQL_CFLAGS@ @CPPFLAGS@ -c $(OUTPUT_OPTION) $<
+	@@CXX@ @CXXFLAGS@ $(COMMON_INCLUDE) $(LIBCONFIG_INCLUDE) $(RAPIDYAML_INCLUDE) -DWITH_SQL @MYSQL_CFLAGS@ @CPPFLAGS@ -c $(OUTPUT_OPTION) $<
 
 # missing object files
 $(COMMON_AR):
@@ -69,3 +75,6 @@ $(COMMON_AR):
 
 $(LIBCONFIG_AR):
 	@$(MAKE) -C ../../3rdparty/libconfig
+
+$(RAPIDYAML_AR):
+	@$(MAKE) -C ../../3rdparty/rapidyaml

src/map/achievement.cpp

@@ -46,7 +46,7 @@ const std::string AchievementDatabase::getDefaultLocation(){
  * @param node: YAML node containing the entry.
  * @return count of successfully parsed rows
  */
-uint64 AchievementDatabase::parseBodyNode(const ryml::NodeRef node){
+uint64 AchievementDatabase::parseBodyNode(const ryml::NodeRef& node){
 	uint32 achievement_id;
 
 	if( !this->asUInt32( node, "Id", achievement_id ) ){
@@ -97,9 +97,9 @@ uint64 AchievementDatabase::parseBodyNode(const ryml::NodeRef node){
 	}
 
 	if( this->nodeExists( node, "Targets" ) ){
-		const auto targets = node["Targets"];
+		const auto& targets = node["Targets"];
 
-		for( const auto targetNode : targets.children() ){
+		for( const auto& targetNode : targets ){
 			uint16 targetId;
 
 			if( !this->asUInt16( targetNode, "Id", targetId ) ){
@@ -230,9 +230,9 @@ uint64 AchievementDatabase::parseBodyNode(const ryml::NodeRef node){
 	}
 
 	if( this->nodeExists( node, "Dependents" ) ){
-		const auto dependentNode = node["Dependents"];
+		const auto& dependentNode = node["Dependents"];
 
-		for( const auto it : dependentNode.children() ){
+		for( const auto& it : dependentNode ){
 			auto id_str = it.key();
 			uint32 dependent_achievement_id;
 			c4::atou<uint32>(id_str, &dependent_achievement_id);
@@ -259,7 +259,7 @@ uint64 AchievementDatabase::parseBodyNode(const ryml::NodeRef node){
 	}
 
 	if( this->nodeExists( node, "Rewards" ) ){
-		const auto rewardNode = node["Rewards"];
+		const auto& rewardNode = node["Rewards"];
 
 		if( this->nodeExists( rewardNode, "Item" ) ){
 			std::string item_name;
@@ -387,7 +387,7 @@ const std::string AchievementLevelDatabase::getDefaultLocation(){
 	return std::string(db_path) + "/achievement_level_db.yml";
 }
 
-uint64 AchievementLevelDatabase::parseBodyNode( const ryml::NodeRef node ){
+uint64 AchievementLevelDatabase::parseBodyNode( const ryml::NodeRef& node ){
 	if( !this->nodesExist( node, { "Level", "Points" } ) ){
 		return 0;
 	}

src/map/achievement.hpp

@@ -108,7 +108,7 @@ public:
 
 	void clear() override;
 	const std::string getDefaultLocation() override;
-	uint64 parseBodyNode( const ryml::NodeRef node ) override;
+	uint64 parseBodyNode( const ryml::NodeRef& node ) override;
 	void loadingFinished() override;
 
 	// Additional
@@ -129,7 +129,7 @@ public:
 	}
 
 	const std::string getDefaultLocation() override;
-	uint64 parseBodyNode( const ryml::NodeRef node ) override;
+	uint64 parseBodyNode( const ryml::NodeRef& node ) override;
 };
 
 extern AchievementLevelDatabase achievement_level_db;

src/map/atcommand.cpp

@@ -105,7 +105,7 @@ public:
 
 	void clear() override;
 	const std::string getDefaultLocation() override;
-	uint64 parseBodyNode( const ryml::NodeRef node ) override;
+	uint64 parseBodyNode( const ryml::NodeRef& node ) override;
 
 	// Additional
 	const char* checkAlias( const char* alias );
@@ -120,7 +120,7 @@ const std::string AtcommandAliasDatabase::getDefaultLocation(){
 	return std::string(conf_path) + "/atcommands.yml";
 }
 
-uint64 AtcommandAliasDatabase::parseBodyNode( const ryml::NodeRef node ){
+uint64 AtcommandAliasDatabase::parseBodyNode( const ryml::NodeRef& node ){
 	std::string command;
 
 	if( !this->asString( node, "Command", command ) ){
@@ -153,14 +153,14 @@ uint64 AtcommandAliasDatabase::parseBodyNode( const ryml::NodeRef node ){
 	}
 
 	if( this->nodeExists( node, "Aliases" ) ){
-		const auto aliasesNode = node["Aliases"];
+		const auto& aliasesNode = node["Aliases"];
 
 		if( !aliasesNode.is_seq() ){
 			this->invalidWarning( aliasesNode, "Aliases should be a sequence.\n" );
 			return 0;
 		}
 
-		for( const auto subNode : aliasesNode.children() ){
+		for( const auto& subNode : aliasesNode ){
 			std::string alias;
 			subNode >> alias;
 

src/map/battleground.cpp

@@ -42,7 +42,7 @@ const std::string BattlegroundDatabase::getDefaultLocation() {
  * @param node: The YAML node containing the entry
  * @return count of successfully parsed rows
  */
-uint64 BattlegroundDatabase::parseBodyNode(const ryml::NodeRef node) {
+uint64 BattlegroundDatabase::parseBodyNode(const ryml::NodeRef& node) {
 	uint32 id;
 
 	if (!this->asUInt32(node, "Id", id))
@@ -172,7 +172,7 @@ uint64 BattlegroundDatabase::parseBodyNode(const ryml::NodeRef node) {
 	}
 
 	if (this->nodeExists(node, "Join")) {
-		const auto joinNode = node["Join"];
+		const auto& joinNode = node["Join"];
 
 		if (this->nodeExists(joinNode, "Solo")) {
 			bool active;
@@ -218,9 +218,9 @@ uint64 BattlegroundDatabase::parseBodyNode(const ryml::NodeRef node) {
 	}
 
 	if (this->nodeExists(node, "JobRestrictions")) {
-		const auto jobsNode = node["JobRestrictions"];
+		const auto& jobsNode = node["JobRestrictions"];
 
-		for (const auto jobit : jobsNode.children()) {
+		for (const auto& jobit : jobsNode) {
 			std::string job_name;
 			c4::from_chars(jobit.key(), &job_name);
 			std::string job_name_constant = "JOB_" + job_name;
@@ -246,7 +246,7 @@ uint64 BattlegroundDatabase::parseBodyNode(const ryml::NodeRef node) {
 	if (this->nodeExists(node, "Locations")) {
 		int count = 0;
 
-		for (const auto location : node["Locations"].children()) {
+		for (const auto& location : node["Locations"]) {
 			s_battleground_map map_entry;
 
 			if (this->nodeExists(location, "Map")) {

src/map/battleground.hpp

@@ -119,7 +119,7 @@ public:
 	}
 
 	const std::string getDefaultLocation() override;
-	uint64 parseBodyNode(const ryml::NodeRef node) override;
+	uint64 parseBodyNode(const ryml::NodeRef& node) override;
 };
 
 extern BattlegroundDatabase battleground_db;

src/map/elemental.cpp

@@ -668,7 +668,7 @@ const std::string ElementalDatabase::getDefaultLocation() {
  * @param node: YAML node containing the entry.
  * @return count of successfully parsed rows
  */
-uint64 ElementalDatabase::parseBodyNode(const ryml::NodeRef node) {
+uint64 ElementalDatabase::parseBodyNode(const ryml::NodeRef& node) {
 	int32 id;
 
 	if (!this->asInt32(node, "Id", id))
@@ -1059,9 +1059,9 @@ uint64 ElementalDatabase::parseBodyNode(const ryml::NodeRef node) {
 	elemental->status.aspd_rate = 1000;
 
 	if (this->nodeExists(node, "Mode")) {
-		const ryml::NodeRef ModeNode = node["Mode"];
+		const ryml::NodeRef& ModeNode = node["Mode"];
 
-		for (const auto &Modeit : ModeNode.children()) {
+		for (const auto &Modeit : ModeNode) {
 			std::string mode_name;
 			c4::from_chars(Modeit.key(), &mode_name);
 
@@ -1081,7 +1081,7 @@ uint64 ElementalDatabase::parseBodyNode(const ryml::NodeRef node) {
 			if (!mode_exists)
 				entry = std::make_shared<s_elemental_skill>();
 
-			const ryml::NodeRef SkillNode = ModeNode[Modeit.key()];
+			const ryml::NodeRef& SkillNode = ModeNode[Modeit.key()];
 			std::string skill_name;
 
 			if (!this->asString(SkillNode, "Skill", skill_name))

src/map/elemental.hpp

@@ -100,7 +100,7 @@ public:
 	}
 
 	const std::string getDefaultLocation() override;
-	uint64 parseBodyNode(const ryml::NodeRef node) override;
+	uint64 parseBodyNode(const ryml::NodeRef& node) override;
 };
 
 extern ElementalDatabase elemental_db;

src/map/guild.cpp

@@ -73,14 +73,14 @@ public:
 	}
 
 	const std::string getDefaultLocation() override;
-	uint64 parseBodyNode( const ryml::NodeRef node ) override;
+	uint64 parseBodyNode( const ryml::NodeRef& node ) override;
 };
 
 const std::string GuildSkillTreeDatabase::getDefaultLocation(){
 	return std::string(db_path) + "/guild_skill_tree.yml";
 }
 
-uint64 GuildSkillTreeDatabase::parseBodyNode( const ryml::NodeRef node ){
+uint64 GuildSkillTreeDatabase::parseBodyNode( const ryml::NodeRef& node ){
 	std::string name;
 
 	if( !this->asString( node, "Id", name ) ){
@@ -128,8 +128,8 @@ uint64 GuildSkillTreeDatabase::parseBodyNode( const ryml::NodeRef node ){
 	}
 
 	if( this->nodeExists( node, "Required" ) ){
-		const auto reqNode = node["Required"];
-		for( const auto  requiredNode : reqNode.children() ){
+		const auto& reqNode = node["Required"];
+		for( const auto&  requiredNode : reqNode ){
 			std::string requiredName;
 
 			if( !this->asString( requiredNode, "Id", requiredName ) ){
@@ -274,7 +274,7 @@ const std::string CastleDatabase::getDefaultLocation() {
 	return std::string(db_path) + "/castle_db.yml";
 }
 
-uint64 CastleDatabase::parseBodyNode(const ryml::NodeRef node) {
+uint64 CastleDatabase::parseBodyNode(const ryml::NodeRef& node) {
 	int32 castle_id;
 
 	if (!this->asInt32(node, "Id", castle_id))

src/map/guild.hpp

@@ -123,7 +123,7 @@ public:
 	}
 
 	const std::string getDefaultLocation() override;
-	uint64 parseBodyNode(const ryml::NodeRef node) override;
+	uint64 parseBodyNode(const ryml::NodeRef& node) override;
 
 	// Additional
 	std::shared_ptr<guild_castle> mapname2gc(const char* mapname);

src/map/homunculus.cpp

@@ -54,7 +54,7 @@ const std::string HomExpDatabase::getDefaultLocation() {
 	return std::string(db_path) + "/exp_homun.yml";
 }
 
-uint64 HomExpDatabase::parseBodyNode(const ryml::NodeRef node) {
+uint64 HomExpDatabase::parseBodyNode(const ryml::NodeRef& node) {
 	if (!this->nodesExist(node, { "Level", "Exp" })) {
 		return 0;
 	}

src/map/homunculus.hpp

@@ -34,7 +34,7 @@ public:
 	}
 
 	const std::string getDefaultLocation() override;
-	uint64 parseBodyNode(const ryml::NodeRef node) override;
+	uint64 parseBodyNode(const ryml::NodeRef& node) override;
 
 	// Additional
 	t_exp get_nextexp(uint16 level);

src/map/instance.cpp

@@ -49,7 +49,7 @@ const std::string InstanceDatabase::getDefaultLocation() {
  * @param node: YAML node containing the entry.
  * @return count of successfully parsed rows
  */
-uint64 InstanceDatabase::parseBodyNode(const ryml::NodeRef node) {
+uint64 InstanceDatabase::parseBodyNode(const ryml::NodeRef& node) {
 	int32 instance_id = 0;
 
 	if (!this->asInt32(node, "Id", instance_id))
@@ -150,7 +150,7 @@ uint64 InstanceDatabase::parseBodyNode(const ryml::NodeRef node) {
 	}
 
 	if (this->nodeExists(node, "Enter")) {
-		const auto enterNode = node["Enter"];
+		const auto& enterNode = node["Enter"];
 
 		if (!this->nodesExist(enterNode, { "Map", "X", "Y" }))
 			return 0;
@@ -191,9 +191,9 @@ uint64 InstanceDatabase::parseBodyNode(const ryml::NodeRef node) {
 	}
 
 	if (this->nodeExists(node, "AdditionalMaps")) {
-		const auto mapNode = node["AdditionalMaps"];
+		const auto& mapNode = node["AdditionalMaps"];
 
-		for (const auto mapIt : mapNode.children()) {
+		for (const auto& mapIt : mapNode) {
 			std::string map;
 			c4::from_chars(mapIt.key(), &map);
 

src/map/instance.hpp

@@ -105,7 +105,7 @@ public:
 	}
 
 	const std::string getDefaultLocation() override;
-	uint64 parseBodyNode(const ryml::NodeRef node) override;
+	uint64 parseBodyNode(const ryml::NodeRef& node) override;
 };
 
 extern InstanceDatabase instance_db;

src/map/itemdb.cpp

@@ -42,7 +42,7 @@ const std::string ItemDatabase::getDefaultLocation() {
  * @param node: YAML node containing the entry.
  * @return count of successfully parsed rows
  */
-uint64 ItemDatabase::parseBodyNode(const ryml::NodeRef node) {
+uint64 ItemDatabase::parseBodyNode(const ryml::NodeRef& node) {
 	t_itemid nameid;
 
 	if (!this->asUInt32(node, "Id", nameid))
@@ -318,7 +318,7 @@ uint64 ItemDatabase::parseBodyNode(const ryml::NodeRef node) {
 	}
 
 	if (this->nodeExists(node, "Jobs")) {
-		const ryml::NodeRef jobNode = node["Jobs"];
+		const ryml::NodeRef& jobNode = node["Jobs"];
 
 		item->class_base[0] = item->class_base[1] = item->class_base[2] = 0;
 
@@ -331,7 +331,7 @@ uint64 ItemDatabase::parseBodyNode(const ryml::NodeRef node) {
 			itemdb_jobid2mapid(item->class_base, MAPID_ALL, active);
 		}
 
-		for (const auto jobit : jobNode.children()) {
+		for (const auto& jobit : jobNode) {
 			std::string jobName;
 			c4::from_chars(jobit.key(), &jobName);
 
@@ -364,7 +364,7 @@ uint64 ItemDatabase::parseBodyNode(const ryml::NodeRef node) {
 	}
 
 	if (this->nodeExists(node, "Classes")) {
-		const auto classNode = node["Classes"];
+		const auto& classNode = node["Classes"];
 
 		if (this->nodeExists(classNode, "All")) {
 			bool active;
@@ -378,7 +378,7 @@ uint64 ItemDatabase::parseBodyNode(const ryml::NodeRef node) {
 				item->class_upper &= ~ITEMJ_ALL;
 		}
 
-		for (const auto classit : classNode.children()) {
+		for (const auto& classit : classNode) {
 			std::string className;
 			c4::from_chars(classit.key(), &className);
 
@@ -434,9 +434,9 @@ uint64 ItemDatabase::parseBodyNode(const ryml::NodeRef node) {
 	}
 
 	if (this->nodeExists(node, "Locations")) {
-		const auto locationNode = node["Locations"];
+		const auto& locationNode = node["Locations"];
 
-		for (const auto locit : locationNode.children()) {
+		for (const auto& locit : locationNode) {
 			std::string equipName;
 			c4::from_chars(locit.key(), &equipName);
 
@@ -603,7 +603,7 @@ uint64 ItemDatabase::parseBodyNode(const ryml::NodeRef node) {
 	}
 
 	if (this->nodeExists(node, "Flags")) {
-		const auto flagNode = node["Flags"];
+		const auto& flagNode = node["Flags"];
 
 		if (this->nodeExists(flagNode, "BuyingStore")) {
 			bool active;
@@ -738,7 +738,7 @@ uint64 ItemDatabase::parseBodyNode(const ryml::NodeRef node) {
 	}
 
 	if (this->nodeExists(node, "Delay")) {
-		const auto delayNode = node["Delay"];
+		const auto& delayNode = node["Delay"];
 
 		if (this->nodeExists(delayNode, "Duration")) {
 			uint32 duration;
@@ -779,7 +779,7 @@ uint64 ItemDatabase::parseBodyNode(const ryml::NodeRef node) {
 	}
 
 	if (this->nodeExists(node, "Stack")) {
-		const auto stackNode = node["Stack"];
+		const auto& stackNode = node["Stack"];
 
 		if (this->nodeExists(stackNode, "Amount")) {
 			uint16 amount;
@@ -856,7 +856,7 @@ uint64 ItemDatabase::parseBodyNode(const ryml::NodeRef node) {
 	}
 	
 	if (this->nodeExists(node, "NoUse")) {
-		const auto nouseNode = node["NoUse"];
+		const auto& nouseNode = node["NoUse"];
 
 		if (this->nodeExists(nouseNode, "Override")) {
 			uint16 override;
@@ -894,7 +894,7 @@ uint64 ItemDatabase::parseBodyNode(const ryml::NodeRef node) {
 	}
 
 	if (this->nodeExists(node, "Trade")) {
-		const auto tradeNode = node["Trade"];
+		const auto& tradeNode = node["Trade"];
 
 		if (this->nodeExists(tradeNode, "Override")) {
 			uint16 override;
@@ -1176,7 +1176,7 @@ void ItemDatabase::loadingFinished(){
  * @param node: the already parsed item data.
  * @return gender that should be used.
  */
-e_sex ItemDatabase::defaultGender( const ryml::NodeRef node, std::shared_ptr<item_data> id ){
+e_sex ItemDatabase::defaultGender( const ryml::NodeRef& node, std::shared_ptr<item_data> id ){
 	if (id->nameid == WEDDING_RING_M) //Grom Ring
 		return SEX_MALE;
 	if (id->nameid == WEDDING_RING_F) //Bride Ring
@@ -1279,7 +1279,7 @@ const std::string LaphineSynthesisDatabase::getDefaultLocation(){
 	return std::string( db_path ) + "/laphine_synthesis.yml";
 }
 
-uint64 LaphineSynthesisDatabase::parseBodyNode( const ryml::NodeRef node ){
+uint64 LaphineSynthesisDatabase::parseBodyNode( const ryml::NodeRef& node ){
 	t_itemid item_id;
 
 	{
@@ -1352,7 +1352,7 @@ uint64 LaphineSynthesisDatabase::parseBodyNode( const ryml::NodeRef node ){
 	}
 
 	if( this->nodeExists( node, "Requirements" ) ){
-		for( const ryml::NodeRef requirementNode : node["Requirements"] ){
+		for( const ryml::NodeRef& requirementNode : node["Requirements"] ){
 			std::string name;
 
 			if( !this->asString( requirementNode, "Item", name ) ){
@@ -1450,7 +1450,7 @@ const std::string LaphineUpgradeDatabase::getDefaultLocation(){
 	return std::string( db_path ) + "/laphine_upgrade.yml";
 }
 
-uint64 LaphineUpgradeDatabase::parseBodyNode( const ryml::NodeRef node ){
+uint64 LaphineUpgradeDatabase::parseBodyNode( const ryml::NodeRef& node ){
 	t_itemid item_id;
 
 	{
@@ -1504,7 +1504,7 @@ uint64 LaphineUpgradeDatabase::parseBodyNode( const ryml::NodeRef node ){
 	}
 
 	if( this->nodeExists( node, "TargetItems" ) ){
-		for( const ryml::NodeRef targetNode : node["TargetItems"] ){
+		for( const ryml::NodeRef& targetNode : node["TargetItems"] ){
 			std::string name;
 
 			if( !this->asString( targetNode, "Item", name ) ){
@@ -2054,7 +2054,7 @@ const std::string ItemGroupDatabase::getDefaultLocation() {
  * @param node: YAML node containing the entry.
  * @return count of successfully parsed rows
  */
-uint64 ItemGroupDatabase::parseBodyNode(const ryml::NodeRef node) {
+uint64 ItemGroupDatabase::parseBodyNode(const ryml::NodeRef& node) {
 	std::string group_name;
 
 	if (!this->asString(node, "Group", group_name))
@@ -2082,9 +2082,9 @@ uint64 ItemGroupDatabase::parseBodyNode(const ryml::NodeRef node) {
 	}
 
 	if (this->nodeExists(node, "SubGroups")) {
-		const auto subNode = node["SubGroups"];
+		const auto& subNode = node["SubGroups"];
 
-		for (const auto subit : subNode.children()) {
+		for (const auto& subit : subNode) {
 			if (this->nodeExists(subit, "Clear")) {
 				uint16 id;
 
@@ -2117,9 +2117,9 @@ uint64 ItemGroupDatabase::parseBodyNode(const ryml::NodeRef node) {
 				group->random[subgroup] = random;
 			}
 
-			const auto listNode = subit["List"];
+			const auto& listNode = subit["List"];
 
-			for (const auto listit : listNode.children()) {
+			for (const auto& listit : listNode) {
 				if (this->nodeExists(listit, "Clear")) {
 					std::string item_name;
 
@@ -2397,23 +2397,23 @@ uint16 ComboDatabase::find_combo_id( const std::vector<t_itemid>& items ){
  * @param node: YAML node containing the entry.
  * @return count of successfully parsed rows
  */
-uint64 ComboDatabase::parseBodyNode(const ryml::NodeRef node) {
+uint64 ComboDatabase::parseBodyNode(const ryml::NodeRef& node) {
 	std::vector<std::vector<t_itemid>> items_list;
 
 	if( !this->nodesExist( node, { "Combos" } ) ){
 		return 0;
 	}
 
-	const ryml::NodeRef combosNode = node["Combos"];
+	const ryml::NodeRef& combosNode = node["Combos"];
 
-	for (const auto comboit : combosNode.children()) {
+	for (const auto& comboit : combosNode) {
 		static const std::string nodeName = "Combo";
 
 		if (!this->nodesExist(comboit, { nodeName })) {
 			return 0;
 		}
 
-		const ryml::NodeRef comboNode = comboit["Combo"];
+		const ryml::NodeRef& comboNode = comboit["Combo"];
 
 		if (!comboNode.is_seq()) {
 			this->invalidWarning(comboNode, "%s should be a sequence.\n", nodeName.c_str());
@@ -2422,7 +2422,7 @@ uint64 ComboDatabase::parseBodyNode(const ryml::NodeRef node) {
 
 		std::vector<t_itemid> items = {};
 
-		for (const auto it : comboNode.children()) {
+		for (const auto it : comboNode) {
 			std::string item_name;
 			c4::from_chars(it.val(), &item_name);
 
@@ -3014,7 +3014,7 @@ const std::string RandomOptionDatabase::getDefaultLocation() {
  * @param node: YAML node containing the entry.
  * @return count of successfully parsed rows
  */
-uint64 RandomOptionDatabase::parseBodyNode(const ryml::NodeRef node) {
+uint64 RandomOptionDatabase::parseBodyNode(const ryml::NodeRef& node) {
 	uint16 id;
 
 	if (!this->asUInt16(node, "Id", id))
@@ -3123,7 +3123,7 @@ const std::string RandomOptionGroupDatabase::getDefaultLocation() {
 	return std::string(db_path) + "/item_randomopt_group.yml";
 }
 
-bool RandomOptionGroupDatabase::add_option(const ryml::NodeRef node, std::shared_ptr<s_random_opt_group_entry> &entry) {
+bool RandomOptionGroupDatabase::add_option(const ryml::NodeRef& node, std::shared_ptr<s_random_opt_group_entry> &entry) {
 	uint16 option_id;
 
 	if (this->nodeExists(node, "Option")) {
@@ -3246,7 +3246,7 @@ void s_random_opt_group::apply( struct item& item ){
  * @param node: YAML node containing the entry.
  * @return count of successfully parsed rows
  */
-uint64 RandomOptionGroupDatabase::parseBodyNode(const ryml::NodeRef node) {
+uint64 RandomOptionGroupDatabase::parseBodyNode(const ryml::NodeRef& node) {
 	uint16 id;
 
 	if (!this->asUInt16(node, "Id", id))
@@ -3278,8 +3278,8 @@ uint64 RandomOptionGroupDatabase::parseBodyNode(const ryml::NodeRef node) {
 	}
 
 	if (this->nodeExists(node, "Slots")) {
-		const auto slotsNode = node["Slots"];
-		for (const ryml::NodeRef slotNode : slotsNode.children()) {
+		const auto& slotsNode = node["Slots"];
+		for (const ryml::NodeRef& slotNode : slotsNode) {
 			if (randopt->slots.size() >= MAX_ITEM_RDM_OPT) {
 				this->invalidWarning(slotNode, "Reached maximum of %d Random Option group options. Skipping the remaining slots...\n", MAX_ITEM_RDM_OPT);
 				break;
@@ -3301,8 +3301,8 @@ uint64 RandomOptionGroupDatabase::parseBodyNode(const ryml::NodeRef node) {
 			}
 
 			std::vector<std::shared_ptr<s_random_opt_group_entry>> entries;
-			const auto optionsNode = slotNode["Options"];
-			for (const auto optionNode : optionsNode.children()) {
+			const auto& optionsNode = slotNode["Options"];
+			for (const auto& optionNode : optionsNode) {
 				std::shared_ptr<s_random_opt_group_entry> entry;
 
 				if (!this->add_option(optionNode, entry))
@@ -3335,8 +3335,8 @@ uint64 RandomOptionGroupDatabase::parseBodyNode(const ryml::NodeRef node) {
 	if (this->nodeExists(node, "Random")) {
 		randopt->random_options.clear();
 
-		const auto randomNode = node["Random"];
-		for (const auto randomNode : randomNode.children()) {
+		const auto& randomNode = node["Random"];
+		for (const auto& randomNode : randomNode) {
 			std::shared_ptr<s_random_opt_group_entry> entry;
 
 			if (!this->add_option(randomNode, entry))

src/map/itemdb.hpp

@@ -981,7 +981,7 @@ public:
 		this->combo_num = 0;
 	}
 	const std::string getDefaultLocation() override;
-	uint64 parseBodyNode(const ryml::NodeRef node) override;
+	uint64 parseBodyNode(const ryml::NodeRef& node) override;
 	void loadingFinished() override;
 };
 
@@ -1027,7 +1027,7 @@ public:
 	}
 
 	const std::string getDefaultLocation() override;
-	uint64 parseBodyNode(const ryml::NodeRef node) override;
+	uint64 parseBodyNode(const ryml::NodeRef& node) override;
 	void loadingFinished() override;
 
 	// Additional
@@ -1044,10 +1044,10 @@ public:
 	}
 
 	const std::string getDefaultLocation() override;
-	uint64 parseBodyNode(const ryml::NodeRef node) override;
+	uint64 parseBodyNode(const ryml::NodeRef& node) override;
 
 	// Additional
-	bool add_option(const ryml::NodeRef node, std::shared_ptr<s_random_opt_group_entry> &entry);
+	bool add_option(const ryml::NodeRef& node, std::shared_ptr<s_random_opt_group_entry> &entry);
 	bool option_exists(std::string name);
 	bool option_get_id(std::string name, uint16 &id);
 };
@@ -1195,7 +1195,7 @@ private:
 	std::unordered_map<std::string, std::shared_ptr<item_data>> nameToItemDataMap;
 	std::unordered_map<std::string, std::shared_ptr<item_data>> aegisNameToItemDataMap;
 
-	e_sex defaultGender( const ryml::NodeRef node, std::shared_ptr<item_data> id );
+	e_sex defaultGender( const ryml::NodeRef& node, std::shared_ptr<item_data> id );
 
 public:
 	ItemDatabase() : TypesafeCachedYamlDatabase("ITEM_DB", 2, 1) {
@@ -1203,7 +1203,7 @@ public:
 	}
 
 	const std::string getDefaultLocation() override;
-	uint64 parseBodyNode(const ryml::NodeRef node) override;
+	uint64 parseBodyNode(const ryml::NodeRef& node) override;
 	void loadingFinished() override;
 	void clear() override{
 		TypesafeCachedYamlDatabase::clear();
@@ -1226,7 +1226,7 @@ public:
 	}
 
 	const std::string getDefaultLocation() override;
-	uint64 parseBodyNode(const ryml::NodeRef node) override;
+	uint64 parseBodyNode(const ryml::NodeRef& node) override;
 	void loadingFinished() override;
 
 	// Additional
@@ -1260,7 +1260,7 @@ public:
 	}
 
 	const std::string getDefaultLocation();
-	uint64 parseBodyNode( const ryml::NodeRef node );
+	uint64 parseBodyNode( const ryml::NodeRef& node );
 };
 
 extern LaphineSynthesisDatabase laphine_synthesis_db;
@@ -1285,7 +1285,7 @@ public:
 	}
 
 	const std::string getDefaultLocation();
-	uint64 parseBodyNode( const ryml::NodeRef node );
+	uint64 parseBodyNode( const ryml::NodeRef& node );
 };
 
 extern LaphineUpgradeDatabase laphine_upgrade_db;

src/map/mercenary.cpp

@@ -464,7 +464,7 @@ const std::string MercenaryDatabase::getDefaultLocation() {
  * @param node: YAML node containing the entry.
  * @return count of successfully parsed rows
  */
-uint64 MercenaryDatabase::parseBodyNode(const ryml::NodeRef node) {
+uint64 MercenaryDatabase::parseBodyNode(const ryml::NodeRef& node) {
 	uint32 id;
 
 	if (!this->asUInt32(node, "Id", id))
@@ -864,9 +864,9 @@ uint64 MercenaryDatabase::parseBodyNode(const ryml::NodeRef node) {
 	mercenary->status.aspd_rate = 1000;
 
 	if (this->nodeExists(node, "Skills")) {
-		const ryml::NodeRef skillsNode = node["Skills"];
+		const ryml::NodeRef& skillsNode = node["Skills"];
 
-		for (const ryml::NodeRef skill : skillsNode) {
+		for (const ryml::NodeRef& skill : skillsNode) {
 			std::string skill_name;
 
 			if (!this->asString(skill, "Name", skill_name))

src/map/mercenary.hpp

@@ -66,7 +66,7 @@ public:
 	}
 
 	const std::string getDefaultLocation() override;
-	uint64 parseBodyNode(const ryml::NodeRef node) override;
+	uint64 parseBodyNode(const ryml::NodeRef& node) override;
 };
 
 extern MercenaryDatabase mercenary_db;

src/map/mob.cpp

@@ -4183,8 +4183,8 @@ const std::string MobDatabase::getDefaultLocation() {
 	return std::string(db_path) + "/mob_db.yml";
 }
 
-bool MobDatabase::parseDropNode(std::string nodeName, ryml::NodeRef node, uint8 max, s_mob_drop *drops) {
-	const auto dropNode = node[c4::to_csubstr(nodeName)];
+bool MobDatabase::parseDropNode(std::string nodeName, const ryml::NodeRef& node, uint8 max, s_mob_drop *drops) {
+	const auto& dropNode = node[c4::to_csubstr(nodeName)];
 	uint16 i;
 
 	// Find first empty spot
@@ -4194,7 +4194,7 @@ bool MobDatabase::parseDropNode(std::string nodeName, ryml::NodeRef node, uint8
 		}
 	}
 
-	for (const auto dropit : dropNode.children()) {
+	for (const auto& dropit : dropNode) {
 		uint16 index;
 
 		if (this->nodeExists(dropit, "Index")) {
@@ -4264,7 +4264,7 @@ bool MobDatabase::parseDropNode(std::string nodeName, ryml::NodeRef node, uint8
  * @param node: YAML node containing the entry.
  * @return count of successfully parsed rows
  */
-uint64 MobDatabase::parseBodyNode(const ryml::NodeRef node) {
+uint64 MobDatabase::parseBodyNode(const ryml::NodeRef& node) {
 	uint32 mob_id;
 
 	if (!this->asUInt32(node, "Id", mob_id))
@@ -4655,9 +4655,9 @@ uint64 MobDatabase::parseBodyNode(const ryml::NodeRef node) {
 	}
 
 	if (this->nodeExists(node, "RaceGroups")) {
-		const auto raceNode = node["RaceGroups"];
+		const auto& raceNode = node["RaceGroups"];
 
-		for (const auto &raceit : raceNode.children()) {
+		for (const auto &raceit : raceNode) {
 			std::string raceName;
 			c4::from_chars(raceit.key(), &raceName);
 			std::string raceName_constant = "RC2_" + raceName;
@@ -4846,9 +4846,9 @@ uint64 MobDatabase::parseBodyNode(const ryml::NodeRef node) {
 	}
 
 	if (this->nodeExists(node, "Modes")) {
-		const auto modeNode = node["Modes"];
+		const auto& modeNode = node["Modes"];
 
-		for (const auto modeit : modeNode.children()) {
+		for (const auto& modeit : modeNode) {
 			std::string modeName;
 			c4::from_chars(modeit.key(), &modeName);
 			std::string modeName_constant = "MD_" + modeName;
@@ -5214,7 +5214,7 @@ const std::string MobAvailDatabase::getDefaultLocation() {
  * @param node: YAML node containing the entry.
  * @return count of successfully parsed rows
  */
-uint64 MobAvailDatabase::parseBodyNode(const ryml::NodeRef node) {
+uint64 MobAvailDatabase::parseBodyNode(const ryml::NodeRef& node) {
 	std::string mob_name;
 
 	if (!this->asString(node, "Mob", mob_name))
@@ -5471,9 +5471,9 @@ uint64 MobAvailDatabase::parseBodyNode(const ryml::NodeRef node) {
 	}
 
 	if (this->nodeExists(node, "Options")) {
-		const auto optionNode = node["Options"];
+		const auto& optionNode = node["Options"];
 
-		for (const auto it : optionNode.children()) {
+		for (const auto& it : optionNode) {
 			std::string option;
 			c4::from_chars(it.key(), &option);
 			std::string option_constant = "OPTION_" + option;
@@ -5520,7 +5520,7 @@ const std::string MobSummonDatabase::getDefaultLocation() {
  * @param node: YAML node containing the entry.
  * @return count of successfully parsed rows
  */
-uint64 MobSummonDatabase::parseBodyNode(const ryml::NodeRef node) {
+uint64 MobSummonDatabase::parseBodyNode(const ryml::NodeRef& node) {
 	std::string group_name;
 
 	if (!this->asString(node, "Group", group_name))
@@ -5564,9 +5564,9 @@ uint64 MobSummonDatabase::parseBodyNode(const ryml::NodeRef node) {
 	}
 
 	if (this->nodeExists(node, "Summon")) {
-		const auto MobNode = node["Summon"];
+		const auto& MobNode = node["Summon"];
 
-		for (const auto mobit : MobNode.children()) {
+		for (const auto& mobit : MobNode) {
 			if (!this->nodesExist(mobit, { "Mob", "Rate" })) {
 				continue;
 			}
@@ -5622,7 +5622,7 @@ const std::string MobChatDatabase::getDefaultLocation() {
  * @param node: YAML node containing the entry.
  * @return count of successfully parsed rows
  */
-uint64 MobChatDatabase::parseBodyNode(const ryml::NodeRef node) {
+uint64 MobChatDatabase::parseBodyNode(const ryml::NodeRef& node) {
 	uint16 id;
 
 	if (!this->asUInt16(node, "Id", id))
@@ -5999,7 +5999,7 @@ const std::string MobItemRatioDatabase::getDefaultLocation() {
  * @param node: YAML node containing the entry.
  * @return count of successfully parsed rows
  */
-uint64 MobItemRatioDatabase::parseBodyNode(const ryml::NodeRef node) {
+uint64 MobItemRatioDatabase::parseBodyNode(const ryml::NodeRef& node) {
 	std::string item_name;
 
 	if (!this->asString(node, "Item", item_name))
@@ -6036,9 +6036,9 @@ uint64 MobItemRatioDatabase::parseBodyNode(const ryml::NodeRef node) {
 	}
 
 	if (this->nodeExists(node, "List")) {
-		const auto MobNode = node["List"];
+		const auto& MobNode = node["List"];
 
-		for (const auto mobit : MobNode.children()) {
+		for (const auto& mobit : MobNode) {
 			std::string mob_name;
 			c4::from_chars(mobit.key(), &mob_name);
 

src/map/mob.hpp

@@ -211,7 +211,7 @@ public:
 	}
 
 	const std::string getDefaultLocation() override;
-	uint64 parseBodyNode(const ryml::NodeRef node) override;
+	uint64 parseBodyNode(const ryml::NodeRef& node) override;
 };
 
 struct s_mob_item_drop_ratio {
@@ -227,7 +227,7 @@ public:
 	}
 
 	const std::string getDefaultLocation() override;
-	uint64 parseBodyNode(const ryml::NodeRef node) override;
+	uint64 parseBodyNode(const ryml::NodeRef& node) override;
 };
 
 struct spawn_info {
@@ -270,7 +270,7 @@ struct s_mob_db {
 
 class MobDatabase : public TypesafeCachedYamlDatabase <uint32, s_mob_db> {
 private:
-	bool parseDropNode(std::string nodeName, ryml::NodeRef node, uint8 max, s_mob_drop *drops);
+	bool parseDropNode(std::string nodeName, const ryml::NodeRef& node, uint8 max, s_mob_drop *drops);
 
 public:
 	MobDatabase() : TypesafeCachedYamlDatabase("MOB_DB", 3, 1) {
@@ -278,7 +278,7 @@ public:
 	}
 
 	const std::string getDefaultLocation() override;
-	uint64 parseBodyNode(const ryml::NodeRef node) override;
+	uint64 parseBodyNode(const ryml::NodeRef& node) override;
 	void loadingFinished() override;
 };
 
@@ -363,7 +363,7 @@ public:
 
 	void clear() override{ };
 	const std::string getDefaultLocation() override;
-	uint64 parseBodyNode(const ryml::NodeRef node) override;
+	uint64 parseBodyNode(const ryml::NodeRef& node) override;
 };
 
 struct s_randomsummon_entry {
@@ -384,7 +384,7 @@ public:
 	}
 
 	const std::string getDefaultLocation() override;
-	uint64 parseBodyNode(const ryml::NodeRef node) override;
+	uint64 parseBodyNode(const ryml::NodeRef& node) override;
 };
 
 enum e_mob_skill_target {

src/map/npc.cpp

@@ -129,7 +129,7 @@ const std::string StylistDatabase::getDefaultLocation(){
 	return std::string(db_path) + "/stylist.yml";
 }
 
-bool StylistDatabase::parseCostNode( std::shared_ptr<s_stylist_entry> entry, bool doram, const ryml::NodeRef node ){
+bool StylistDatabase::parseCostNode( std::shared_ptr<s_stylist_entry> entry, bool doram, const ryml::NodeRef& node ){
 	std::shared_ptr<s_stylist_costs> costs = doram ? entry->doram : entry->human;
 	bool costs_exists = costs != nullptr;
 
@@ -209,7 +209,7 @@ bool StylistDatabase::parseCostNode( std::shared_ptr<s_stylist_entry> entry, boo
 	return true;
 }
 
-uint64 StylistDatabase::parseBodyNode( const ryml::NodeRef node ){
+uint64 StylistDatabase::parseBodyNode( const ryml::NodeRef& node ){
 	if( !this->nodesExist( node, { "Look", "Options" } ) ){
 		return 0;
 	}
@@ -250,7 +250,7 @@ uint64 StylistDatabase::parseBodyNode( const ryml::NodeRef node ){
 		list->look = (uint16)constant;
 	}
 
-	for( const ryml::NodeRef optionNode : node["Options"] ){
+	for( const ryml::NodeRef& optionNode : node["Options"] ){
 		int16 index;
 
 		if( !this->asInt16( optionNode, "Index", index ) ){
@@ -394,7 +394,7 @@ const std::string BarterDatabase::getDefaultLocation(){
 	return "npc/barters.yml";
 }
 
-uint64 BarterDatabase::parseBodyNode( const ryml::NodeRef node ){
+uint64 BarterDatabase::parseBodyNode( const ryml::NodeRef& node ){
 	std::string npcname;
 
 	if( !this->asString( node, "Name", npcname ) ){
@@ -538,7 +538,7 @@ uint64 BarterDatabase::parseBodyNode( const ryml::NodeRef node ){
 	}
 
 	if( this->nodeExists( node, "Items" ) ){
-		for( const ryml::NodeRef itemNode : node["Items"] ){
+		for( const ryml::NodeRef& itemNode : node["Items"] ){
 			uint16 index;
 
 			if( !this->asUInt16( itemNode, "Index", index ) ){
@@ -610,7 +610,7 @@ uint64 BarterDatabase::parseBodyNode( const ryml::NodeRef node ){
 			}
 
 			if( this->nodeExists( itemNode, "RequiredItems" ) ){
-				for( const ryml::NodeRef requiredItemNode : itemNode["RequiredItems"] ){
+				for( const ryml::NodeRef& requiredItemNode : itemNode["RequiredItems"] ){
 					uint16 requirement_index;
 
 					if( !this->asUInt16( requiredItemNode, "Index", requirement_index ) ){

src/map/npc.hpp

@@ -65,7 +65,7 @@ struct s_stylist_list{
 
 class StylistDatabase : public TypesafeYamlDatabase<uint32, s_stylist_list>{
 private:
-	bool parseCostNode( std::shared_ptr<s_stylist_entry> entry, bool doram, const ryml::NodeRef node );
+	bool parseCostNode( std::shared_ptr<s_stylist_entry> entry, bool doram, const ryml::NodeRef& node );
 
 public:
 	StylistDatabase() : TypesafeYamlDatabase( "STYLIST_DB", 1 ){
@@ -73,7 +73,7 @@ public:
 	}
 
 	const std::string getDefaultLocation() override;
-	uint64 parseBodyNode( const ryml::NodeRef node ) override;
+	uint64 parseBodyNode( const ryml::NodeRef& node ) override;
 };
 
 extern StylistDatabase stylist_db;
@@ -111,7 +111,7 @@ public:
 	}
 
 	const std::string getDefaultLocation();
-	uint64 parseBodyNode( const ryml::NodeRef node );
+	uint64 parseBodyNode( const ryml::NodeRef& node );
 	void loadingFinished();
 };
 

src/map/pc.cpp

@@ -92,7 +92,7 @@ const std::string AttendanceDatabase::getDefaultLocation(){
  * @param node: YAML node containing the entry.
  * @return count of successfully parsed rows
  */
-uint64 AttendanceDatabase::parseBodyNode(const ryml::NodeRef node){
+uint64 AttendanceDatabase::parseBodyNode(const ryml::NodeRef& node){
 	uint32 start;
 
 	if( !this->asUInt32( node, "Start", start ) ){
@@ -173,9 +173,9 @@ uint64 AttendanceDatabase::parseBodyNode(const ryml::NodeRef node){
 	}
 
 	if( this->nodeExists( node, "Rewards" ) ){
-		const auto rewardsNode = node["Rewards"];
+		const auto& rewardsNode = node["Rewards"];
 
-		for( const auto rewardNode : rewardsNode.children() ){
+		for( const auto& rewardNode : rewardsNode ){
 			uint32 day;
 
 			if( !this->asUInt32( rewardNode, "Day", day ) ){
@@ -266,7 +266,7 @@ const std::string PenaltyDatabase::getDefaultLocation(){
 	return std::string( db_path ) + "/level_penalty.yml";
 }
 
-uint64 PenaltyDatabase::parseBodyNode(const ryml::NodeRef node){
+uint64 PenaltyDatabase::parseBodyNode(const ryml::NodeRef& node){
 	std::string type_constant;
 
 	if( !this->asString( node, "Type", type_constant ) ){
@@ -300,7 +300,7 @@ uint64 PenaltyDatabase::parseBodyNode(const ryml::NodeRef node){
 	}
 
 	if( this->nodeExists( node, "LevelDifferences" ) ){
-		for( const auto levelNode : node["LevelDifferences"].children() ){
+		for( const auto& levelNode : node["LevelDifferences"] ){
 			if( !this->nodesExist( levelNode, { "Difference", "Rate" } ) ){
 				return 0;
 			}
@@ -12636,7 +12636,7 @@ const std::string SkillTreeDatabase::getDefaultLocation() {
  * @param node: YAML node containing the entry.
  * @return count of successfully parsed rows
  */
-uint64 SkillTreeDatabase::parseBodyNode(const ryml::NodeRef node) {
+uint64 SkillTreeDatabase::parseBodyNode(const ryml::NodeRef& node) {
 	std::string job_name;
 
 	if (!this->asString(node, "Job", job_name))
@@ -12658,7 +12658,7 @@ uint64 SkillTreeDatabase::parseBodyNode(const ryml::NodeRef node) {
 		tree = std::make_shared<s_skill_tree>();
 
 	if (this->nodeExists(node, "Inherit")) {
-		const ryml::NodeRef InheritNode = node["Inherit"];
+		const ryml::NodeRef& InheritNode = node["Inherit"];
 
 		for (const auto &Inheritit : InheritNode) {
 			std::string inheritname;
@@ -12980,9 +12980,9 @@ const std::string JobDatabase::getDefaultLocation() {
  * @param node: YAML node containing the entry.
  * @return count of successfully parsed rows
  */
-uint64 JobDatabase::parseBodyNode(const ryml::NodeRef node) {
+uint64 JobDatabase::parseBodyNode(const ryml::NodeRef& node) {
 	if (this->nodeExists(node, "Jobs")) {
-		const ryml::NodeRef jobsNode = node["Jobs"];
+		const ryml::NodeRef& jobsNode = node["Jobs"];
 
 		for (const auto &jobit : jobsNode) {
 			std::string job_name;
@@ -13063,7 +13063,7 @@ uint64 JobDatabase::parseBodyNode(const ryml::NodeRef node) {
 			}
 
 			if (this->nodeExists(node, "BaseASPD")) {
-				const ryml::NodeRef aspdNode = node["BaseASPD"];
+				const ryml::NodeRef& aspdNode = node["BaseASPD"];
 				uint8 max = MAX_WEAPON_TYPE;
 
 #ifdef RENEWAL // Renewal adds an extra column for shields
@@ -13111,7 +13111,7 @@ uint64 JobDatabase::parseBodyNode(const ryml::NodeRef node) {
 			}
 
 			if (this->nodeExists(node, "MaxStats")) {
-				const ryml::NodeRef statNode = node["MaxStats"];
+				const ryml::NodeRef& statNode = node["MaxStats"];
 
 				for (const auto &statit : statNode) {
 					std::string stat;
@@ -13156,7 +13156,7 @@ uint64 JobDatabase::parseBodyNode(const ryml::NodeRef node) {
 			}
 
 			if (this->nodeExists(node, "BaseExp")) {
-				for (const ryml::NodeRef bexpNode : node["BaseExp"]) {
+				for (const ryml::NodeRef& bexpNode : node["BaseExp"]) {
 					uint16 level;
 
 					if (!this->asUInt16(bexpNode, "Level", level))
@@ -13199,7 +13199,7 @@ uint64 JobDatabase::parseBodyNode(const ryml::NodeRef node) {
 			}
 
 			if (this->nodeExists(node, "JobExp")) {
-				for (const ryml::NodeRef jexpNode : node["JobExp"]) {
+				for (const ryml::NodeRef& jexpNode : node["JobExp"]) {
 					uint16 level;
 
 					if (!this->asUInt16(jexpNode, "Level", level))
@@ -13225,9 +13225,9 @@ uint64 JobDatabase::parseBodyNode(const ryml::NodeRef node) {
 			}
 
 			if (this->nodeExists(node, "BonusStats")) {
-				const ryml::NodeRef bonusNode = node["BonusStats"];
+				const ryml::NodeRef& bonusNode = node["BonusStats"];
 
-				for (const ryml::NodeRef levelNode : bonusNode) {
+				for (const ryml::NodeRef& levelNode : bonusNode) {
 					uint16 level;
 
 					if (!this->asUInt16(levelNode, "Level", level))
@@ -13253,7 +13253,7 @@ uint64 JobDatabase::parseBodyNode(const ryml::NodeRef node) {
 
 #ifdef HP_SP_TABLES
 			if (this->nodeExists(node, "BaseHp")) {
-				for (const ryml::NodeRef bhpNode : node["BaseHp"]) {
+				for (const ryml::NodeRef& bhpNode : node["BaseHp"]) {
 					uint16 level;
 
 					if (!this->asUInt16(bhpNode, "Level", level))
@@ -13279,7 +13279,7 @@ uint64 JobDatabase::parseBodyNode(const ryml::NodeRef node) {
 			}
 
 			if (this->nodeExists(node, "BaseSp")) {
-				for (const ryml::NodeRef bspNode : node["BaseSp"]) {
+				for (const ryml::NodeRef& bspNode : node["BaseSp"]) {
 					uint16 level;
 
 					if (!this->asUInt16(bspNode, "Level", level))
@@ -13305,7 +13305,7 @@ uint64 JobDatabase::parseBodyNode(const ryml::NodeRef node) {
 			}
 
 			if (this->nodeExists(node, "BaseAp")) {
-				for (const ryml::NodeRef bapNode : node["BaseAp"]) {
+				for (const ryml::NodeRef& bapNode : node["BaseAp"]) {
 					uint16 level;
 
 					if (!this->asUInt16(bapNode, "Level", level))
@@ -13510,7 +13510,7 @@ const std::string PlayerStatPointDatabase::getDefaultLocation() {
 	return std::string(db_path) + "/statpoint.yml";
 }
 
-uint64 PlayerStatPointDatabase::parseBodyNode(const ryml::NodeRef node) {
+uint64 PlayerStatPointDatabase::parseBodyNode(const ryml::NodeRef& node) {
 	if (!this->nodesExist(node, { "Level", "Points" })) {
 		return 0;
 	}

src/map/pc.hpp

@@ -993,7 +993,7 @@ public:
 	}
 
 	const std::string getDefaultLocation() override;
-	uint64 parseBodyNode(const ryml::NodeRef node) override;
+	uint64 parseBodyNode(const ryml::NodeRef& node) override;
 	void loadingFinished() override;
 };
 
@@ -1018,7 +1018,7 @@ public:
 	}
 
 	const std::string getDefaultLocation() override;
-	uint64 parseBodyNode(const ryml::NodeRef node) override;
+	uint64 parseBodyNode(const ryml::NodeRef& node) override;
 	void loadingFinished() override;
 
 	// Additional
@@ -1191,7 +1191,7 @@ public:
 	}
 
 	const std::string getDefaultLocation() override;
-	uint64 parseBodyNode(const ryml::NodeRef node) override;
+	uint64 parseBodyNode(const ryml::NodeRef& node) override;
 };
 
 extern AttendanceDatabase attendance_db;
@@ -1209,7 +1209,7 @@ public:
 	}
 
 	const std::string getDefaultLocation() override;
-	uint64 parseBodyNode(const ryml::NodeRef node) override;
+	uint64 parseBodyNode(const ryml::NodeRef& node) override;
 	void loadingFinished() override;
 
 	// Additional
@@ -1485,7 +1485,7 @@ public:
 	}
 
 	const std::string getDefaultLocation() override;
-	uint64 parseBodyNode(const ryml::NodeRef node) override;
+	uint64 parseBodyNode(const ryml::NodeRef& node) override;
 	void loadingFinished() override;
 
 	// Additional

src/map/pet.cpp

@@ -37,7 +37,7 @@ const std::string PetDatabase::getDefaultLocation(){
 	return std::string(db_path) + "/pet_db.yml";
 }
 
-uint64 PetDatabase::parseBodyNode( const ryml::NodeRef node ){
+uint64 PetDatabase::parseBodyNode( const ryml::NodeRef& node ){
 	std::string mob_name;
 
 	if( !this->asString( node, "Mob", mob_name ) ){
@@ -403,8 +403,8 @@ uint64 PetDatabase::parseBodyNode( const ryml::NodeRef node ){
 	}
 
 	if( this->nodeExists( node, "Evolution" ) ){
-		const auto evolutionsNode = node["Evolution"];
-		for( const auto evolutionNode : evolutionsNode.children() ){
+		const auto& evolutionsNode = node["Evolution"];
+		for( const auto& evolutionNode : evolutionsNode ){
 			std::string target_name;
 
 			if( !this->asString( evolutionNode, "Target", target_name ) ){
@@ -433,8 +433,8 @@ uint64 PetDatabase::parseBodyNode( const ryml::NodeRef node ){
 				evolution->target_mob_id = targetId;
 			}
 
-			const auto requirementsNode = evolutionNode["ItemRequirements"];
-			for( const auto requirementNode : requirementsNode.children() ){
+			const auto& requirementsNode = evolutionNode["ItemRequirements"];
+			for( const auto& requirementNode : requirementsNode ){
 				std::string item_name;
 
 				if( !this->asString( requirementNode, "Item", item_name ) ){

src/map/pet.hpp

@@ -136,7 +136,7 @@ public:
 	}
 
 	const std::string getDefaultLocation() override;
-	uint64 parseBodyNode( const ryml::NodeRef node ) override;
+	uint64 parseBodyNode( const ryml::NodeRef& node ) override;
 
 	// Additional
 	bool reload();

src/map/quest.cpp

@@ -37,7 +37,7 @@ const std::string QuestDatabase::getDefaultLocation() {
  * @param node: YAML node containing the entry.
  * @return count of successfully parsed rows
  */
-uint64 QuestDatabase::parseBodyNode(const ryml::NodeRef node) {
+uint64 QuestDatabase::parseBodyNode(const ryml::NodeRef& node) {
 	uint32 quest_id;
 
 	if (!this->asUInt32(node, "Id", quest_id))
@@ -97,9 +97,9 @@ uint64 QuestDatabase::parseBodyNode(const ryml::NodeRef node) {
 	}
 
 	if (this->nodeExists(node, "Targets")) {
-		const auto targets = node["Targets"];
+		const auto& targets = node["Targets"];
 
-		for (const auto targetNode : targets.children()) {
+		for (const auto& targetNode : targets) {
 			if (quest->objectives.size() >= MAX_QUEST_OBJECTIVES) {
 				this->invalidWarning(targetNode, "Targets list exceeds the maximum of %d, skipping.\n", MAX_QUEST_OBJECTIVES);
 				return 0;
@@ -315,9 +315,9 @@ uint64 QuestDatabase::parseBodyNode(const ryml::NodeRef node) {
 	}
 
 	if (this->nodeExists(node, "Drops")) {
-		const auto drops = node["Drops"];
+		const auto& drops = node["Drops"];
 
-		for (const auto dropNode : drops.children()) {
+		for (const auto& dropNode : drops) {
 			uint32 mob_id = 0; // Can be 0 which means all monsters
 
 			if (this->nodeExists(dropNode, "Mob")) {

src/map/quest.hpp

@@ -60,7 +60,7 @@ public:
 	}
 
 	const std::string getDefaultLocation() override;
-	uint64 parseBodyNode(const ryml::NodeRef node) override;
+	uint64 parseBodyNode(const ryml::NodeRef& node) override;
 
 	// Additional
 	bool reload();

src/map/script.cpp

@@ -2356,7 +2356,7 @@ const std::string ConstantDatabase::getDefaultLocation(){
 	return std::string(db_path) + "/const.yml";
 }
 
-uint64 ConstantDatabase::parseBodyNode( const ryml::NodeRef node ) {
+uint64 ConstantDatabase::parseBodyNode( const ryml::NodeRef& node ) {
 	std::string constant_name;
 
 	if (!this->asString( node, "Name", constant_name ))

src/map/script.hpp

@@ -2077,7 +2077,7 @@ public:
 
 	void clear() override{ }
 	const std::string getDefaultLocation() override;
-	uint64 parseBodyNode(const ryml::NodeRef node) override;
+	uint64 parseBodyNode(const ryml::NodeRef& node) override;
 };
 
 /**

src/map/skill.cpp

@@ -22993,9 +22993,9 @@ const std::string SkillDatabase::getDefaultLocation() {
 	return std::string(db_path) + "/skill_db.yml";
 }
 
-template<typename T, size_t S> bool SkillDatabase::parseNode(std::string nodeName, std::string subNodeName, ryml::NodeRef node, T (&arr)[S]) {
+template<typename T, size_t S> bool SkillDatabase::parseNode(const std::string& nodeName, const std::string& subNodeName, const ryml::NodeRef& node, T (&arr)[S]) {
 	int32 value;
-	const auto skNode = node[c4::to_csubstr(nodeName)];
+	const auto& skNode = node[c4::to_csubstr(nodeName)];
 	if (!skNode.is_seq()) {
 		if (!this->asInt32(node, nodeName, value))
 			return false;
@@ -23005,7 +23005,7 @@ template<typename T, size_t S> bool SkillDatabase::parseNode(std::string nodeNam
 	} else {
 		uint16 max_level = 0;
 
-		for (const auto it : skNode.children()) {
+		for (const auto& it : skNode) {
 			uint16 skill_lv;
 
 			if (!this->asUInt16(it, "Level", skill_lv))
@@ -23063,7 +23063,7 @@ template<typename T, size_t S> bool SkillDatabase::parseNode(std::string nodeNam
  * @param node: YAML node containing the entry.
  * @return count of successfully parsed rows
  */
-uint64 SkillDatabase::parseBodyNode(const ryml::NodeRef node) {
+uint64 SkillDatabase::parseBodyNode(const ryml::NodeRef& node) {
 	uint16 skill_id;
 
 	if (!this->asUInt16(node, "Id", skill_id))
@@ -23158,9 +23158,9 @@ uint64 SkillDatabase::parseBodyNode(const ryml::NodeRef node) {
 	}
 
 	if (this->nodeExists(node, "DamageFlags")) {
-		const auto damageNode = node["DamageFlags"];
+		const auto& damageNode = node["DamageFlags"];
 
-		for (const auto it : damageNode.children()) {
+		for (const auto& it : damageNode) {
 			std::string nk;
 			c4::from_chars(it.key(), &nk);
 			std::string nk_constant = "NK_" + nk;
@@ -23184,9 +23184,9 @@ uint64 SkillDatabase::parseBodyNode(const ryml::NodeRef node) {
 	}
 
 	if (this->nodeExists(node, "Flags")) {
-		const auto infoNode = node["Flags"];
+		const auto& infoNode = node["Flags"];
 
-		for (const auto it : infoNode.children()) {
+		for (const auto& it : infoNode) {
 			std::string inf2;
 			c4::from_chars(it.key(), &inf2);
 			std::string inf2_constant = "INF2_" + inf2;
@@ -23268,7 +23268,7 @@ uint64 SkillDatabase::parseBodyNode(const ryml::NodeRef node) {
 
 			memset(skill->element, static_cast<e_element>(constant), sizeof(skill->element));
 		} else {
-			for (const auto it : elementNode.children()) {
+			for (const auto& it : elementNode) {
 				uint16 skill_lv;
 
 				if (!this->asUInt16(it, "Level", skill_lv))
@@ -23328,10 +23328,10 @@ uint64 SkillDatabase::parseBodyNode(const ryml::NodeRef node) {
 	}
 
 	if (this->nodeExists(node, "CopyFlags")) {
-		const auto copyNode = node["CopyFlags"];
+		const auto& copyNode = node["CopyFlags"];
 
 		if (this->nodeExists(copyNode, "Skill")) {
-			const auto copyskillNode = copyNode["Skill"];
+			const auto& copyskillNode = copyNode["Skill"];
 
 			if (this->nodeExists(copyskillNode, "Plagiarism")) {
 				bool active;
@@ -23362,9 +23362,9 @@ uint64 SkillDatabase::parseBodyNode(const ryml::NodeRef node) {
 		}
 
 		if (this->nodeExists(copyNode, "RemoveRequirement")) {
-			const auto copyreqNode = copyNode["RemoveRequirement"];
+			const auto& copyreqNode = copyNode["RemoveRequirement"];
 
-			for (const auto it : copyreqNode.children()) {
+			for (const auto& it : copyreqNode) {
 				std::string req;
 				c4::from_chars(it.key(), &req);
 				std::string req_constant = "SKILL_REQ_" + req;
@@ -23384,7 +23384,7 @@ uint64 SkillDatabase::parseBodyNode(const ryml::NodeRef node) {
 	}
 
 	if (this->nodeExists(node, "NoNearNpc")) {
-		const auto npcNode = node["NoNearNpc"];
+		const auto& npcNode = node["NoNearNpc"];
 
 		if (this->nodeExists(npcNode, "AdditionalRange")) {
 			uint16 range;
@@ -23399,9 +23399,9 @@ uint64 SkillDatabase::parseBodyNode(const ryml::NodeRef node) {
 		}
 
 		if (this->nodeExists(npcNode, "Type")) {
-			const auto npctypeNode = npcNode["Type"];
+			const auto& npctypeNode = npcNode["Type"];
 
-			for (const auto it : npctypeNode.children()) {
+			for (const auto& it : npctypeNode) {
 				std::string type;
 				c4::from_chars(it.key(), &type);
 				std::string type_constant = "SKILL_NONEAR_" + type;
@@ -23511,9 +23511,9 @@ uint64 SkillDatabase::parseBodyNode(const ryml::NodeRef node) {
 #endif
 
 	if (this->nodeExists(node, "CastTimeFlags")) {
-		const auto castNode = node["CastTimeFlags"];
+		const auto& castNode = node["CastTimeFlags"];
 
-		for (const auto it : castNode.children()) {
+		for (const auto& it : castNode) {
 			std::string flag;
 			c4::from_chars(it.key(), &flag);
 			std::string flag_constant = "SKILL_CAST_" + flag;
@@ -23537,9 +23537,9 @@ uint64 SkillDatabase::parseBodyNode(const ryml::NodeRef node) {
 	}
 
 	if (this->nodeExists(node, "CastDelayFlags")) {
-		const auto castNode = node["CastDelayFlags"];
+		const auto& castNode = node["CastDelayFlags"];
 
-		for (const auto it : castNode.children()) {
+		for (const auto& it : castNode) {
 			std::string flag;
 			c4::from_chars(it.key(), &flag);
 			std::string flag_constant = "SKILL_CAST_" + flag;
@@ -23563,7 +23563,7 @@ uint64 SkillDatabase::parseBodyNode(const ryml::NodeRef node) {
 	}
 
 	if (this->nodeExists(node, "Requires")) {
-		const auto requireNode = node["Requires"];
+		const auto& requireNode = node["Requires"];
 
 		if (this->nodeExists(requireNode, "HpCost")) {
 			if (!this->parseNode("HpCost", "Amount", requireNode, skill->require.hp))
@@ -23630,7 +23630,7 @@ uint64 SkillDatabase::parseBodyNode(const ryml::NodeRef node) {
 		}
 
 		if (this->nodeExists(requireNode, "Weapon")) {
-			const auto weaponNode = requireNode["Weapon"];
+			const auto& weaponNode = requireNode["Weapon"];
 
 			if (this->nodeExists(weaponNode, "All")) {
 				bool active;
@@ -23641,7 +23641,7 @@ uint64 SkillDatabase::parseBodyNode(const ryml::NodeRef node) {
 				if (active)
 					skill->require.weapon = 0;
 			} else {
-				for (const auto it : weaponNode.children()) {
+				for (const auto& it : weaponNode) {
 					std::string weapon;
 					c4::from_chars(it.key(), &weapon);
 					std::string weapon_constant = "W_" + weapon;
@@ -23669,7 +23669,7 @@ uint64 SkillDatabase::parseBodyNode(const ryml::NodeRef node) {
 		}
 
 		if (this->nodeExists(requireNode, "Ammo")) {
-			const auto ammoNode = requireNode["Ammo"];
+			const auto& ammoNode = requireNode["Ammo"];
 
 			if (this->nodeExists(ammoNode, "None")) {
 				bool active;
@@ -23680,7 +23680,7 @@ uint64 SkillDatabase::parseBodyNode(const ryml::NodeRef node) {
 				if (active)
 					skill->require.ammo = 0;
 			} else {
-				for (const auto it : ammoNode.children()) {
+				for (const auto& it : ammoNode) {
 					std::string ammo;
 					c4::from_chars(it.key(), &ammo);
 					std::string ammo_constant = "AMMO_" + ammo;
@@ -23738,9 +23738,9 @@ uint64 SkillDatabase::parseBodyNode(const ryml::NodeRef node) {
 		}
 
 		if (this->nodeExists(requireNode, "Status")) {
-			const auto statusNode = requireNode["Status"];
+			const auto& statusNode = requireNode["Status"];
 
-			for (const auto it : statusNode.children()) {
+			for (const auto& it : statusNode) {
 				std::string status;
 				c4::from_chars(it.key(), &status);
 				std::string status_constant = "SC_" + status;
@@ -23777,7 +23777,7 @@ uint64 SkillDatabase::parseBodyNode(const ryml::NodeRef node) {
 			const auto itemNode = requireNode["ItemCost"];
 			int32 count = 0;
 
-			for (const auto it : itemNode.children()) {
+			for (const auto& it : itemNode) {
 				std::string item_name;
 
 				if (!this->asString(it, "Item", item_name))
@@ -23819,9 +23819,9 @@ uint64 SkillDatabase::parseBodyNode(const ryml::NodeRef node) {
 		}
 
 		if (this->nodeExists(requireNode, "Equipment")) {
-			const auto equipNode = requireNode["Equipment"];
+			const auto& equipNode = requireNode["Equipment"];
 
-			for (const auto it : equipNode.children()) {
+			for (const auto& it : equipNode) {
 				std::string item_name;
 				c4::from_chars(it.key(), &item_name);
 
@@ -23856,7 +23856,7 @@ uint64 SkillDatabase::parseBodyNode(const ryml::NodeRef node) {
 	}
 
 	if (this->nodeExists(node, "Unit")) {
-		const auto unitNode = node["Unit"];
+		const auto& unitNode = node["Unit"];
 
 		if (this->nodeExists(unitNode, "Id")) {
 			std::string unit;
@@ -23948,9 +23948,9 @@ uint64 SkillDatabase::parseBodyNode(const ryml::NodeRef node) {
 		}
 
 		if (this->nodeExists(unitNode, "Flag")) {
-			const auto flagNode = unitNode["Flag"];
+			const auto& flagNode = unitNode["Flag"];
 
-			for (const auto it : flagNode.children()) {
+			for (const auto& it : flagNode) {
 				std::string flag;
 				c4::from_chars(it.key(), &flag);
 				std::string flag_constant = "UF_" + flag;
@@ -24064,7 +24064,7 @@ const std::string ReadingSpellbookDatabase::getDefaultLocation() {
  * @param node: YAML node containing the entry.
  * @return count of successfully parsed rows
  */
-uint64 ReadingSpellbookDatabase::parseBodyNode(const ryml::NodeRef node) {
+uint64 ReadingSpellbookDatabase::parseBodyNode(const ryml::NodeRef& node) {
 	std::string skill_name;
 
 	if (!this->asString(node, "Skill", skill_name))
@@ -24130,7 +24130,7 @@ uint64 ReadingSpellbookDatabase::parseBodyNode(const ryml::NodeRef node) {
  * @return Spell data or nullptr otherwise
  */
 std::shared_ptr<s_skill_spellbook_db> ReadingSpellbookDatabase::findBook(t_itemid nameid) {
-	if (nameid == 0 || !itemdb_exists(nameid) || reading_spellbook_db.size() == 0)
+	if (nameid == 0 || !itemdb_exists(nameid) || reading_spellbook_db.empty())
 		return nullptr;
 
 	for (const auto &spell : reading_spellbook_db) {
@@ -24150,7 +24150,7 @@ const std::string MagicMushroomDatabase::getDefaultLocation() {
  * @param node: YAML node containing the entry.
  * @return count of successfully parsed rows
  */
-uint64 MagicMushroomDatabase::parseBodyNode(const ryml::NodeRef node) {
+uint64 MagicMushroomDatabase::parseBodyNode(const ryml::NodeRef& node) {
 	std::string skill_name;
 
 	if (!this->asString(node, "Skill", skill_name))
@@ -24249,7 +24249,7 @@ const std::string SkillArrowDatabase::getDefaultLocation() {
  * @param node: YAML node containing the entry.
  * @return count of successfully parsed rows
  */
-uint64 SkillArrowDatabase::parseBodyNode(const ryml::NodeRef node) {
+uint64 SkillArrowDatabase::parseBodyNode(const ryml::NodeRef& node) {
 	std::string source_name;
 
 	if (!this->asString(node, "Source", source_name))
@@ -24272,9 +24272,9 @@ uint64 SkillArrowDatabase::parseBodyNode(const ryml::NodeRef node) {
 		arrow->nameid = nameid;
 	}
 
-	const auto MakeNode = node["Make"];
+	const auto& MakeNode = node["Make"];
 
-	for (const auto &it : MakeNode.children()) {
+	for (const auto &it : MakeNode) {
 		std::string item_name;
 
 		if (!this->asString(it, "Item", item_name))
@@ -24320,7 +24320,7 @@ const std::string AbraDatabase::getDefaultLocation() {
  * @param node: YAML node containing the entry.
  * @return count of successfully parsed rows
  */
-uint64 AbraDatabase::parseBodyNode(const ryml::NodeRef node) {
+uint64 AbraDatabase::parseBodyNode(const ryml::NodeRef& node) {
 	std::string skill_name;
 
 	if (!this->asString(node, "Skill", skill_name))
@@ -24347,7 +24347,7 @@ uint64 AbraDatabase::parseBodyNode(const ryml::NodeRef node) {
 	}
 
 	if (this->nodeExists(node, "Probability")) {
-		const auto probNode = node["Probability"];
+		const auto& probNode = node["Probability"];
 		uint16 probability;
 
 		if (!probNode.is_seq()) {
@@ -24358,7 +24358,7 @@ uint64 AbraDatabase::parseBodyNode(const ryml::NodeRef node) {
 		} else {
 			abra->per.fill(0);
 
-			for (const auto it : probNode.children()) {
+			for (const auto& it : probNode) {
 				uint16 skill_lv;
 
 				if (!this->asUInt16(it, "Level", skill_lv))

src/map/skill.hpp

@@ -312,7 +312,7 @@ private:
 	/// Skill count, also as last index
 	uint16 skill_num;
 
-	template<typename T, size_t S> bool parseNode(std::string nodeName, std::string subNodeName, ryml::NodeRef node, T(&arr)[S]);
+	template<typename T, size_t S> bool parseNode(const std::string& nodeName, const std::string& subNodeName, const ryml::NodeRef& node, T(&arr)[S]);
 
 public:
 	SkillDatabase() : TypesafeCachedYamlDatabase("SKILL_DB", 3, 1) {
@@ -320,7 +320,7 @@ public:
 	}
 
 	const std::string getDefaultLocation() override;
-	uint64 parseBodyNode(const ryml::NodeRef node) override;
+	uint64 parseBodyNode(const ryml::NodeRef& node) override;
 	void clear() override;
 	void loadingFinished() override;
 
@@ -462,7 +462,7 @@ public:
 	}
 
 	const std::string getDefaultLocation() override;
-	uint64 parseBodyNode(const ryml::NodeRef node) override;
+	uint64 parseBodyNode(const ryml::NodeRef& node) override;
 };
 
 extern SkillArrowDatabase skill_arrow_db;
@@ -480,21 +480,7 @@ public:
 	}
 
 	const std::string getDefaultLocation() override;
-	uint64 parseBodyNode(const ryml::NodeRef node) override;
-};
-
-struct s_skill_improvise_db {
-	uint16 skill_id, per;
-};
-
-class ImprovisedSongDatabase : public TypesafeYamlDatabase<uint16, s_skill_improvise_db> {
-public:
-	ImprovisedSongDatabase() : TypesafeYamlDatabase("IMPROVISED_SONG_DB", 1) {
-
-	}
-
-	const std::string getDefaultLocation() override;
-	uint64 parseBodyNode(const ryml::NodeRef node) override;
+	uint64 parseBodyNode(const ryml::NodeRef& node) override;
 };
 
 void do_init_skill(void);
@@ -2568,7 +2554,7 @@ public:
 	}
 
 	const std::string getDefaultLocation() override;
-	uint64 parseBodyNode(const ryml::NodeRef node) override;
+	uint64 parseBodyNode(const ryml::NodeRef& node) override;
 
 	// Additional
 	std::shared_ptr<s_skill_spellbook_db> findBook(t_itemid nameid);
@@ -2591,7 +2577,7 @@ public:
 	}
 
 	const std::string getDefaultLocation() override;
-	uint64 parseBodyNode(const ryml::NodeRef node) override;
+	uint64 parseBodyNode(const ryml::NodeRef& node) override;
 };
 
 extern MagicMushroomDatabase magic_mushroom_db;

src/map/status.cpp

@@ -117,7 +117,7 @@ const std::string RefineDatabase::getDefaultLocation(){
 	return std::string( db_path ) + "/refine.yml";
 }
 
-uint64 RefineDatabase::parseBodyNode( const ryml::NodeRef node ){
+uint64 RefineDatabase::parseBodyNode( const ryml::NodeRef& node ){
 	std::string group_name;
 
 	if( !this->asString( node, "Group", group_name ) ){
@@ -142,8 +142,8 @@ uint64 RefineDatabase::parseBodyNode( const ryml::NodeRef node ){
 	}
 
 	if( this->nodeExists( node, "Levels" ) ){
-		const auto levelsNode = node["Levels"];
-		for( const auto levelNode : levelsNode.children() ){
+		const auto& levelsNode = node["Levels"];
+		for( const auto& levelNode : levelsNode ){
 			uint16 level;
 
 			if( !this->asUInt16( levelNode, "Level", level ) ){
@@ -159,8 +159,8 @@ uint64 RefineDatabase::parseBodyNode( const ryml::NodeRef node ){
 			}
 
 			if( this->nodeExists( levelNode, "RefineLevels" ) ){
-				const auto refineLevelsNode = levelNode["RefineLevels"];
-				for( const auto refineLevelNode : refineLevelsNode.children() ){
+				const auto& refineLevelsNode = levelNode["RefineLevels"];
+				for( const auto& refineLevelNode : refineLevelsNode ){
 					uint16 refine_level;
 
 					if( !this->asUInt16( refineLevelNode, "Level", refine_level ) ){
@@ -231,8 +231,8 @@ uint64 RefineDatabase::parseBodyNode( const ryml::NodeRef node ){
 					}
 
 					if( this->nodeExists( refineLevelNode, "Chances" ) ){
-						const auto chancesNode = refineLevelNode["Chances"];
-						for( const auto chanceNode : chancesNode ){
+						const auto& chancesNode = refineLevelNode["Chances"];
+						for( const auto& chanceNode : chancesNode ){
 							std::string cost_name;
 
 							if( !this->asString( chanceNode, "Type", cost_name ) ){
@@ -459,7 +459,7 @@ const std::string SizeFixDatabase::getDefaultLocation() {
  * @param node: YAML node containing the entry.
  * @return count of successfully parsed rows
  */
-uint64 SizeFixDatabase::parseBodyNode(const ryml::NodeRef node) {
+uint64 SizeFixDatabase::parseBodyNode(const ryml::NodeRef& node) {
 	std::string weapon_name;
 
 	if (!this->asString(node, "Weapon", weapon_name))
@@ -653,7 +653,7 @@ void StatusDatabase::changeSkillTree(map_session_data *sd, int32 class_) {
 		uint16 skill_id = it.first;
 		sc_type sc = skill_get_sc(skill_id);
 
-		if (sc > SC_COMMON_MAX && sd->sc.data[sc])
+		if (sc > SC_COMMON_MAX && sc < SC_MAX && sd->sc.data[sc])
 			status_change_end(&sd->bl, sc, INVALID_TIMER);
 	}
 }
@@ -14556,7 +14556,7 @@ const std::string AttributeDatabase::getDefaultLocation() {
  * @param node: YAML node containing the entry.
  * @return count of successfully parsed rows
  */
-uint64 AttributeDatabase::parseBodyNode(const ryml::NodeRef node) {
+uint64 AttributeDatabase::parseBodyNode(const ryml::NodeRef& node) {
 	uint16 level;
 
 	if (!this->asUInt16(node, "Level", level))
@@ -14571,7 +14571,7 @@ uint64 AttributeDatabase::parseBodyNode(const ryml::NodeRef node) {
 		if (!this->nodeExists(node, itatk.first))
 			continue;
 
-		const auto eleNode = node[c4::to_csubstr(itatk.first)];
+		const auto& eleNode = node[c4::to_csubstr(itatk.first)];
 
 		for (const auto &itdef : um_eleid2elename) {
 			if (!this->nodeExists(eleNode, itdef.first))
@@ -14622,7 +14622,7 @@ const std::string StatusDatabase::getDefaultLocation() {
  * @param node: YAML node containing the entry.
  * @return count of successfully parsed rows
  */
-uint64 StatusDatabase::parseBodyNode(const ryml::NodeRef node) {
+uint64 StatusDatabase::parseBodyNode(const ryml::NodeRef& node) {
 	std::string status_name;
 
 	if (!this->asString(node, "Status", status_name))
@@ -14692,9 +14692,9 @@ uint64 StatusDatabase::parseBodyNode(const ryml::NodeRef node) {
 	}
 
 	if (this->nodeExists(node, "States")) {
-		const ryml::NodeRef stateNode = node["States"];
+		const ryml::NodeRef& stateNode = node["States"];
 
-		for (const auto &it : stateNode.children()) {
+		for (const auto &it : stateNode) {
 			std::string state;
 			c4::from_chars(it.key(), &state);
 
@@ -14727,9 +14727,9 @@ uint64 StatusDatabase::parseBodyNode(const ryml::NodeRef node) {
 	}
 
 	if (this->nodeExists(node, "CalcFlags")) {
-		const ryml::NodeRef flagNode = node["CalcFlags"];
+		const ryml::NodeRef& flagNode = node["CalcFlags"];
 
-		for (const auto &it : flagNode.children()) {
+		for (const auto &it : flagNode) {
 			if (this->nodeExists(it, "All")) {
 				bool active;
 
@@ -14743,7 +14743,7 @@ uint64 StatusDatabase::parseBodyNode(const ryml::NodeRef node) {
 			}
 		}
 
-		for (const auto &it : flagNode.children()) {
+		for (const auto &it : flagNode) {
 			std::string flag;
 			c4::from_chars(it.key(), &flag);
 
@@ -14805,9 +14805,9 @@ uint64 StatusDatabase::parseBodyNode(const ryml::NodeRef node) {
 	}
 
 	if (this->nodeExists(node, "Opt2")) {
-		const ryml::NodeRef optNode = node["Opt2"];
+		const ryml::NodeRef& optNode = node["Opt2"];
 
-		for (const auto &it : optNode.children()) {
+		for (const auto &it : optNode) {
 			std::string opt;
 			c4::from_chars(it.key(), &opt);
 
@@ -14840,9 +14840,9 @@ uint64 StatusDatabase::parseBodyNode(const ryml::NodeRef node) {
 	}
 
 	if (this->nodeExists(node, "Opt3")) {
-		const ryml::NodeRef optNode = node["Opt3"];
+		const ryml::NodeRef& optNode = node["Opt3"];
 
-		for (const auto &it : optNode.children()) {
+		for (const auto &it : optNode) {
 			std::string opt;
 			c4::from_chars(it.key(), &opt);
 
@@ -14875,9 +14875,9 @@ uint64 StatusDatabase::parseBodyNode(const ryml::NodeRef node) {
 	}
 
 	if (this->nodeExists(node, "Options")) {
-		const ryml::NodeRef optionNode = node["Options"];
+		const ryml::NodeRef& optionNode = node["Options"];
 
-		for (const auto &it : optionNode.children()) {
+		for (const auto &it : optionNode) {
 			std::string option;
 			c4::from_chars(it.key(), &option);
 
@@ -14910,9 +14910,9 @@ uint64 StatusDatabase::parseBodyNode(const ryml::NodeRef node) {
 	}
 
 	if (this->nodeExists(node, "Flags")) {
-		const ryml::NodeRef flagNode = node["Flags"];
+		const ryml::NodeRef& flagNode = node["Flags"];
 
-		for (const auto &it : flagNode.children()) {
+		for (const auto &it : flagNode) {
 			std::string flag;
 			c4::from_chars(it.key(), &flag);
 
@@ -14969,9 +14969,9 @@ uint64 StatusDatabase::parseBodyNode(const ryml::NodeRef node) {
 	}
 
 	if (this->nodeExists(node, "Fail")) {
-		const ryml::NodeRef failNode = node["Fail"];
+		const ryml::NodeRef& failNode = node["Fail"];
 
-		for (const auto &it : failNode.children()) {
+		for (const auto &it : failNode) {
 			std::string fail;
 			c4::from_chars(it.key(), &fail);
 
@@ -15001,9 +15001,9 @@ uint64 StatusDatabase::parseBodyNode(const ryml::NodeRef node) {
 	}
 
 	if (this->nodeExists(node, "End")) {
-		const ryml::NodeRef endNode = node["End"];
+		const ryml::NodeRef& endNode = node["End"];
 
-		for (const auto &it : endNode.children()) {
+		for (const auto &it : endNode) {
 			std::string end;
 			c4::from_chars(it.key(), &end);
 

src/map/status.hpp

@@ -97,7 +97,7 @@ public:
 	}
 
 	const std::string getDefaultLocation() override;
-	uint64 parseBodyNode( const ryml::NodeRef node ) override;
+	uint64 parseBodyNode( const ryml::NodeRef& node ) override;
 
 	// Additional
 	std::shared_ptr<s_refine_level_info> findLevelInfo( const struct item_data& data, struct item& item );
@@ -118,7 +118,7 @@ public:
 	}
 
 	const std::string getDefaultLocation() override;
-	uint64 parseBodyNode(const ryml::NodeRef node) override;
+	uint64 parseBodyNode(const ryml::NodeRef& node) override;
 };
 
 extern SizeFixDatabase size_fix_db;
@@ -136,7 +136,7 @@ public:
 		std::fill_n(&attr_fix_table[0][0][0], MAX_ELE_LEVEL * ELE_MAX * ELE_MAX, 100);
 	}
 	const std::string getDefaultLocation() override;
-	uint64 parseBodyNode(const ryml::NodeRef node) override;
+	uint64 parseBodyNode(const ryml::NodeRef& node) override;
 
 	// Additional
 	int16 getAttribute(uint16 level, uint16 atk_ele, uint16 def_ele);
@@ -2888,7 +2888,7 @@ public:
 	}
 
 	const std::string getDefaultLocation() override;
-	uint64 parseBodyNode(const ryml::NodeRef node) override;
+	uint64 parseBodyNode(const ryml::NodeRef& node) override;
 	void loadingFinished() override;
 
 	// Determine who will receive a clif_status_change packet for effects that require one to display correctly

src/tool/yaml.hpp

@@ -529,7 +529,7 @@ const std::string ItemDatabase::getDefaultLocation() {
 	return std::string(db_path) + "/item_db.yml";
 }
 
-uint64 ItemDatabase::parseBodyNode(const ryml::NodeRef node) {
+uint64 ItemDatabase::parseBodyNode(const ryml::NodeRef& node) {
 	t_itemid nameid;
 
 	if (!this->asUInt32(node, "Id", nameid))
@@ -552,7 +552,7 @@ uint64 ItemDatabase::parseBodyNode(const ryml::NodeRef node) {
 
 		if (look > 0) {
 			if (this->nodeExists(node, "Locations")) {
-				const ryml::NodeRef locationNode = node["Locations"];
+				const ryml::NodeRef& locationNode = node["Locations"];
 
 				static std::vector<std::string> locations = {
 					"Head_Low",
@@ -608,7 +608,7 @@ const std::string SkillDatabase::getDefaultLocation() {
 	return std::string(db_path) + "/skill_db.yml";
 }
 
-uint64 SkillDatabase::parseBodyNode(const ryml::NodeRef node) {
+uint64 SkillDatabase::parseBodyNode(const ryml::NodeRef& node) {
 	t_itemid nameid;
 
 	if (!this->asUInt32(node, "Id", nameid))
@@ -639,7 +639,7 @@ const std::string MobDatabase::getDefaultLocation(){
 	return std::string( db_path ) + "/mob_db.yml";
 }
 
-uint64 MobDatabase::parseBodyNode(const ryml::NodeRef node) {
+uint64 MobDatabase::parseBodyNode(const ryml::NodeRef& node) {
 	uint16 mob_id;
 
 	if (!this->asUInt16(node, "Id", mob_id))