constexpr + noexcept File/TempFile/TempSpace

mrotteveel · mrotteveel · commit 302430156077 · 2025-07-29T14:46:11.000+02:00
diff --git a/src/common/classes/File.h b/src/common/classes/File.h
@@ -39,15 +39,15 @@ class File
 	virtual FB_SIZE_T read(offset_t, void*, FB_SIZE_T) = 0;
 	virtual FB_SIZE_T write(offset_t, const void*, FB_SIZE_T) = 0;
 
-	virtual void unlink() = 0;
+	virtual void unlink() noexcept = 0;
 
-	virtual offset_t getSize() const = 0;
+	virtual offset_t getSize() const noexcept = 0;
 };
 
 class ZeroBuffer
 {
-	static const FB_SIZE_T DEFAULT_SIZE = 1024 * 256;
-	static const FB_SIZE_T SYS_PAGE_SIZE = 1024 * 4;
+	static constexpr FB_SIZE_T DEFAULT_SIZE = 1024 * 256;
+	static constexpr FB_SIZE_T SYS_PAGE_SIZE = 1024 * 4;
 
 public:
 	explicit ZeroBuffer(MemoryPool& p, FB_SIZE_T size = DEFAULT_SIZE)
@@ -59,8 +59,8 @@ class ZeroBuffer
 		memset(bufAligned, 0, size);
 	}
 
-	const char* getBuffer() const { return bufAligned; }
-	FB_SIZE_T getSize() const { return bufSize; }
+	const char* getBuffer() const noexcept { return bufAligned; }
+	FB_SIZE_T getSize() const noexcept { return bufSize; }
 
 private:
 	Firebird::Array<char> buffer;
diff --git a/src/common/classes/TempFile.cpp b/src/common/classes/TempFile.cpp
@@ -56,8 +56,8 @@ namespace Firebird {
 
 // Const definitions
 
-static const char* ENV_VAR = "FIREBIRD_TMP";
-static const char* DEFAULT_PATH =
+static constexpr const char* ENV_VAR = "FIREBIRD_TMP";
+static constexpr const char* DEFAULT_PATH =
 #if defined(UNIX)
 	"/tmp/";
 #elif defined(ANDROID)
@@ -68,11 +68,11 @@ static const char* DEFAULT_PATH =
 	NULL;
 #endif
 
-static const char* const NAME_PATTERN = "XXXXXX";
+static constexpr const char* NAME_PATTERN = "XXXXXX";
 
 #ifdef WIN_NT
-static const char* const NAME_LETTERS = "abcdefghijklmnopqrstuvwxyz0123456789";
-static const FB_SIZE_T MAX_TRIES = 256;
+static constexpr const char* NAME_LETTERS = "abcdefghijklmnopqrstuvwxyz0123456789";
+static constexpr FB_SIZE_T MAX_TRIES = 256;
 #endif
 
 // we need a class here only to return memory on shutdown and avoid
@@ -388,7 +388,7 @@ FB_SIZE_T TempFile::write(offset_t offset, const void* buffer, FB_SIZE_T length)
 // Unlinks the file
 //
 
-void TempFile::unlink()
+void TempFile::unlink() noexcept
 {
 #if defined(WIN_NT)
 	doUnlink = true;
diff --git a/src/common/classes/TempFile.h b/src/common/classes/TempFile.h
@@ -48,19 +48,19 @@ class TempFile : public File
 
 	virtual ~TempFile();
 
-	FB_SIZE_T read(offset_t, void*, FB_SIZE_T);
-	FB_SIZE_T write(offset_t, const void*, FB_SIZE_T);
+	FB_SIZE_T read(offset_t, void*, FB_SIZE_T) override;
+	FB_SIZE_T write(offset_t, const void*, FB_SIZE_T) override;
 
-	void unlink();
+	void unlink() noexcept override;
 
-	offset_t getSize() const
+	offset_t getSize() const noexcept override
 	{
 		return size;
 	}
 
 	void extend(offset_t);
 
-	const PathName& getName() const
+	const PathName& getName() const noexcept
 	{
 		return filename;
 	}
diff --git a/src/jrd/TempSpace.cpp b/src/jrd/TempSpace.cpp
@@ -44,12 +44,12 @@ FB_SIZE_T TempSpace::minBlockSize = 0;
 
 namespace
 {
-	const size_t MIN_TEMP_BLOCK_SIZE = 64 * 1024;
+	constexpr size_t MIN_TEMP_BLOCK_SIZE = 64 * 1024;
 
 	class TempCacheLimitGuard
 	{
 	public:
-		explicit TempCacheLimitGuard(Database* dbb) :
+		explicit TempCacheLimitGuard(Database* dbb) noexcept :
 			m_dbb(dbb),
 			m_size(0)
 		{}
@@ -70,7 +70,7 @@ namespace
 			return false;
 		}
 
-		void commit()
+		void commit() noexcept
 		{
 			m_size = 0;
 		}
diff --git a/src/jrd/TempSpace.h b/src/jrd/TempSpace.h
@@ -37,12 +37,12 @@ class TempSpace : public Firebird::File
 	TempSpace(MemoryPool& pool, const Firebird::PathName& prefix, bool dynamic = true);
 	virtual ~TempSpace();
 
-	FB_SIZE_T read(offset_t offset, void* buffer, FB_SIZE_T length);
-	FB_SIZE_T write(offset_t offset, const void* buffer, FB_SIZE_T length);
+	FB_SIZE_T read(offset_t offset, void* buffer, FB_SIZE_T length) override;
+	FB_SIZE_T write(offset_t offset, const void* buffer, FB_SIZE_T length) override;
 
-	void unlink() {}
+	void unlink() noexcept override {}
 
-	offset_t getSize() const
+	offset_t getSize() const noexcept override
 	{
 		return logicalSize;
 	}
@@ -72,7 +72,7 @@ class TempSpace : public Firebird::File
 	class Block
 	{
 	public:
-		Block(Block* tail, size_t length)
+		Block(Block* tail, size_t length) noexcept
 			: next(NULL), size(length)
 		{
 			if (tail)
@@ -87,8 +87,8 @@ class TempSpace : public Firebird::File
 		virtual FB_SIZE_T read(offset_t offset, void* buffer, FB_SIZE_T length) = 0;
 		virtual FB_SIZE_T write(offset_t offset, const void* buffer, FB_SIZE_T length) = 0;
 
-		virtual UCHAR* inMemory(offset_t offset, size_t size) const = 0;
-		virtual bool sameFile(const Firebird::TempFile* file) const = 0;
+		virtual UCHAR* inMemory(offset_t offset, size_t size) const noexcept = 0;
+		virtual bool sameFile(const Firebird::TempFile* file) const noexcept = 0;
 
 		Block *prev;
 		Block *next;
@@ -98,7 +98,7 @@ class TempSpace : public Firebird::File
 	class MemoryBlock : public Block
 	{
 	public:
-		MemoryBlock(UCHAR* memory, Block* tail, size_t length)
+		MemoryBlock(UCHAR* memory, Block* tail, size_t length) noexcept
 			: Block(tail, length), ptr(memory)
 		{}
 
@@ -107,18 +107,18 @@ class TempSpace : public Firebird::File
 			delete[] ptr;
 		}
 
-		FB_SIZE_T read(offset_t offset, void* buffer, FB_SIZE_T length);
-		FB_SIZE_T write(offset_t offset, const void* buffer, FB_SIZE_T length);
+		FB_SIZE_T read(offset_t offset, void* buffer, FB_SIZE_T length) override;
+		FB_SIZE_T write(offset_t offset, const void* buffer, FB_SIZE_T length) override;
 
-		UCHAR* inMemory(offset_t offset, size_t _size) const
+		UCHAR* inMemory(offset_t offset, size_t _size) const noexcept override
 		{
 			if ((offset < this->size) && (offset + _size <= this->size))
 				return ptr + offset;
 
 			return NULL;
 		}
 
-		bool sameFile(const Firebird::TempFile*) const
+		bool sameFile(const Firebird::TempFile*) const noexcept override
 		{
 			return false;
 		}
@@ -130,7 +130,7 @@ class TempSpace : public Firebird::File
 	class InitialBlock : public MemoryBlock
 	{
 	public:
-		InitialBlock(UCHAR* memory, size_t length)
+		InitialBlock(UCHAR* memory, size_t length) noexcept
 			: MemoryBlock(memory, NULL, length)
 		{}
 
@@ -155,15 +155,15 @@ class TempSpace : public Firebird::File
 
 		~FileBlock() {}
 
-		FB_SIZE_T read(offset_t offset, void* buffer, FB_SIZE_T length);
-		FB_SIZE_T write(offset_t offset, const void* buffer, FB_SIZE_T length);
+		FB_SIZE_T read(offset_t offset, void* buffer, FB_SIZE_T length) override;
+		FB_SIZE_T write(offset_t offset, const void* buffer, FB_SIZE_T length) override;
 
-		UCHAR* inMemory(offset_t /*offset*/, size_t /*a_size*/) const
+		UCHAR* inMemory(offset_t /*offset*/, size_t /*a_size*/) const noexcept override
 		{
 			return NULL;
 		}
 
-		bool sameFile(const Firebird::TempFile* aFile) const
+		bool sameFile(const Firebird::TempFile* aFile) const noexcept override
 		{
 			return (aFile == this->file);
 		}
@@ -182,7 +182,7 @@ class TempSpace : public Firebird::File
 	class Segment
 	{
 	public:
-		Segment(offset_t aPosition, offset_t aSize) :
+		Segment(offset_t aPosition, offset_t aSize) noexcept :
 			position(aPosition), size(aSize), prev(nullptr), next(nullptr)
 		{}
 
@@ -191,7 +191,7 @@ class TempSpace : public Firebird::File
 		Segment* prev;
 		Segment* next;
 
-		static const offset_t& generate(const void* /*sender*/, const Segment* segment)
+		static const offset_t& generate(const void* /*sender*/, const Segment* segment) noexcept
 		{
 			return segment->position;
 		}
@@ -200,17 +200,17 @@ class TempSpace : public Firebird::File
 	class SegmentsStack
 	{
 	public:
-		SegmentsStack() : size(0), tail(nullptr)
+		SegmentsStack() noexcept : size(0), tail(nullptr)
 		{}
 
-		SegmentsStack(offset_t aSize, Segment* aSegment) :
+		SegmentsStack(offset_t aSize, Segment* aSegment) noexcept :
 			size(aSize), tail(aSegment)
 		{}
 
 		offset_t size;
 		Segment* tail;
 
-		static const offset_t& generate(const void* /*sender*/, const SegmentsStack& segment)
+		static const offset_t& generate(const void* /*sender*/, const SegmentsStack& segment) noexcept
 		{
 			return segment.size;
 		}

Original file line number	Diff line number	Diff line change
`@@ -48,19 +48,19 @@ class TempFile : public File`
`48`	`48`
`49`	`49`	`virtual ~TempFile();`
`50`	`50`
`51`		`- FB_SIZE_T read(offset_t, void*, FB_SIZE_T);`
`52`		`- FB_SIZE_T write(offset_t, const void*, FB_SIZE_T);`
	`51`	`+ FB_SIZE_T read(offset_t, void*, FB_SIZE_T) override;`
	`52`	`+ FB_SIZE_T write(offset_t, const void*, FB_SIZE_T) override;`
`53`	`53`
`54`		`- void unlink();`
	`54`	`+ void unlink() noexcept override;`
`55`	`55`
`56`		`- offset_t getSize() const`
	`56`	`+ offset_t getSize() const noexcept override`
`57`	`57`	`{`
`58`	`58`	`return size;`
`59`	`59`	`}`
`60`	`60`
`61`	`61`	`void extend(offset_t);`
`62`	`62`
`63`		`- const PathName& getName() const`
	`63`	`+ const PathName& getName() const noexcept`
`64`	`64`	`{`
`65`	`65`	`return filename;`
`66`	`66`	`}`
Original file line number	Diff line number	Diff line change
`@@ -44,12 +44,12 @@ FB_SIZE_T TempSpace::minBlockSize = 0;`
`44`	`44`
`45`	`45`	`namespace`
`46`	`46`	`{`
`47`		`- const size_t MIN_TEMP_BLOCK_SIZE = 64 * 1024;`
	`47`	`+ constexpr size_t MIN_TEMP_BLOCK_SIZE = 64 * 1024;`
`48`	`48`
`49`	`49`	`class TempCacheLimitGuard`
`50`	`50`	`{`
`51`	`51`	`public:`
`52`		`- explicit TempCacheLimitGuard(Database* dbb) :`
	`52`	`+ explicit TempCacheLimitGuard(Database* dbb) noexcept :`
`53`	`53`	`m_dbb(dbb),`
`54`	`54`	`m_size(0)`
`55`	`55`	`{}`
`@@ -70,7 +70,7 @@ namespace`
`70`	`70`	`return false;`
`71`	`71`	`}`
`72`	`72`
`73`		`- void commit()`
	`73`	`+ void commit() noexcept`
`74`	`74`	`{`
`75`	`75`	`m_size = 0;`
`76`	`76`	`}`
Original file line number	Diff line number	Diff line change
`@@ -37,12 +37,12 @@ class TempSpace : public Firebird::File`
`37`	`37`	`TempSpace(MemoryPool& pool, const Firebird::PathName& prefix, bool dynamic = true);`
`38`	`38`	`virtual ~TempSpace();`
`39`	`39`
`40`		`- FB_SIZE_T read(offset_t offset, void* buffer, FB_SIZE_T length);`
`41`		`- FB_SIZE_T write(offset_t offset, const void* buffer, FB_SIZE_T length);`
	`40`	`+ FB_SIZE_T read(offset_t offset, void* buffer, FB_SIZE_T length) override;`
	`41`	`+ FB_SIZE_T write(offset_t offset, const void* buffer, FB_SIZE_T length) override;`
`42`	`42`
`43`		`- void unlink() {}`
	`43`	`+ void unlink() noexcept override {}`
`44`	`44`
`45`		`- offset_t getSize() const`
	`45`	`+ offset_t getSize() const noexcept override`
`46`	`46`	`{`
`47`	`47`	`return logicalSize;`
`48`	`48`	`}`
`@@ -72,7 +72,7 @@ class TempSpace : public Firebird::File`
`72`	`72`	`class Block`
`73`	`73`	`{`
`74`	`74`	`public:`
`75`		`- Block(Block* tail, size_t length)`
	`75`	`+ Block(Block* tail, size_t length) noexcept`
`76`	`76`	`: next(NULL), size(length)`
`77`	`77`	`{`
`78`	`78`	`if (tail)`
`@@ -87,8 +87,8 @@ class TempSpace : public Firebird::File`
`87`	`87`	`virtual FB_SIZE_T read(offset_t offset, void* buffer, FB_SIZE_T length) = 0;`
`88`	`88`	`virtual FB_SIZE_T write(offset_t offset, const void* buffer, FB_SIZE_T length) = 0;`
`89`	`89`
`90`		`- virtual UCHAR* inMemory(offset_t offset, size_t size) const = 0;`
`91`		`- virtual bool sameFile(const Firebird::TempFile* file) const = 0;`
	`90`	`+ virtual UCHAR* inMemory(offset_t offset, size_t size) const noexcept = 0;`
	`91`	`+ virtual bool sameFile(const Firebird::TempFile* file) const noexcept = 0;`
`92`	`92`
`93`	`93`	`Block *prev;`
`94`	`94`	`Block *next;`
`@@ -98,7 +98,7 @@ class TempSpace : public Firebird::File`
`98`	`98`	`class MemoryBlock : public Block`
`99`	`99`	`{`
`100`	`100`	`public:`
`101`		`- MemoryBlock(UCHAR* memory, Block* tail, size_t length)`
	`101`	`+ MemoryBlock(UCHAR* memory, Block* tail, size_t length) noexcept`
`102`	`102`	`: Block(tail, length), ptr(memory)`
`103`	`103`	`{}`
`104`	`104`
`@@ -107,18 +107,18 @@ class TempSpace : public Firebird::File`
`107`	`107`	`delete[] ptr;`
`108`	`108`	`}`
`109`	`109`
`110`		`- FB_SIZE_T read(offset_t offset, void* buffer, FB_SIZE_T length);`
`111`		`- FB_SIZE_T write(offset_t offset, const void* buffer, FB_SIZE_T length);`
	`110`	`+ FB_SIZE_T read(offset_t offset, void* buffer, FB_SIZE_T length) override;`
	`111`	`+ FB_SIZE_T write(offset_t offset, const void* buffer, FB_SIZE_T length) override;`
`112`	`112`
`113`		`- UCHAR* inMemory(offset_t offset, size_t _size) const`
	`113`	`+ UCHAR* inMemory(offset_t offset, size_t _size) const noexcept override`
`114`	`114`	`{`
`115`	`115`	`if ((offset < this->size) && (offset + _size <= this->size))`
`116`	`116`	`return ptr + offset;`
`117`	`117`
`118`	`118`	`return NULL;`
`119`	`119`	`}`
`120`	`120`
`121`		`- bool sameFile(const Firebird::TempFile*) const`
	`121`	`+ bool sameFile(const Firebird::TempFile*) const noexcept override`
`122`	`122`	`{`
`123`	`123`	`return false;`
`124`	`124`	`}`
`@@ -130,7 +130,7 @@ class TempSpace : public Firebird::File`
`130`	`130`	`class InitialBlock : public MemoryBlock`
`131`	`131`	`{`
`132`	`132`	`public:`
`133`		`- InitialBlock(UCHAR* memory, size_t length)`
	`133`	`+ InitialBlock(UCHAR* memory, size_t length) noexcept`
`134`	`134`	`: MemoryBlock(memory, NULL, length)`
`135`	`135`	`{}`
`136`	`136`
`@@ -155,15 +155,15 @@ class TempSpace : public Firebird::File`
`155`	`155`
`156`	`156`	`~FileBlock() {}`
`157`	`157`
`158`		`- FB_SIZE_T read(offset_t offset, void* buffer, FB_SIZE_T length);`
`159`		`- FB_SIZE_T write(offset_t offset, const void* buffer, FB_SIZE_T length);`
	`158`	`+ FB_SIZE_T read(offset_t offset, void* buffer, FB_SIZE_T length) override;`
	`159`	`+ FB_SIZE_T write(offset_t offset, const void* buffer, FB_SIZE_T length) override;`
`160`	`160`
`161`		`- UCHAR* inMemory(offset_t /offset/, size_t /a_size/) const`
	`161`	`+ UCHAR* inMemory(offset_t /offset/, size_t /a_size/) const noexcept override`
`162`	`162`	`{`
`163`	`163`	`return NULL;`
`164`	`164`	`}`
`165`	`165`
`166`		`- bool sameFile(const Firebird::TempFile* aFile) const`
	`166`	`+ bool sameFile(const Firebird::TempFile* aFile) const noexcept override`
`167`	`167`	`{`
`168`	`168`	`return (aFile == this->file);`
`169`	`169`	`}`
`@@ -182,7 +182,7 @@ class TempSpace : public Firebird::File`
`182`	`182`	`class Segment`
`183`	`183`	`{`
`184`	`184`	`public:`
`185`		`- Segment(offset_t aPosition, offset_t aSize) :`
	`185`	`+ Segment(offset_t aPosition, offset_t aSize) noexcept :`
`186`	`186`	`position(aPosition), size(aSize), prev(nullptr), next(nullptr)`
`187`	`187`	`{}`
`188`	`188`
`@@ -191,7 +191,7 @@ class TempSpace : public Firebird::File`
`191`	`191`	`Segment* prev;`
`192`	`192`	`Segment* next;`
`193`	`193`
`194`		`- static const offset_t& generate(const void* /sender/, const Segment* segment)`
	`194`	`+ static const offset_t& generate(const void* /sender/, const Segment* segment) noexcept`
`195`	`195`	`{`
`196`	`196`	`return segment->position;`
`197`	`197`	`}`
`@@ -200,17 +200,17 @@ class TempSpace : public Firebird::File`
`200`	`200`	`class SegmentsStack`
`201`	`201`	`{`
`202`	`202`	`public:`
`203`		`- SegmentsStack() : size(0), tail(nullptr)`
	`203`	`+ SegmentsStack() noexcept : size(0), tail(nullptr)`
`204`	`204`	`{}`
`205`	`205`
`206`		`- SegmentsStack(offset_t aSize, Segment* aSegment) :`
	`206`	`+ SegmentsStack(offset_t aSize, Segment* aSegment) noexcept :`
`207`	`207`	`size(aSize), tail(aSegment)`
`208`	`208`	`{}`
`209`	`209`
`210`	`210`	`offset_t size;`
`211`	`211`	`Segment* tail;`
`212`	`212`
`213`		`- static const offset_t& generate(const void* /sender/, const SegmentsStack& segment)`
	`213`	`+ static const offset_t& generate(const void* /sender/, const SegmentsStack& segment) noexcept`
`214`	`214`	`{`
`215`	`215`	`return segment.size;`
`216`	`216`	`}`