noexcept + const in MetaName

mrotteveel · mrotteveel · commit d2caf98a845e · 2025-08-05T09:51:10.000+02:00
diff --git a/src/jrd/MetaName.cpp b/src/jrd/MetaName.cpp
@@ -29,6 +29,7 @@
 #include "firebird.h"
 
 #include <stdarg.h>
+#include <algorithm>
 
 #include "../jrd/MetaName.h"
 #include "../common/classes/MetaString.h"
@@ -42,7 +43,7 @@ int MetaName::compare(const char* s, FB_SIZE_T len) const
 	if (s)
 	{
 		adjustLength(s, len);
-		FB_SIZE_T x = length() < len ? length() : len;
+		const FB_SIZE_T x = std::min(length(), len);
 		int rc = memcmp(c_str(), s, x);
 		if (rc)
 		{
@@ -55,11 +56,11 @@ int MetaName::compare(const char* s, FB_SIZE_T len) const
 	return length() - len;
 }
 
-void MetaName::adjustLength(const char* const s, FB_SIZE_T& len)
+void MetaName::adjustLength(const char* const s, FB_SIZE_T& len) noexcept
 {
+	fb_assert(s);
 	if (len > MAX_SQL_IDENTIFIER_LEN)
 	{
-		fb_assert(s);
 #ifdef DEV_BUILD
 		for (FB_SIZE_T i = MAX_SQL_IDENTIFIER_LEN; i < len; ++i)
 			fb_assert(s[i] == '\0' || s[i] == ' ');
@@ -81,7 +82,7 @@ void MetaName::printf(const char* format, ...)
 	char data[MAX_SQL_IDENTIFIER_LEN + 1];
 	va_list params;
 	va_start(params, format);
-	int len = VSNPRINTF(data, MAX_SQL_IDENTIFIER_LEN, format, params);
+	int len = vsnprintf(data, MAX_SQL_IDENTIFIER_LEN, format, params);
 	va_end(params);
 
 	if (len < 0 || FB_SIZE_T(len) > MAX_SQL_IDENTIFIER_LEN)
@@ -105,7 +106,7 @@ FB_SIZE_T MetaName::copyTo(char* to, FB_SIZE_T toSize) const
 	return toSize;
 }
 
-MetaName::operator Firebird::MetaString() const
+MetaName::operator Firebird::MetaString() const noexcept
 {
 	return Firebird::MetaString(c_str(), length());
 }
@@ -125,7 +126,7 @@ void MetaName::test()
 #if defined(DEV_BUILD) || GROW_DEBUG > 0
 	if (word)
 	{
-		Dictionary::Word* checkWord = get(word->c_str(), word->length());
+		const Dictionary::Word* checkWord = get(word->c_str(), word->length());
 		fb_assert(checkWord == word);
 #ifndef DEV_BUILD
 		if (word != checkWord)
@@ -135,17 +136,15 @@ void MetaName::test()
 #endif
 }
 
-const char* MetaName::EMPTY = "";
-
 #if GROW_DEBUG > 1
-static const unsigned int hashSize[] = {1000, 2000, 4000, 6000, 8000, 10000,
+static constexpr unsigned int hashSize[] = {1000, 2000, 4000, 6000, 8000, 10000,
 										12000, 14000, 16000, 18000, 20000,
 										22000, 24000, 26000, 28000, 30000,
 										32000, 34000, 36000, 38000, 40000,
 										42000, 44000, 46000, 48000, 50000,
 										52000, 54000, 56000, 58000, 60000};
 #else
-static const unsigned int hashSize[] = { 10007, 100003, 1000003 };
+static constexpr unsigned int hashSize[] = { 10007, 100003, 1000003 };
 #endif
 
 Dictionary::Dictionary(MemoryPool& p)
@@ -187,7 +186,7 @@ Dictionary::HashTable::HashTable(MemoryPool& p, unsigned lvl)
 		table[n].store(nullptr, std::memory_order_relaxed);
 }
 
-unsigned Dictionary::HashTable::getMaxLevel()
+unsigned Dictionary::HashTable::getMaxLevel() noexcept
 {
 	return FB_NELEM(hashSize) - 1;
 }
@@ -223,7 +222,7 @@ Dictionary::TableData* Dictionary::HashTable::getEntryByHash(const char* s, FB_S
 	return &table[h];
 }
 
-bool Dictionary::checkConsistency(Dictionary::HashTable* oldValue)
+bool Dictionary::checkConsistency(const Dictionary::HashTable* oldValue) noexcept
 {
 	return oldValue->level == nextLevel.load();
 }
@@ -291,7 +290,7 @@ Dictionary::Word* Dictionary::get(const char* s, FB_SIZE_T len)
 					{
 						segment = FB_NEW_POOL(getPool()) Segment;
 						++segCount;
-						unsigned lvl = nextLevel.load();
+						const unsigned lvl = nextLevel.load();
 						if (lvl < HashTable::getMaxLevel() &&
 							segCount * Segment::getWordCapacity() > hashSize[lvl])
 						{
@@ -366,7 +365,7 @@ void Dictionary::growHash()
 
 	// move one level up size of hash table
 	HashTable* tab = hashTable.load();
-	unsigned lvl = ++nextLevel;
+	const unsigned lvl = ++nextLevel;
 	fb_assert(lvl == tab->level + 1);
 	fb_assert(lvl <= HashTable::getMaxLevel());
 
@@ -421,7 +420,7 @@ Dictionary::HashTable* Dictionary::waitForMutex(Jrd::Dictionary::Word** checkWor
 		return t;
 
 	// may be we already have that word in new table
-	FB_SIZE_T len = (*checkWordPtr)->length();
+	const FB_SIZE_T len = (*checkWordPtr)->length();
 	const char* s = (*checkWordPtr)->c_str();
 	Word* word = t->getEntryByHash(s, len)->load();
 	while (word)
@@ -441,25 +440,25 @@ Dictionary::HashTable* Dictionary::waitForMutex(Jrd::Dictionary::Word** checkWor
 	return t;
 }
 
-Dictionary::Segment::Segment()
+Dictionary::Segment::Segment() noexcept
 {
 	position.store(0, std::memory_order_relaxed);
 }
 
-unsigned Dictionary::Segment::getWordCapacity()
+constexpr unsigned Dictionary::Segment::getWordCapacity() noexcept
 {
-	const unsigned AVERAGE_BYTES_LEN = 16;
+	constexpr unsigned AVERAGE_BYTES_LEN = 16;
 	return SEG_BUFFER_SIZE / getWordLength(AVERAGE_BYTES_LEN);
 }
 
-unsigned Dictionary::Segment::getWordLength(FB_SIZE_T len)
+constexpr unsigned Dictionary::Segment::getWordLength(FB_SIZE_T len) noexcept
 {
 	// calculate length in sizeof(Word*)
 	len += 2;
-	return 1 + (len / sizeof(Word*)) + (len % sizeof(Word*) ? 1 : 0);
+	return 1 + (len / sizeof(Word*)) + ((len % sizeof(Word*)) ? 1 : 0);
 }
 
-Dictionary::Word* Dictionary::Segment::getSpace(FB_SIZE_T len DIC_STAT_SEGMENT_PAR)
+Dictionary::Word* Dictionary::Segment::getSpace(FB_SIZE_T len DIC_STAT_SEGMENT_PAR) noexcept
 {
 	len = getWordLength(len);
 
@@ -470,7 +469,7 @@ Dictionary::Word* Dictionary::Segment::getSpace(FB_SIZE_T len DIC_STAT_SEGMENT_P
 	for(;;)
 	{
 		// calculate and check new position
-		unsigned newPos = oldPos + len;
+		const unsigned newPos = oldPos + len;
 		if (newPos >= SEG_BUFFER_SIZE)
 			break;
 
diff --git a/src/jrd/MetaName.h b/src/jrd/MetaName.h
@@ -73,12 +73,12 @@ class Dictionary : public Firebird::PermanentStorage
 		char text[1];
 
 	public:
-		const char* c_str() const
+		const char* c_str() const noexcept
 		{
 			return text;
 		}
 
-		FB_SIZE_T length() const
+		FB_SIZE_T length() const noexcept
 		{
 			return textLen;
 		}
@@ -102,31 +102,31 @@ class Dictionary : public Firebird::PermanentStorage
 	public:
 		HashTable(MemoryPool& p, unsigned lvl);
 		Dictionary::TableData* getEntryByHash(const char* s, FB_SIZE_T len);
-		static unsigned getMaxLevel();
+		static unsigned getMaxLevel() noexcept;
 
 		const unsigned level;
 		TableData* table;
 	};
 	std::atomic<HashTable*> hashTable;
 	std::atomic<unsigned> nextLevel;
 
-	bool checkConsistency(HashTable* oldValue);
+	bool checkConsistency(const HashTable* oldValue) noexcept;
 	HashTable* waitForMutex(Word** checkWordPtr = nullptr);
 
 	class Segment
 	{
 	public:
-		Segment();
-		Word* getSpace(FB_SIZE_T l DIC_STAT_SEGMENT_PAR);
-		static unsigned getWordCapacity();
+		Segment() noexcept;
+		Word* getSpace(FB_SIZE_T len DIC_STAT_SEGMENT_PAR) noexcept;
+		static constexpr unsigned getWordCapacity() noexcept;
 
 	private:
-		static unsigned getWordLength(FB_SIZE_T len);
+		static constexpr unsigned getWordLength(FB_SIZE_T len) noexcept;
 
 #if GROW_DEBUG > 1
-		static const unsigned SEG_BUFFER_SIZE = 256;		// size in sizeof(pointer)
+		static constexpr unsigned SEG_BUFFER_SIZE = 256;		// size in sizeof(pointer)
 #else
-		static const unsigned SEG_BUFFER_SIZE = 16384;		// size in sizeof(pointer)
+		static constexpr unsigned SEG_BUFFER_SIZE = 16384;		// size in sizeof(pointer)
 #endif
 		void* buffer[SEG_BUFFER_SIZE];
 		std::atomic<unsigned> position;
@@ -141,7 +141,7 @@ class MetaName
 {
 private:
 	Dictionary::Word* word;
-	static const char* EMPTY;
+	static constexpr const char* EMPTY = "";
 
 	void test();
 	Dictionary::Word* get(const char* s, FB_SIZE_T l);
@@ -152,7 +152,7 @@ class MetaName
 	}
 
 public:
-	MetaName()
+	MetaName() noexcept
 		: word(nullptr)
 	{ }
 
@@ -177,7 +177,7 @@ class MetaName
 	{ }
 
 
-	explicit MetaName(MemoryPool&)
+	explicit MetaName(MemoryPool&) noexcept
 		: word(nullptr)
 	{ }
 
@@ -233,43 +233,43 @@ class MetaName
 
 	MetaName& operator=(const Firebird::MetaString& s);
 
-	FB_SIZE_T length() const
+	FB_SIZE_T length() const noexcept
 	{
 		return word ? word->length() : 0;
 	}
 
-	const char* c_str() const
+	const char* c_str() const noexcept
 	{
 		return word ? word->c_str() : EMPTY;
 	}
 
-	const char* nullStr() const
+	const char* nullStr() const noexcept
 	{
 		return word ? word->c_str() : nullptr;
 	}
 
-	bool isEmpty() const
+	bool isEmpty() const noexcept
 	{
 		return !word;
 	}
 
-	bool hasData() const
+	bool hasData() const noexcept
 	{
 		return word;
 	}
 
-	char operator[](unsigned n) const
+	char operator[](unsigned n) const noexcept
 	{
 		fb_assert(n < length());
 		return word->c_str()[n];
 	}
 
-	const char* begin() const
+	const char* begin() const noexcept
 	{
 		return word ? word->c_str() : EMPTY;
 	}
 
-	const char* end() const
+	const char* end() const noexcept
 	{
 		return word ? &word->c_str()[length()] : EMPTY;
 	}
@@ -354,22 +354,22 @@ class MetaName
 		return compare(m) >  0;
 	}
 
-	bool operator==(const MetaName& m) const
+	bool operator==(const MetaName& m) const noexcept
 	{
 		return word == m.word;
 	}
 
-	bool operator!=(const MetaName& m) const
+	bool operator!=(const MetaName& m) const noexcept
 	{
 		return word != m.word;
 	}
 
 	void printf(const char*, ...);
 	FB_SIZE_T copyTo(char* to, FB_SIZE_T toSize) const;
-	operator Firebird::MetaString() const;
+	operator Firebird::MetaString() const noexcept;
 
 protected:
-	static void adjustLength(const char* const s, FB_SIZE_T& l);
+	static void adjustLength(const char* const s, FB_SIZE_T& l) noexcept;
 };
 
 typedef Firebird::Pair<Firebird::Full<MetaName, MetaName> > MetaNamePair;

Original file line number	Diff line number	Diff line change
`@@ -29,6 +29,7 @@`
`29`	`29`	`#include "firebird.h"`
`30`	`30`
`31`	`31`	`#include <stdarg.h>`
	`32`	`+#include <algorithm>`
`32`	`33`
`33`	`34`	`#include "../jrd/MetaName.h"`
`34`	`35`	`#include "../common/classes/MetaString.h"`
`@@ -42,7 +43,7 @@ int MetaName::compare(const char* s, FB_SIZE_T len) const`
`42`	`43`	`if (s)`
`43`	`44`	`{`
`44`	`45`	`adjustLength(s, len);`
`45`		`- FB_SIZE_T x = length() < len ? length() : len;`
	`46`	`+ const FB_SIZE_T x = std::min(length(), len);`
`46`	`47`	`int rc = memcmp(c_str(), s, x);`
`47`	`48`	`if (rc)`
`48`	`49`	`{`
`@@ -55,11 +56,11 @@ int MetaName::compare(const char* s, FB_SIZE_T len) const`
`55`	`56`	`return length() - len;`
`56`	`57`	`}`
`57`	`58`
`58`		`-void MetaName::adjustLength(const char* const s, FB_SIZE_T& len)`
	`59`	`+void MetaName::adjustLength(const char* const s, FB_SIZE_T& len) noexcept`
`59`	`60`	`{`
	`61`	`+ fb_assert(s);`
`60`	`62`	`if (len > MAX_SQL_IDENTIFIER_LEN)`
`61`	`63`	`{`
`62`		`- fb_assert(s);`
`63`	`64`	`#ifdef DEV_BUILD`
`64`	`65`	`for (FB_SIZE_T i = MAX_SQL_IDENTIFIER_LEN; i < len; ++i)`
`65`	`66`	`fb_assert(s[i] == '\0' \|\| s[i] == ' ');`
`@@ -81,7 +82,7 @@ void MetaName::printf(const char* format, ...)`
`81`	`82`	`char data[MAX_SQL_IDENTIFIER_LEN + 1];`
`82`	`83`	`va_list params;`
`83`	`84`	`va_start(params, format);`
`84`		`- int len = VSNPRINTF(data, MAX_SQL_IDENTIFIER_LEN, format, params);`
	`85`	`+ int len = vsnprintf(data, MAX_SQL_IDENTIFIER_LEN, format, params);`
`85`	`86`	`va_end(params);`
`86`	`87`
`87`	`88`	`if (len < 0 \|\| FB_SIZE_T(len) > MAX_SQL_IDENTIFIER_LEN)`
`@@ -105,7 +106,7 @@ FB_SIZE_T MetaName::copyTo(char* to, FB_SIZE_T toSize) const`
`105`	`106`	`return toSize;`
`106`	`107`	`}`
`107`	`108`
`108`		`-MetaName::operator Firebird::MetaString() const`
	`109`	`+MetaName::operator Firebird::MetaString() const noexcept`
`109`	`110`	`{`
`110`	`111`	`return Firebird::MetaString(c_str(), length());`
`111`	`112`	`}`
`@@ -125,7 +126,7 @@ void MetaName::test()`
`125`	`126`	`#if defined(DEV_BUILD) \|\| GROW_DEBUG > 0`
`126`	`127`	`if (word)`
`127`	`128`	`{`
`128`		`- Dictionary::Word* checkWord = get(word->c_str(), word->length());`
	`129`	`+ const Dictionary::Word* checkWord = get(word->c_str(), word->length());`
`129`	`130`	`fb_assert(checkWord == word);`
`130`	`131`	`#ifndef DEV_BUILD`
`131`	`132`	`if (word != checkWord)`
`@@ -135,17 +136,15 @@ void MetaName::test()`
`135`	`136`	`#endif`
`136`	`137`	`}`
`137`	`138`
`138`		`-const char* MetaName::EMPTY = "";`
`139`		`-`
`140`	`139`	`#if GROW_DEBUG > 1`
`141`		`-static const unsigned int hashSize[] = {1000, 2000, 4000, 6000, 8000, 10000,`
	`140`	`+static constexpr unsigned int hashSize[] = {1000, 2000, 4000, 6000, 8000, 10000,`
`142`	`141`	`12000, 14000, 16000, 18000, 20000,`
`143`	`142`	`22000, 24000, 26000, 28000, 30000,`
`144`	`143`	`32000, 34000, 36000, 38000, 40000,`
`145`	`144`	`42000, 44000, 46000, 48000, 50000,`
`146`	`145`	`52000, 54000, 56000, 58000, 60000};`
`147`	`146`	`#else`
`148`		`-static const unsigned int hashSize[] = { 10007, 100003, 1000003 };`
	`147`	`+static constexpr unsigned int hashSize[] = { 10007, 100003, 1000003 };`
`149`	`148`	`#endif`
`150`	`149`
`151`	`150`	`Dictionary::Dictionary(MemoryPool& p)`
`@@ -187,7 +186,7 @@ Dictionary::HashTable::HashTable(MemoryPool& p, unsigned lvl)`
`187`	`186`	`table[n].store(nullptr, std::memory_order_relaxed);`
`188`	`187`	`}`
`189`	`188`
`190`		`-unsigned Dictionary::HashTable::getMaxLevel()`
	`189`	`+unsigned Dictionary::HashTable::getMaxLevel() noexcept`
`191`	`190`	`{`
`192`	`191`	`return FB_NELEM(hashSize) - 1;`
`193`	`192`	`}`
`@@ -223,7 +222,7 @@ Dictionary::TableData* Dictionary::HashTable::getEntryByHash(const char* s, FB_S`
`223`	`222`	`return &table[h];`
`224`	`223`	`}`
`225`	`224`
`226`		`-bool Dictionary::checkConsistency(Dictionary::HashTable* oldValue)`
	`225`	`+bool Dictionary::checkConsistency(const Dictionary::HashTable* oldValue) noexcept`
`227`	`226`	`{`
`228`	`227`	`return oldValue->level == nextLevel.load();`
`229`	`228`	`}`
`@@ -291,7 +290,7 @@ Dictionary::Word* Dictionary::get(const char* s, FB_SIZE_T len)`
`291`	`290`	`{`
`292`	`291`	`segment = FB_NEW_POOL(getPool()) Segment;`
`293`	`292`	`++segCount;`
`294`		`- unsigned lvl = nextLevel.load();`
	`293`	`+ const unsigned lvl = nextLevel.load();`
`295`	`294`	`if (lvl < HashTable::getMaxLevel() &&`
`296`	`295`	`segCount * Segment::getWordCapacity() > hashSize[lvl])`
`297`	`296`	`{`
`@@ -366,7 +365,7 @@ void Dictionary::growHash()`
`366`	`365`
`367`	`366`	`// move one level up size of hash table`
`368`	`367`	`HashTable* tab = hashTable.load();`
`369`		`- unsigned lvl = ++nextLevel;`
	`368`	`+ const unsigned lvl = ++nextLevel;`
`370`	`369`	`fb_assert(lvl == tab->level + 1);`
`371`	`370`	`fb_assert(lvl <= HashTable::getMaxLevel());`
`372`	`371`
`@@ -421,7 +420,7 @@ Dictionary::HashTable* Dictionary::waitForMutex(Jrd::Dictionary::Word** checkWor`
`421`	`420`	`return t;`
`422`	`421`
`423`	`422`	`// may be we already have that word in new table`
`424`		`- FB_SIZE_T len = (*checkWordPtr)->length();`
	`423`	`+ const FB_SIZE_T len = (*checkWordPtr)->length();`
`425`	`424`	`const char* s = (*checkWordPtr)->c_str();`
`426`	`425`	`Word* word = t->getEntryByHash(s, len)->load();`
`427`	`426`	`while (word)`
`@@ -441,25 +440,25 @@ Dictionary::HashTable* Dictionary::waitForMutex(Jrd::Dictionary::Word** checkWor`
`441`	`440`	`return t;`
`442`	`441`	`}`
`443`	`442`
`444`		`-Dictionary::Segment::Segment()`
	`443`	`+Dictionary::Segment::Segment() noexcept`
`445`	`444`	`{`
`446`	`445`	`position.store(0, std::memory_order_relaxed);`
`447`	`446`	`}`
`448`	`447`
`449`		`-unsigned Dictionary::Segment::getWordCapacity()`
	`448`	`+constexpr unsigned Dictionary::Segment::getWordCapacity() noexcept`
`450`	`449`	`{`
`451`		`- const unsigned AVERAGE_BYTES_LEN = 16;`
	`450`	`+ constexpr unsigned AVERAGE_BYTES_LEN = 16;`
`452`	`451`	`return SEG_BUFFER_SIZE / getWordLength(AVERAGE_BYTES_LEN);`
`453`	`452`	`}`
`454`	`453`
`455`		`-unsigned Dictionary::Segment::getWordLength(FB_SIZE_T len)`
	`454`	`+constexpr unsigned Dictionary::Segment::getWordLength(FB_SIZE_T len) noexcept`
`456`	`455`	`{`
`457`	`456`	`// calculate length in sizeof(Word*)`
`458`	`457`	`len += 2;`
`459`		`- return 1 + (len / sizeof(Word)) + (len % sizeof(Word) ? 1 : 0);`
	`458`	`+ return 1 + (len / sizeof(Word)) + ((len % sizeof(Word)) ? 1 : 0);`
`460`	`459`	`}`
`461`	`460`
`462`		`-Dictionary::Word* Dictionary::Segment::getSpace(FB_SIZE_T len DIC_STAT_SEGMENT_PAR)`
	`461`	`+Dictionary::Word* Dictionary::Segment::getSpace(FB_SIZE_T len DIC_STAT_SEGMENT_PAR) noexcept`
`463`	`462`	`{`
`464`	`463`	`len = getWordLength(len);`
`465`	`464`
`@@ -470,7 +469,7 @@ Dictionary::Word* Dictionary::Segment::getSpace(FB_SIZE_T len DIC_STAT_SEGMENT_P`
`470`	`469`	`for(;;)`
`471`	`470`	`{`
`472`	`471`	`// calculate and check new position`
`473`		`- unsigned newPos = oldPos + len;`
	`472`	`+ const unsigned newPos = oldPos + len;`
`474`	`473`	`if (newPos >= SEG_BUFFER_SIZE)`
`475`	`474`	`break;`
`476`	`475`
Original file line number	Diff line number	Diff line change
`@@ -73,12 +73,12 @@ class Dictionary : public Firebird::PermanentStorage`
`73`	`73`	`char text[1];`
`74`	`74`
`75`	`75`	`public:`
`76`		`- const char* c_str() const`
	`76`	`+ const char* c_str() const noexcept`
`77`	`77`	`{`
`78`	`78`	`return text;`
`79`	`79`	`}`
`80`	`80`
`81`		`- FB_SIZE_T length() const`
	`81`	`+ FB_SIZE_T length() const noexcept`
`82`	`82`	`{`
`83`	`83`	`return textLen;`
`84`	`84`	`}`
`@@ -102,31 +102,31 @@ class Dictionary : public Firebird::PermanentStorage`
`102`	`102`	`public:`
`103`	`103`	`HashTable(MemoryPool& p, unsigned lvl);`
`104`	`104`	`Dictionary::TableData* getEntryByHash(const char* s, FB_SIZE_T len);`
`105`		`- static unsigned getMaxLevel();`
	`105`	`+ static unsigned getMaxLevel() noexcept;`
`106`	`106`
`107`	`107`	`const unsigned level;`
`108`	`108`	`TableData* table;`
`109`	`109`	`};`
`110`	`110`	`std::atomic<HashTable*> hashTable;`
`111`	`111`	`std::atomic<unsigned> nextLevel;`
`112`	`112`
`113`		`- bool checkConsistency(HashTable* oldValue);`
	`113`	`+ bool checkConsistency(const HashTable* oldValue) noexcept;`
`114`	`114`	`HashTable* waitForMutex(Word** checkWordPtr = nullptr);`
`115`	`115`
`116`	`116`	`class Segment`
`117`	`117`	`{`
`118`	`118`	`public:`
`119`		`- Segment();`
`120`		`- Word* getSpace(FB_SIZE_T l DIC_STAT_SEGMENT_PAR);`
`121`		`- static unsigned getWordCapacity();`
	`119`	`+ Segment() noexcept;`
	`120`	`+ Word* getSpace(FB_SIZE_T len DIC_STAT_SEGMENT_PAR) noexcept;`
	`121`	`+ static constexpr unsigned getWordCapacity() noexcept;`
`122`	`122`
`123`	`123`	`private:`
`124`		`- static unsigned getWordLength(FB_SIZE_T len);`
	`124`	`+ static constexpr unsigned getWordLength(FB_SIZE_T len) noexcept;`
`125`	`125`
`126`	`126`	`#if GROW_DEBUG > 1`
`127`		`- static const unsigned SEG_BUFFER_SIZE = 256; // size in sizeof(pointer)`
	`127`	`+ static constexpr unsigned SEG_BUFFER_SIZE = 256; // size in sizeof(pointer)`
`128`	`128`	`#else`
`129`		`- static const unsigned SEG_BUFFER_SIZE = 16384; // size in sizeof(pointer)`
	`129`	`+ static constexpr unsigned SEG_BUFFER_SIZE = 16384; // size in sizeof(pointer)`
`130`	`130`	`#endif`
`131`	`131`	`void* buffer[SEG_BUFFER_SIZE];`
`132`	`132`	`std::atomic<unsigned> position;`
`@@ -141,7 +141,7 @@ class MetaName`
`141`	`141`	`{`
`142`	`142`	`private:`
`143`	`143`	`Dictionary::Word* word;`
`144`		`- static const char* EMPTY;`
	`144`	`+ static constexpr const char* EMPTY = "";`
`145`	`145`
`146`	`146`	`void test();`
`147`	`147`	`Dictionary::Word* get(const char* s, FB_SIZE_T l);`
`@@ -152,7 +152,7 @@ class MetaName`
`152`	`152`	`}`
`153`	`153`
`154`	`154`	`public:`
`155`		`- MetaName()`
	`155`	`+ MetaName() noexcept`
`156`	`156`	`: word(nullptr)`
`157`	`157`	`{ }`
`158`	`158`
`@@ -177,7 +177,7 @@ class MetaName`
`177`	`177`	`{ }`
`178`	`178`
`179`	`179`
`180`		`- explicit MetaName(MemoryPool&)`
	`180`	`+ explicit MetaName(MemoryPool&) noexcept`
`181`	`181`	`: word(nullptr)`
`182`	`182`	`{ }`
`183`	`183`
`@@ -233,43 +233,43 @@ class MetaName`
`233`	`233`
`234`	`234`	`MetaName& operator=(const Firebird::MetaString& s);`
`235`	`235`
`236`		`- FB_SIZE_T length() const`
	`236`	`+ FB_SIZE_T length() const noexcept`
`237`	`237`	`{`
`238`	`238`	`return word ? word->length() : 0;`
`239`	`239`	`}`
`240`	`240`
`241`		`- const char* c_str() const`
	`241`	`+ const char* c_str() const noexcept`
`242`	`242`	`{`
`243`	`243`	`return word ? word->c_str() : EMPTY;`
`244`	`244`	`}`
`245`	`245`
`246`		`- const char* nullStr() const`
	`246`	`+ const char* nullStr() const noexcept`
`247`	`247`	`{`
`248`	`248`	`return word ? word->c_str() : nullptr;`
`249`	`249`	`}`
`250`	`250`
`251`		`- bool isEmpty() const`
	`251`	`+ bool isEmpty() const noexcept`
`252`	`252`	`{`
`253`	`253`	`return !word;`
`254`	`254`	`}`
`255`	`255`
`256`		`- bool hasData() const`
	`256`	`+ bool hasData() const noexcept`
`257`	`257`	`{`
`258`	`258`	`return word;`
`259`	`259`	`}`
`260`	`260`
`261`		`- char operator[](unsigned n) const`
	`261`	`+ char operator[](unsigned n) const noexcept`
`262`	`262`	`{`
`263`	`263`	`fb_assert(n < length());`
`264`	`264`	`return word->c_str()[n];`
`265`	`265`	`}`
`266`	`266`
`267`		`- const char* begin() const`
	`267`	`+ const char* begin() const noexcept`
`268`	`268`	`{`
`269`	`269`	`return word ? word->c_str() : EMPTY;`
`270`	`270`	`}`
`271`	`271`
`272`		`- const char* end() const`
	`272`	`+ const char* end() const noexcept`
`273`	`273`	`{`
`274`	`274`	`return word ? &word->c_str()[length()] : EMPTY;`
`275`	`275`	`}`
`@@ -354,22 +354,22 @@ class MetaName`
`354`	`354`	`return compare(m) > 0;`
`355`	`355`	`}`
`356`	`356`
`357`		`- bool operator==(const MetaName& m) const`
	`357`	`+ bool operator==(const MetaName& m) const noexcept`
`358`	`358`	`{`
`359`	`359`	`return word == m.word;`
`360`	`360`	`}`
`361`	`361`
`362`		`- bool operator!=(const MetaName& m) const`
	`362`	`+ bool operator!=(const MetaName& m) const noexcept`
`363`	`363`	`{`
`364`	`364`	`return word != m.word;`
`365`	`365`	`}`
`366`	`366`
`367`	`367`	`void printf(const char*, ...);`
`368`	`368`	`FB_SIZE_T copyTo(char* to, FB_SIZE_T toSize) const;`
`369`		`- operator Firebird::MetaString() const;`
	`369`	`+ operator Firebird::MetaString() const noexcept;`
`370`	`370`
`371`	`371`	`protected:`
`372`		`- static void adjustLength(const char* const s, FB_SIZE_T& l);`
	`372`	`+ static void adjustLength(const char* const s, FB_SIZE_T& l) noexcept;`
`373`	`373`	`};`
`374`	`374`
`375`	`375`	`typedef Firebird::Pair<Firebird::Full<MetaName, MetaName> > MetaNamePair;`