constexpr + noexcept in NoThrowTimeStamp

mrotteveel · mrotteveel · commit 6bc762fe43ae · 2025-07-30T12:35:25.000+02:00
diff --git a/src/common/classes/NoThrowTimeStamp.cpp b/src/common/classes/NoThrowTimeStamp.cpp
@@ -299,7 +299,7 @@ ISC_TIMESTAMP NoThrowTimeStamp::encode_timestamp(const struct tm* times, const i
 	return ts;
 }
 
-void NoThrowTimeStamp::add10msec(ISC_TIMESTAMP* v, SINT64 msec, SINT64 multiplier)
+void NoThrowTimeStamp::add10msec(ISC_TIMESTAMP* v, SINT64 msec, SINT64 multiplier) noexcept
 {
 	const SINT64 full = msec * multiplier;
 	const int days = full / (SECONDS_PER_DAY * ISC_TIME_SECONDS_PRECISION);
@@ -321,7 +321,7 @@ void NoThrowTimeStamp::add10msec(ISC_TIMESTAMP* v, SINT64 msec, SINT64 multiplie
 	}
 }
 
-void NoThrowTimeStamp::round_time(ISC_TIME &ntime, const int precision)
+void NoThrowTimeStamp::round_time(ISC_TIME &ntime, const int precision) noexcept
 {
 	const int scale = -ISC_TIME_SECONDS_PRECISION_SCALE - precision;
 
@@ -337,7 +337,7 @@ void NoThrowTimeStamp::round_time(ISC_TIME &ntime, const int precision)
 	ntime -= (ntime % period);
 }
 
-int NoThrowTimeStamp::convertGregorianDateToWeekDate(const struct tm& times)
+int NoThrowTimeStamp::convertGregorianDateToWeekDate(const struct tm& times) noexcept
 {
 	// Algorithm for Converting Gregorian Dates to ISO 8601 Week Date by Rick McCarty, 1999
 	// http://personal.ecu.edu/mccartyr/ISOwdALG.txt
@@ -369,7 +369,7 @@ int NoThrowTimeStamp::convertGregorianDateToWeekDate(const struct tm& times)
 		yearNumber = y;
 
 		// Find if y m d falls in yearNumber y+1, weekNumber 1
-		int i = isLeapYear(y) ? 366 : 365;
+		const int i = isLeapYear(y) ? 366 : 365;
 
 		if ((i - dayOfYearNumber) < (4 - weekday))
 		{
@@ -381,7 +381,7 @@ int NoThrowTimeStamp::convertGregorianDateToWeekDate(const struct tm& times)
 	// Find if y m d falls in yearNumber y, weekNumber 1 through 53
 	if (yearNumber == y)
 	{
-		int j = dayOfYearNumber + (7 - weekday) + (jan1Weekday - 1);
+		const int j = dayOfYearNumber + (7 - weekday) + (jan1Weekday - 1);
 		weekNumber = j / 7;
 		if (jan1Weekday > 4)
 			weekNumber--;
@@ -390,35 +390,34 @@ int NoThrowTimeStamp::convertGregorianDateToWeekDate(const struct tm& times)
 	return weekNumber;
 }
 
-int NoThrowTimeStamp::convertGregorianDateToJulianDate(int year, int month, int day)
+int NoThrowTimeStamp::convertGregorianDateToJulianDate(int year, int month, int day) noexcept
 {
-	int jdn = (1461 * (year + 4800 + (month - 14)/12))/4 + (367 * (month - 2 - 12 * ((month - 14)/12)))
+	return (1461 * (year + 4800 + (month - 14)/12))/4 + (367 * (month - 2 - 12 * ((month - 14)/12)))
 		/ 12 - (3 * ((year + 4900 + (month - 14)/12)/100))/4 + day - 32075;
-	return jdn;
 }
 
-void NoThrowTimeStamp::convertJulianDateToGregorianDate(int jdn, int& outYear, int& outMonth, int& outDay)
+void NoThrowTimeStamp::convertJulianDateToGregorianDate(int jdn, int& outYear, int& outMonth, int& outDay) noexcept
 {
-	int a = jdn + 32044;
-	int b = (4 * a +3 ) / 146097;
-	int c = a - (146097 * b) / 4;
-	int d = (4 * c + 3) / 1461;
-	int e = c - (1461 * d) / 4;
-	int m = (5 * e + 2) / 153;
+	const int a = jdn + 32044;
+	const int b = (4 * a +3 ) / 146097;
+	const int c = a - (146097 * b) / 4;
+	const int d = (4 * c + 3) / 1461;
+	const int e = c - (1461 * d) / 4;
+	const int m = (5 * e + 2) / 153;
 
 	outDay = e - (153 * m + 2) / 5 + 1;
 	outMonth  = m + 3 - 12 * (m / 10);
 	outYear = 100 * b + d - 4800 + (m / 10);
 }
 
 // Encode timestamp from UNIX datetime structure
-void NoThrowTimeStamp::encode(const struct tm* times, int fractions)
+void NoThrowTimeStamp::encode(const struct tm* times, int fractions) noexcept
 {
 	mValue = encode_timestamp(times, fractions);
 }
 
 // Decode timestamp into UNIX datetime structure
-void NoThrowTimeStamp::decode(struct tm* times, int* fractions) const
+void NoThrowTimeStamp::decode(struct tm* times, int* fractions) const noexcept
 {
 	fb_assert(mValue.timestamp_date != BAD_DATE);
 	fb_assert(mValue.timestamp_time != BAD_TIME);
diff --git a/src/common/classes/NoThrowTimeStamp.h b/src/common/classes/NoThrowTimeStamp.h
@@ -57,19 +57,19 @@ namespace Firebird {
 class NoThrowTimeStamp
 {
 public:
-	static const ISC_DATE MIN_DATE = -678575;	// 01.01.0001
-	static const ISC_DATE MAX_DATE = 2973483;	// 31.12.9999
-	static const ISC_DATE UNIX_DATE = 40587;	// 01.01.1970
+	static constexpr ISC_DATE MIN_DATE = -678575;	// 01.01.0001
+	static constexpr ISC_DATE MAX_DATE = 2973483;	// 31.12.9999
+	static constexpr ISC_DATE UNIX_DATE = 40587;	// 01.01.1970
 
-	static const SINT64 SECONDS_PER_DAY = 24 * 60 * 60;
-	static const SINT64 ISC_TICKS_PER_DAY = SECONDS_PER_DAY * ISC_TIME_SECONDS_PRECISION;
+	static constexpr SINT64 SECONDS_PER_DAY = 24 * 60 * 60;
+	static constexpr SINT64 ISC_TICKS_PER_DAY = SECONDS_PER_DAY * ISC_TIME_SECONDS_PRECISION;
 
 	static const ISC_TIMESTAMP MIN_TIMESTAMP;
 	static const ISC_TIMESTAMP MAX_TIMESTAMP;
 
 private:
-	static const ISC_DATE BAD_DATE = MAX_SLONG;
-	static const ISC_TIME BAD_TIME = MAX_ULONG;
+	static constexpr ISC_DATE BAD_DATE = MAX_SLONG;
+	static constexpr ISC_TIME BAD_TIME = MAX_ULONG;
 
 public:
 	// Number of the first day of UNIX epoch in GDS counting
@@ -78,39 +78,39 @@ class NoThrowTimeStamp
 	static const ISC_TIME POW_10_TABLE[];
 
 	// Constructors
-	NoThrowTimeStamp()
+	NoThrowTimeStamp() noexcept
 	{
 		invalidate();
 	}
 
-	NoThrowTimeStamp(const ISC_TIMESTAMP& from)
+	NoThrowTimeStamp(const ISC_TIMESTAMP& from) noexcept
 		: mValue(from)
 	{}
 
-	NoThrowTimeStamp(ISC_DATE date, ISC_TIME time)
+	NoThrowTimeStamp(ISC_DATE date, ISC_TIME time) noexcept
 	{
 		mValue.timestamp_date = date;
 		mValue.timestamp_time = time;
 	}
 
-	explicit NoThrowTimeStamp(const struct tm& times, int fractions = 0)
+	explicit NoThrowTimeStamp(const struct tm& times, int fractions = 0) noexcept
 	{
 		encode(&times, fractions);
 	}
 
-	bool isValid() const
+	bool isValid() const noexcept
 	{
 		return isValidTimeStamp(mValue);
 	}
 
 	// Check if timestamp contains a non-existing value
-	bool isEmpty() const
+	bool isEmpty() const noexcept
 	{
 		return (mValue.timestamp_date == BAD_DATE && mValue.timestamp_time == BAD_TIME);
 	}
 
 	// Set value of timestamp to a non-existing value
-	void invalidate()
+	void invalidate() noexcept
 	{
 		mValue.timestamp_date = BAD_DATE;
 		mValue.timestamp_time = BAD_TIME;
@@ -126,32 +126,32 @@ class NoThrowTimeStamp
 	}
 
 	// Encode timestamp from UNIX datetime structure
-	void encode(const struct tm* times, int fractions = 0);
+	void encode(const struct tm* times, int fractions = 0) noexcept;
 
 	// Decode timestamp into UNIX datetime structure
-	void decode(struct tm* times, int* fractions = NULL) const;
+	void decode(struct tm* times, int* fractions = NULL) const noexcept;
 
 	// Write access to timestamp structure we wrap
-	ISC_TIMESTAMP& value() { return mValue; }
+	ISC_TIMESTAMP& value() noexcept { return mValue; }
 
 	// Read access to timestamp structure we wrap
-	const ISC_TIMESTAMP& value() const { return mValue; }
+	const ISC_TIMESTAMP& value() const noexcept { return mValue; }
 
 	// Return current timestamp value
 	static NoThrowTimeStamp getCurrentTimeStamp(const char** error) noexcept;
 
 	// Validation routines
-	static bool isValidDate(const ISC_DATE ndate)
+	static constexpr bool isValidDate(const ISC_DATE ndate) noexcept
 	{
 		return (ndate >= MIN_DATE && ndate <= MAX_DATE);
 	}
 
-	static bool isValidTime(const ISC_TIME ntime)
+	static constexpr bool isValidTime(const ISC_TIME ntime) noexcept
 	{
 		return (ntime < 24 * 3600 * ISC_TIME_SECONDS_PRECISION);
 	}
 
-	static bool isValidTimeStamp(const ISC_TIMESTAMP ts)
+	static constexpr bool isValidTimeStamp(const ISC_TIMESTAMP ts) noexcept
 	{
 		return (isValidDate(ts.timestamp_date) && isValidTime(ts.timestamp_time));
 	}
@@ -165,25 +165,24 @@ class NoThrowTimeStamp
 	static void decode_time(ISC_TIME ntime, int* hours, int* minutes, int* seconds, int* fractions = NULL) noexcept;
 	static void decode_timestamp(const ISC_TIMESTAMP ntimestamp, struct tm* times, int* fractions = NULL) noexcept;
 
-	static void add10msec(ISC_TIMESTAMP* v, SINT64 msec, SINT64 multiplier);
-	static void round_time(ISC_TIME& ntime, const int precision);
+	static void add10msec(ISC_TIMESTAMP* v, SINT64 msec, SINT64 multiplier) noexcept;
+	static void round_time(ISC_TIME& ntime, const int precision) noexcept;
 
-	static int convertGregorianDateToWeekDate(const struct tm& times);
-	static int convertGregorianDateToJulianDate(int year, int month, int day);
-	static void convertJulianDateToGregorianDate(int jdn, int& outYear, int& outMonth, int& outDay);
+	static int convertGregorianDateToWeekDate(const struct tm& times) noexcept;
+	static int convertGregorianDateToJulianDate(int year, int month, int day) noexcept;
+	static void convertJulianDateToGregorianDate(int jdn, int& outYear, int& outMonth, int& outDay) noexcept;
 
-	static inline bool isLeapYear(const int year) noexcept
+	static constexpr bool isLeapYear(const int year) noexcept
 	{
 		return (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0);
 	}
 
-	static SINT64 timeStampToTicks(ISC_TIMESTAMP ts)
+	static constexpr SINT64 timeStampToTicks(ISC_TIMESTAMP ts) noexcept
 	{
-		const SINT64 ticks = (ts.timestamp_date - MIN_DATE) * ISC_TICKS_PER_DAY + ts.timestamp_time;
-		return ticks;
+		return (static_cast<SINT64>(ts.timestamp_date) - MIN_DATE) * ISC_TICKS_PER_DAY + ts.timestamp_time;
 	}
 
-	static ISC_TIMESTAMP ticksToTimeStamp(SINT64 ticks)
+	static constexpr ISC_TIMESTAMP ticksToTimeStamp(SINT64 ticks) noexcept
 	{
 		ISC_TIMESTAMP ts;
 		ts.timestamp_date = (ticks / ISC_TICKS_PER_DAY) + MIN_DATE;

Original file line number	Diff line number	Diff line change
`@@ -299,7 +299,7 @@ ISC_TIMESTAMP NoThrowTimeStamp::encode_timestamp(const struct tm* times, const i`
`299`	`299`	`return ts;`
`300`	`300`	`}`
`301`	`301`
`302`		`-void NoThrowTimeStamp::add10msec(ISC_TIMESTAMP* v, SINT64 msec, SINT64 multiplier)`
	`302`	`+void NoThrowTimeStamp::add10msec(ISC_TIMESTAMP* v, SINT64 msec, SINT64 multiplier) noexcept`
`303`	`303`	`{`
`304`	`304`	`const SINT64 full = msec * multiplier;`
`305`	`305`	`const int days = full / (SECONDS_PER_DAY * ISC_TIME_SECONDS_PRECISION);`
`@@ -321,7 +321,7 @@ void NoThrowTimeStamp::add10msec(ISC_TIMESTAMP* v, SINT64 msec, SINT64 multiplie`
`321`	`321`	`}`
`322`	`322`	`}`
`323`	`323`
`324`		`-void NoThrowTimeStamp::round_time(ISC_TIME &ntime, const int precision)`
	`324`	`+void NoThrowTimeStamp::round_time(ISC_TIME &ntime, const int precision) noexcept`
`325`	`325`	`{`
`326`	`326`	`const int scale = -ISC_TIME_SECONDS_PRECISION_SCALE - precision;`
`327`	`327`
`@@ -337,7 +337,7 @@ void NoThrowTimeStamp::round_time(ISC_TIME &ntime, const int precision)`
`337`	`337`	`ntime -= (ntime % period);`
`338`	`338`	`}`
`339`	`339`
`340`		`-int NoThrowTimeStamp::convertGregorianDateToWeekDate(const struct tm& times)`
	`340`	`+int NoThrowTimeStamp::convertGregorianDateToWeekDate(const struct tm& times) noexcept`
`341`	`341`	`{`
`342`	`342`	`// Algorithm for Converting Gregorian Dates to ISO 8601 Week Date by Rick McCarty, 1999`
`343`	`343`	`// http://personal.ecu.edu/mccartyr/ISOwdALG.txt`
`@@ -369,7 +369,7 @@ int NoThrowTimeStamp::convertGregorianDateToWeekDate(const struct tm& times)`
`369`	`369`	`yearNumber = y;`
`370`	`370`
`371`	`371`	`// Find if y m d falls in yearNumber y+1, weekNumber 1`
`372`		`- int i = isLeapYear(y) ? 366 : 365;`
	`372`	`+ const int i = isLeapYear(y) ? 366 : 365;`
`373`	`373`
`374`	`374`	`if ((i - dayOfYearNumber) < (4 - weekday))`
`375`	`375`	`{`
`@@ -381,7 +381,7 @@ int NoThrowTimeStamp::convertGregorianDateToWeekDate(const struct tm& times)`
`381`	`381`	`// Find if y m d falls in yearNumber y, weekNumber 1 through 53`
`382`	`382`	`if (yearNumber == y)`
`383`	`383`	`{`
`384`		`- int j = dayOfYearNumber + (7 - weekday) + (jan1Weekday - 1);`
	`384`	`+ const int j = dayOfYearNumber + (7 - weekday) + (jan1Weekday - 1);`
`385`	`385`	`weekNumber = j / 7;`
`386`	`386`	`if (jan1Weekday > 4)`
`387`	`387`	`weekNumber--;`
`@@ -390,35 +390,34 @@ int NoThrowTimeStamp::convertGregorianDateToWeekDate(const struct tm& times)`
`390`	`390`	`return weekNumber;`
`391`	`391`	`}`
`392`	`392`
`393`		`-int NoThrowTimeStamp::convertGregorianDateToJulianDate(int year, int month, int day)`
	`393`	`+int NoThrowTimeStamp::convertGregorianDateToJulianDate(int year, int month, int day) noexcept`
`394`	`394`	`{`
`395`		`- int jdn = (1461 * (year + 4800 + (month - 14)/12))/4 + (367 * (month - 2 - 12 * ((month - 14)/12)))`
	`395`	`+ return (1461 * (year + 4800 + (month - 14)/12))/4 + (367 * (month - 2 - 12 * ((month - 14)/12)))`
`396`	`396`	`/ 12 - (3 * ((year + 4900 + (month - 14)/12)/100))/4 + day - 32075;`
`397`		`- return jdn;`
`398`	`397`	`}`
`399`	`398`
`400`		`-void NoThrowTimeStamp::convertJulianDateToGregorianDate(int jdn, int& outYear, int& outMonth, int& outDay)`
	`399`	`+void NoThrowTimeStamp::convertJulianDateToGregorianDate(int jdn, int& outYear, int& outMonth, int& outDay) noexcept`
`401`	`400`	`{`
`402`		`- int a = jdn + 32044;`
`403`		`- int b = (4 * a +3 ) / 146097;`
`404`		`- int c = a - (146097 * b) / 4;`
`405`		`- int d = (4 * c + 3) / 1461;`
`406`		`- int e = c - (1461 * d) / 4;`
`407`		`- int m = (5 * e + 2) / 153;`
	`401`	`+ const int a = jdn + 32044;`
	`402`	`+ const int b = (4 * a +3 ) / 146097;`
	`403`	`+ const int c = a - (146097 * b) / 4;`
	`404`	`+ const int d = (4 * c + 3) / 1461;`
	`405`	`+ const int e = c - (1461 * d) / 4;`
	`406`	`+ const int m = (5 * e + 2) / 153;`
`408`	`407`
`409`	`408`	`outDay = e - (153 * m + 2) / 5 + 1;`
`410`	`409`	`outMonth = m + 3 - 12 * (m / 10);`
`411`	`410`	`outYear = 100 * b + d - 4800 + (m / 10);`
`412`	`411`	`}`
`413`	`412`
`414`	`413`	`// Encode timestamp from UNIX datetime structure`
`415`		`-void NoThrowTimeStamp::encode(const struct tm* times, int fractions)`
	`414`	`+void NoThrowTimeStamp::encode(const struct tm* times, int fractions) noexcept`
`416`	`415`	`{`
`417`	`416`	`mValue = encode_timestamp(times, fractions);`
`418`	`417`	`}`
`419`	`418`
`420`	`419`	`// Decode timestamp into UNIX datetime structure`
`421`		`-void NoThrowTimeStamp::decode(struct tm* times, int* fractions) const`
	`420`	`+void NoThrowTimeStamp::decode(struct tm* times, int* fractions) const noexcept`
`422`	`421`	`{`
`423`	`422`	`fb_assert(mValue.timestamp_date != BAD_DATE);`
`424`	`423`	`fb_assert(mValue.timestamp_time != BAD_TIME);`
Original file line number	Diff line number	Diff line change
`@@ -57,19 +57,19 @@ namespace Firebird {`
`57`	`57`	`class NoThrowTimeStamp`
`58`	`58`	`{`
`59`	`59`	`public:`
`60`		`- static const ISC_DATE MIN_DATE = -678575; // 01.01.0001`
`61`		`- static const ISC_DATE MAX_DATE = 2973483; // 31.12.9999`
`62`		`- static const ISC_DATE UNIX_DATE = 40587; // 01.01.1970`
	`60`	`+ static constexpr ISC_DATE MIN_DATE = -678575; // 01.01.0001`
	`61`	`+ static constexpr ISC_DATE MAX_DATE = 2973483; // 31.12.9999`
	`62`	`+ static constexpr ISC_DATE UNIX_DATE = 40587; // 01.01.1970`
`63`	`63`
`64`		`- static const SINT64 SECONDS_PER_DAY = 24 * 60 * 60;`
`65`		`- static const SINT64 ISC_TICKS_PER_DAY = SECONDS_PER_DAY * ISC_TIME_SECONDS_PRECISION;`
	`64`	`+ static constexpr SINT64 SECONDS_PER_DAY = 24 * 60 * 60;`
	`65`	`+ static constexpr SINT64 ISC_TICKS_PER_DAY = SECONDS_PER_DAY * ISC_TIME_SECONDS_PRECISION;`
`66`	`66`
`67`	`67`	`static const ISC_TIMESTAMP MIN_TIMESTAMP;`
`68`	`68`	`static const ISC_TIMESTAMP MAX_TIMESTAMP;`
`69`	`69`
`70`	`70`	`private:`
`71`		`- static const ISC_DATE BAD_DATE = MAX_SLONG;`
`72`		`- static const ISC_TIME BAD_TIME = MAX_ULONG;`
	`71`	`+ static constexpr ISC_DATE BAD_DATE = MAX_SLONG;`
	`72`	`+ static constexpr ISC_TIME BAD_TIME = MAX_ULONG;`
`73`	`73`
`74`	`74`	`public:`
`75`	`75`	`// Number of the first day of UNIX epoch in GDS counting`
`@@ -78,39 +78,39 @@ class NoThrowTimeStamp`
`78`	`78`	`static const ISC_TIME POW_10_TABLE[];`
`79`	`79`
`80`	`80`	`// Constructors`
`81`		`- NoThrowTimeStamp()`
	`81`	`+ NoThrowTimeStamp() noexcept`
`82`	`82`	`{`
`83`	`83`	`invalidate();`
`84`	`84`	`}`
`85`	`85`
`86`		`- NoThrowTimeStamp(const ISC_TIMESTAMP& from)`
	`86`	`+ NoThrowTimeStamp(const ISC_TIMESTAMP& from) noexcept`
`87`	`87`	`: mValue(from)`
`88`	`88`	`{}`
`89`	`89`
`90`		`- NoThrowTimeStamp(ISC_DATE date, ISC_TIME time)`
	`90`	`+ NoThrowTimeStamp(ISC_DATE date, ISC_TIME time) noexcept`
`91`	`91`	`{`
`92`	`92`	`mValue.timestamp_date = date;`
`93`	`93`	`mValue.timestamp_time = time;`
`94`	`94`	`}`
`95`	`95`
`96`		`- explicit NoThrowTimeStamp(const struct tm& times, int fractions = 0)`
	`96`	`+ explicit NoThrowTimeStamp(const struct tm& times, int fractions = 0) noexcept`
`97`	`97`	`{`
`98`	`98`	`encode(&times, fractions);`
`99`	`99`	`}`
`100`	`100`
`101`		`- bool isValid() const`
	`101`	`+ bool isValid() const noexcept`
`102`	`102`	`{`
`103`	`103`	`return isValidTimeStamp(mValue);`
`104`	`104`	`}`
`105`	`105`
`106`	`106`	`// Check if timestamp contains a non-existing value`
`107`		`- bool isEmpty() const`
	`107`	`+ bool isEmpty() const noexcept`
`108`	`108`	`{`
`109`	`109`	`return (mValue.timestamp_date == BAD_DATE && mValue.timestamp_time == BAD_TIME);`
`110`	`110`	`}`
`111`	`111`
`112`	`112`	`// Set value of timestamp to a non-existing value`
`113`		`- void invalidate()`
	`113`	`+ void invalidate() noexcept`
`114`	`114`	`{`
`115`	`115`	`mValue.timestamp_date = BAD_DATE;`
`116`	`116`	`mValue.timestamp_time = BAD_TIME;`
`@@ -126,32 +126,32 @@ class NoThrowTimeStamp`
`126`	`126`	`}`
`127`	`127`
`128`	`128`	`// Encode timestamp from UNIX datetime structure`
`129`		`- void encode(const struct tm* times, int fractions = 0);`
	`129`	`+ void encode(const struct tm* times, int fractions = 0) noexcept;`
`130`	`130`
`131`	`131`	`// Decode timestamp into UNIX datetime structure`
`132`		`- void decode(struct tm* times, int* fractions = NULL) const;`
	`132`	`+ void decode(struct tm* times, int* fractions = NULL) const noexcept;`
`133`	`133`
`134`	`134`	`// Write access to timestamp structure we wrap`
`135`		`- ISC_TIMESTAMP& value() { return mValue; }`
	`135`	`+ ISC_TIMESTAMP& value() noexcept { return mValue; }`
`136`	`136`
`137`	`137`	`// Read access to timestamp structure we wrap`
`138`		`- const ISC_TIMESTAMP& value() const { return mValue; }`
	`138`	`+ const ISC_TIMESTAMP& value() const noexcept { return mValue; }`
`139`	`139`
`140`	`140`	`// Return current timestamp value`
`141`	`141`	`static NoThrowTimeStamp getCurrentTimeStamp(const char** error) noexcept;`
`142`	`142`
`143`	`143`	`// Validation routines`
`144`		`- static bool isValidDate(const ISC_DATE ndate)`
	`144`	`+ static constexpr bool isValidDate(const ISC_DATE ndate) noexcept`
`145`	`145`	`{`
`146`	`146`	`return (ndate >= MIN_DATE && ndate <= MAX_DATE);`
`147`	`147`	`}`
`148`	`148`
`149`		`- static bool isValidTime(const ISC_TIME ntime)`
	`149`	`+ static constexpr bool isValidTime(const ISC_TIME ntime) noexcept`
`150`	`150`	`{`
`151`	`151`	`return (ntime < 24 * 3600 * ISC_TIME_SECONDS_PRECISION);`
`152`	`152`	`}`
`153`	`153`
`154`		`- static bool isValidTimeStamp(const ISC_TIMESTAMP ts)`
	`154`	`+ static constexpr bool isValidTimeStamp(const ISC_TIMESTAMP ts) noexcept`
`155`	`155`	`{`
`156`	`156`	`return (isValidDate(ts.timestamp_date) && isValidTime(ts.timestamp_time));`
`157`	`157`	`}`
`@@ -165,25 +165,24 @@ class NoThrowTimeStamp`
`165`	`165`	`static void decode_time(ISC_TIME ntime, int* hours, int* minutes, int* seconds, int* fractions = NULL) noexcept;`
`166`	`166`	`static void decode_timestamp(const ISC_TIMESTAMP ntimestamp, struct tm* times, int* fractions = NULL) noexcept;`
`167`	`167`
`168`		`- static void add10msec(ISC_TIMESTAMP* v, SINT64 msec, SINT64 multiplier);`
`169`		`- static void round_time(ISC_TIME& ntime, const int precision);`
	`168`	`+ static void add10msec(ISC_TIMESTAMP* v, SINT64 msec, SINT64 multiplier) noexcept;`
	`169`	`+ static void round_time(ISC_TIME& ntime, const int precision) noexcept;`
`170`	`170`
`171`		`- static int convertGregorianDateToWeekDate(const struct tm& times);`
`172`		`- static int convertGregorianDateToJulianDate(int year, int month, int day);`
`173`		`- static void convertJulianDateToGregorianDate(int jdn, int& outYear, int& outMonth, int& outDay);`
	`171`	`+ static int convertGregorianDateToWeekDate(const struct tm& times) noexcept;`
	`172`	`+ static int convertGregorianDateToJulianDate(int year, int month, int day) noexcept;`
	`173`	`+ static void convertJulianDateToGregorianDate(int jdn, int& outYear, int& outMonth, int& outDay) noexcept;`
`174`	`174`
`175`		`- static inline bool isLeapYear(const int year) noexcept`
	`175`	`+ static constexpr bool isLeapYear(const int year) noexcept`
`176`	`176`	`{`
`177`	`177`	`return (year % 4 == 0 && year % 100 != 0) \|\| (year % 400 == 0);`
`178`	`178`	`}`
`179`	`179`
`180`		`- static SINT64 timeStampToTicks(ISC_TIMESTAMP ts)`
	`180`	`+ static constexpr SINT64 timeStampToTicks(ISC_TIMESTAMP ts) noexcept`
`181`	`181`	`{`
`182`		`- const SINT64 ticks = (ts.timestamp_date - MIN_DATE) * ISC_TICKS_PER_DAY + ts.timestamp_time;`
`183`		`- return ticks;`
	`182`	`+ return (static_cast<SINT64>(ts.timestamp_date) - MIN_DATE) * ISC_TICKS_PER_DAY + ts.timestamp_time;`
`184`	`183`	`}`
`185`	`184`
`186`		`- static ISC_TIMESTAMP ticksToTimeStamp(SINT64 ticks)`
	`185`	`+ static constexpr ISC_TIMESTAMP ticksToTimeStamp(SINT64 ticks) noexcept`
`187`	`186`	`{`
`188`	`187`	`ISC_TIMESTAMP ts;`
`189`	`188`	`ts.timestamp_date = (ticks / ISC_TICKS_PER_DAY) + MIN_DATE;`