diff options
53 files changed, 253 insertions, 199 deletions
diff --git a/src/mongo/base/data_type.h b/src/mongo/base/data_type.h index d25929e3601..caec3a1e6bf 100644 --- a/src/mongo/base/data_type.h +++ b/src/mongo/base/data_type.h @@ -33,6 +33,7 @@ #include <type_traits> #include "mongo/base/error_codes.h" +#include "mongo/base/static_assert.h" #include "mongo/base/status.h" #include "mongo/base/status_with.h" @@ -57,10 +58,10 @@ struct DataType { struct Handler { static void unsafeLoad(T* t, const char* ptr, size_t* advanced) { #if MONGO_HAVE_STD_IS_TRIVIALLY_COPYABLE - static_assert(std::is_trivially_copyable<T>::value, - "The generic DataType implementation requires values " - "to be trivially copyable. You may specialize the " - "template to use it with other types."); + MONGO_STATIC_ASSERT_MSG(std::is_trivially_copyable<T>::value, + "The generic DataType implementation requires values to be " + "trivially copyable. You may specialize the template to use it " + "with other types."); #endif if (t) { @@ -85,10 +86,10 @@ struct DataType { static void unsafeStore(const T& t, char* ptr, size_t* advanced) { #if MONGO_HAVE_STD_IS_TRIVIALLY_COPYABLE - static_assert(std::is_trivially_copyable<T>::value, - "The generic DataType implementation requires values " - "to be trivially copyable. You may specialize the " - "template to use it with other types."); + MONGO_STATIC_ASSERT_MSG(std::is_trivially_copyable<T>::value, + "The generic DataType implementation requires values to be " + "trivially copyable. You may specialize the template to use it " + "with other types."); #endif if (ptr) { diff --git a/src/mongo/base/encoded_value_storage_test.cpp b/src/mongo/base/encoded_value_storage_test.cpp index 465f416fda2..a0cd3f30de8 100644 --- a/src/mongo/base/encoded_value_storage_test.cpp +++ b/src/mongo/base/encoded_value_storage_test.cpp @@ -31,6 +31,7 @@ #include <cstring> #include "mongo/base/data_type_endian.h" +#include "mongo/base/static_assert.h" #include "mongo/platform/endian.h" #include "mongo/unittest/unittest.h" @@ -110,7 +111,7 @@ private: class Value : public EncodedValueStorage<Layout, ConstView, View> { public: Value() { - static_assert(sizeof(Value) == sizeof(Layout), "sizeof(Value) == sizeof(Layout)"); + MONGO_STATIC_ASSERT(sizeof(Value) == sizeof(Layout)); } Value(ZeroInitTag_t zit) : EncodedValueStorage<Layout, ConstView, View>(zit) {} diff --git a/src/mongo/base/secure_allocator.h b/src/mongo/base/secure_allocator.h index 416ff12ebfa..b22ccf771a5 100644 --- a/src/mongo/base/secure_allocator.h +++ b/src/mongo/base/secure_allocator.h @@ -36,6 +36,7 @@ #include <type_traits> #include <vector> +#include "mongo/base/static_assert.h" #include "mongo/stdx/type_traits.h" #include "mongo/util/assert_util.h" @@ -83,8 +84,8 @@ struct SecureAllocator { * */ #ifdef MONGO_CONFIG_HAVE_STD_IS_TRIVIALLY_COPYABLE - static_assert(std::is_trivially_copyable<T>::value, - "SecureAllocator can only be used with trivially copyable types"); + MONGO_STATIC_ASSERT_MSG(std::is_trivially_copyable<T>::value, + "SecureAllocator can only be used with trivially copyable types"); #endif // NOTE: The standard doesn't seem to require these, but libstdc++ diff --git a/src/mongo/base/static_assert.h b/src/mongo/base/static_assert.h new file mode 100644 index 00000000000..de8040264f6 --- /dev/null +++ b/src/mongo/base/static_assert.h @@ -0,0 +1,32 @@ +/* Copyright 2016 MongoDB Inc. + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Affero General Public License, version 3, + * as published by the Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + * + * As a special exception, the copyright holders give permission to link the + * code of portions of this program with the OpenSSL library under certain + * conditions as described in each individual source file and distribute + * linked combinations including the program with the OpenSSL library. You + * must comply with the GNU Affero General Public License in all respects + * for all of the code used other than as permitted herein. If you modify + * file(s) with this exception, you may extend this exception to your + * version of the file(s), but you are not obligated to do so. If you do not + * wish to do so, delete this exception statement from your version. If you + * delete this exception statement from all source files in the program, + * then also delete it in the license file. + */ + +#pragma once + +#define MONGO_STATIC_ASSERT(...) static_assert(__VA_ARGS__, #__VA_ARGS__) + +#define MONGO_STATIC_ASSERT_MSG(...) static_assert(__VA_ARGS__) diff --git a/src/mongo/base/status_with.h b/src/mongo/base/status_with.h index 66880385ab4..29323861199 100644 --- a/src/mongo/base/status_with.h +++ b/src/mongo/base/status_with.h @@ -34,6 +34,7 @@ #include <type_traits> #include <utility> +#include "mongo/base/static_assert.h" #include "mongo/base/status.h" #define MONGO_INCLUDE_INVARIANT_H_WHITELISTED @@ -61,7 +62,8 @@ namespace mongo { */ template <typename T> class StatusWith { - static_assert(!(std::is_same<T, mongo::Status>::value), "StatusWith<Status> is banned."); + MONGO_STATIC_ASSERT_MSG(!(std::is_same<T, mongo::Status>::value), + "StatusWith<Status> is banned."); public: /** diff --git a/src/mongo/bson/mutable/document.cpp b/src/mongo/bson/mutable/document.cpp index ddf1f83281d..93ca13cc751 100644 --- a/src/mongo/bson/mutable/document.cpp +++ b/src/mongo/bson/mutable/document.cpp @@ -32,8 +32,10 @@ #include <cstdlib> #include <cstring> #include <limits> +#include <type_traits> #include <vector> +#include "mongo/base/static_assert.h" #include "mongo/bson/inline_decls.h" #include "mongo/bson/mutable/damage_vector.h" #include "mongo/util/debug_util.h" @@ -466,12 +468,12 @@ struct ElementRep { }; #pragma pack(pop) -static_assert(sizeof(ElementRep) == 32, "sizeof(ElementRep) == 32"); +MONGO_STATIC_ASSERT(sizeof(ElementRep) == 32); // We want ElementRep to be a POD so Document::Impl can grow the std::vector with // memmove. // -// TODO: C++11 static_assert(std::is_pod<ElementRep>::value); +MONGO_STATIC_ASSERT(std::is_pod<ElementRep>::value); // The ElementRep for the root element is always zero. const Element::RepIdx kRootRepIdx = Element::RepIdx(0); diff --git a/src/mongo/bson/oid.h b/src/mongo/bson/oid.h index 7debe105409..0dbf28a3277 100644 --- a/src/mongo/bson/oid.h +++ b/src/mongo/bson/oid.h @@ -32,6 +32,7 @@ #include <string> #include "mongo/base/data_view.h" +#include "mongo/base/static_assert.h" #include "mongo/bson/util/builder.h" #include "mongo/util/time_support.h" @@ -113,8 +114,8 @@ public: return o; } - static_assert(sizeof(int64_t) == kInstanceUniqueSize + kIncrementSize, - "size of term must be size of instance unique + increment"); + MONGO_STATIC_ASSERT_MSG(sizeof(int64_t) == kInstanceUniqueSize + kIncrementSize, + "size of term must be size of instance unique + increment"); // Return OID initialized with a 8 byte term id and max Timestamp. Used for ElectionID. static OID fromTerm(int64_t term) { diff --git a/src/mongo/bson/util/builder.h b/src/mongo/bson/util/builder.h index 258e63cf52d..1eb6f2378df 100644 --- a/src/mongo/bson/util/builder.h +++ b/src/mongo/bson/util/builder.h @@ -40,6 +40,7 @@ #include "mongo/base/data_type_endian.h" #include "mongo/base/data_view.h" #include "mongo/base/disallow_copying.h" +#include "mongo/base/static_assert.h" #include "mongo/base/string_data.h" #include "mongo/bson/bsontypes.h" #include "mongo/bson/inline_decls.h" @@ -194,7 +195,7 @@ public: } void appendUChar(unsigned char j) { - static_assert(CHAR_BIT == 8, "CHAR_BIT == 8"); + MONGO_STATIC_ASSERT(CHAR_BIT == 8); appendNumImpl(j); } void appendChar(char j) { @@ -204,11 +205,11 @@ public: appendNumImpl(j); } void appendNum(short j) { - static_assert(sizeof(short) == 2, "sizeof(short) == 2"); + MONGO_STATIC_ASSERT(sizeof(short) == 2); appendNumImpl(j); } void appendNum(int j) { - static_assert(sizeof(int) == 4, "sizeof(int) == 4"); + MONGO_STATIC_ASSERT(sizeof(int) == 4); appendNumImpl(j); } void appendNum(unsigned j) { @@ -219,11 +220,11 @@ public: void appendNum(bool j) = delete; void appendNum(double j) { - static_assert(sizeof(double) == 8, "sizeof(double) == 8"); + MONGO_STATIC_ASSERT(sizeof(double) == 8); appendNumImpl(j); } void appendNum(long long j) { - static_assert(sizeof(long long) == 8, "sizeof(long long) == 8"); + MONGO_STATIC_ASSERT(sizeof(long long) == 8); appendNumImpl(j); } diff --git a/src/mongo/db/concurrency/fast_map_noalloc.h b/src/mongo/db/concurrency/fast_map_noalloc.h index eef9f4ceebe..8d862d7ac89 100644 --- a/src/mongo/db/concurrency/fast_map_noalloc.h +++ b/src/mongo/db/concurrency/fast_map_noalloc.h @@ -28,6 +28,7 @@ #pragma once +#include "mongo/base/static_assert.h" #include "mongo/platform/unordered_map.h" #include "mongo/util/assert_util.h" @@ -233,8 +234,8 @@ public: private: // Empty and very large maps do not make sense since there will be no performance gain, so // disallow them. - static_assert(PreallocCount > 0, "PreallocCount > 0"); - static_assert(PreallocCount < 32, "PreallocCount < 32"); + MONGO_STATIC_ASSERT(PreallocCount > 0); + MONGO_STATIC_ASSERT(PreallocCount < 32); // Iterator accesses the map directly friend class IteratorImpl<FastMapNoAlloc<KeyType, ValueType, PreallocCount>, ValueType>; diff --git a/src/mongo/db/concurrency/lock_manager.cpp b/src/mongo/db/concurrency/lock_manager.cpp index 6653f5d0288..eb4c4567ce1 100644 --- a/src/mongo/db/concurrency/lock_manager.cpp +++ b/src/mongo/db/concurrency/lock_manager.cpp @@ -33,6 +33,7 @@ #include "mongo/db/concurrency/lock_manager.h" #include "mongo/base/simple_string_data_comparator.h" +#include "mongo/base/static_assert.h" #include "mongo/bson/bsonobjbuilder.h" #include "mongo/config.h" #include "mongo/db/concurrency/locker.h" @@ -72,8 +73,7 @@ static const int LockConflictsTable[] = { const uint64_t intentModes = (1 << MODE_IS) | (1 << MODE_IX); // Ensure we do not add new modes without updating the conflicts table -static_assert((sizeof(LockConflictsTable) / sizeof(LockConflictsTable[0])) == LockModesCount, - "(sizeof(LockConflictsTable) / sizeof(LockConflictsTable[0])) == LockModesCount"); +MONGO_STATIC_ASSERT((sizeof(LockConflictsTable) / sizeof(LockConflictsTable[0])) == LockModesCount); /** @@ -84,10 +84,9 @@ static const char* LockModeNames[] = {"NONE", "IS", "IX", "S", "X"}; static const char* LegacyLockModeNames[] = {"", "r", "w", "R", "W"}; // Ensure we do not add new modes without updating the names array -static_assert((sizeof(LockModeNames) / sizeof(LockModeNames[0])) == LockModesCount, - "(sizeof(LockModeNames) / sizeof(LockModeNames[0])) == LockModesCount"); -static_assert((sizeof(LegacyLockModeNames) / sizeof(LegacyLockModeNames[0])) == LockModesCount, - "(sizeof(LegacyLockModeNames) / sizeof(LegacyLockModeNames[0])) == LockModesCount"); +MONGO_STATIC_ASSERT((sizeof(LockModeNames) / sizeof(LockModeNames[0])) == LockModesCount); +MONGO_STATIC_ASSERT((sizeof(LegacyLockModeNames) / sizeof(LegacyLockModeNames[0])) == + LockModesCount); // Helper functions for the lock modes bool conflicts(LockMode newMode, uint32_t existingModesMask) { @@ -106,8 +105,8 @@ static const char* ResourceTypeNames[] = { "Invalid", "Global", "MMAPV1Journal", "Database", "Collection", "Metadata", "Mutex"}; // Ensure we do not add new types without updating the names array -static_assert((sizeof(ResourceTypeNames) / sizeof(ResourceTypeNames[0])) == ResourceTypesCount, - "(sizeof(ResourceTypeNames) / sizeof(ResourceTypeNames[0])) == ResourceTypesCount"); +MONGO_STATIC_ASSERT((sizeof(ResourceTypeNames) / sizeof(ResourceTypeNames[0])) == + ResourceTypesCount); /** @@ -118,10 +117,8 @@ static const char* LockRequestStatusNames[] = { }; // Ensure we do not add new status types without updating the names array -static_assert((sizeof(LockRequestStatusNames) / sizeof(LockRequestStatusNames[0])) == - LockRequest::StatusCount, - "(sizeof(LockRequestStatusNames) / sizeof(LockRequestStatusNames[0])) == " - "LockRequest::StatusCount"); +MONGO_STATIC_ASSERT((sizeof(LockRequestStatusNames) / sizeof(LockRequestStatusNames[0])) == + LockRequest::StatusCount); } // namespace diff --git a/src/mongo/db/concurrency/lock_manager_defs.h b/src/mongo/db/concurrency/lock_manager_defs.h index 9e1ec088041..8849816278c 100644 --- a/src/mongo/db/concurrency/lock_manager_defs.h +++ b/src/mongo/db/concurrency/lock_manager_defs.h @@ -32,6 +32,7 @@ #include <limits> #include <string> +#include "mongo/base/static_assert.h" #include "mongo/base/string_data.h" #include "mongo/config.h" #include "mongo/platform/hash_namespace.h" @@ -175,8 +176,7 @@ const char* resourceTypeName(ResourceType resourceType); class ResourceId { // We only use 3 bits for the resource type in the ResourceId hash enum { resourceTypeBits = 3 }; - static_assert(ResourceTypesCount <= (1 << resourceTypeBits), - "ResourceTypesCount <= (1 << resourceTypeBits)"); + MONGO_STATIC_ASSERT(ResourceTypesCount <= (1 << resourceTypeBits)); public: /** @@ -240,7 +240,7 @@ private: #ifndef MONGO_CONFIG_DEBUG_BUILD // Treat the resource ids as 64-bit integers in release mode in order to ensure we do // not spend too much time doing comparisons for hashing. -static_assert(sizeof(ResourceId) == sizeof(uint64_t), "sizeof(ResourceId) == sizeof(uint64_t)"); +MONGO_STATIC_ASSERT(sizeof(ResourceId) == sizeof(uint64_t)); #endif diff --git a/src/mongo/db/dbmessage.h b/src/mongo/db/dbmessage.h index 01530edd641..63d3aaea350 100644 --- a/src/mongo/db/dbmessage.h +++ b/src/mongo/db/dbmessage.h @@ -30,6 +30,7 @@ #pragma once +#include "mongo/base/static_assert.h" #include "mongo/bson/bson_validate.h" #include "mongo/client/constants.h" #include "mongo/db/jsobj.h" @@ -202,7 +203,7 @@ private: class Value : public EncodedValueStorage<Layout, ConstView, View> { public: Value() { - static_assert(sizeof(Value) == sizeof(Layout), "sizeof(Value) == sizeof(Layout)"); + MONGO_STATIC_ASSERT(sizeof(Value) == sizeof(Layout)); } Value(ZeroInitTag_t zit) : EncodedValueStorage<Layout, ConstView, View>(zit) {} @@ -217,7 +218,7 @@ public: */ class DbMessage { // Assume sizeof(int) == 4 bytes - static_assert(sizeof(int) == 4, "sizeof(int) == 4"); + MONGO_STATIC_ASSERT(sizeof(int) == 4); public: // Note: DbMessage constructor reads the first 4 bytes and stores it in reserved diff --git a/src/mongo/db/pipeline/document_internal.h b/src/mongo/db/pipeline/document_internal.h index 3ad0d1ee577..2fd3c78cf34 100644 --- a/src/mongo/db/pipeline/document_internal.h +++ b/src/mongo/db/pipeline/document_internal.h @@ -33,6 +33,7 @@ #include <bitset> #include <boost/intrusive_ptr.hpp> +#include "mongo/base/static_assert.h" #include "mongo/db/pipeline/value.h" #include "mongo/util/intrusive_counter.h" @@ -123,8 +124,7 @@ private: }; // Real size is sizeof(ValueElement) + nameLen #pragma pack() -static_assert(sizeof(ValueElement) == (sizeof(Value) + sizeof(Position) + sizeof(int) + 1), - "sizeof(ValueElement) == (sizeof(Value) + sizeof(Position) + sizeof(int) + 1)"); +MONGO_STATIC_ASSERT(sizeof(ValueElement) == (sizeof(Value) + sizeof(Position) + sizeof(int) + 1)); // This is an internal class for Document. See FieldIterator for the public version. class DocumentStorageIterator { diff --git a/src/mongo/db/pipeline/value.cpp b/src/mongo/db/pipeline/value.cpp index 291cc205053..5eea4d314d1 100644 --- a/src/mongo/db/pipeline/value.cpp +++ b/src/mongo/db/pipeline/value.cpp @@ -181,8 +181,7 @@ Value::Value(const BSONElement& elem) : _storage(elem.type()) { } case jstOID: - static_assert(sizeof(_storage.oid) == OID::kOIDSize, - "sizeof(_storage.oid) == OID::kOIDSize"); + MONGO_STATIC_ASSERT(sizeof(_storage.oid) == OID::kOIDSize); memcpy(_storage.oid, elem.OID().view().view(), OID::kOIDSize); break; @@ -836,8 +835,7 @@ void Value::hash_combine(size_t& seed, case bsonTimestamp: case Date: - static_assert(sizeof(_storage.dateValue) == sizeof(_storage.timestampValue), - "sizeof(_storage.dateValue) == sizeof(_storage.timestampValue)"); + MONGO_STATIC_ASSERT(sizeof(_storage.dateValue) == sizeof(_storage.timestampValue)); boost::hash_combine(seed, _storage.dateValue); break; diff --git a/src/mongo/db/pipeline/value.h b/src/mongo/db/pipeline/value.h index b4dfc6a4943..544cce0d604 100644 --- a/src/mongo/db/pipeline/value.h +++ b/src/mongo/db/pipeline/value.h @@ -28,6 +28,7 @@ #pragma once +#include "mongo/base/static_assert.h" #include "mongo/base/string_data.h" #include "mongo/db/pipeline/value_internal.h" #include "mongo/platform/unordered_set.h" @@ -334,7 +335,7 @@ private: ValueStorage _storage; friend class MutableValue; // gets and sets _storage.genericRCPtr }; -static_assert(sizeof(Value) == 16, "sizeof(Value) == 16"); +MONGO_STATIC_ASSERT(sizeof(Value) == 16); inline void swap(mongo::Value& lhs, mongo::Value& rhs) { lhs.swap(rhs); diff --git a/src/mongo/db/pipeline/value_internal.h b/src/mongo/db/pipeline/value_internal.h index fe34b97e0a7..51d76e6cf73 100644 --- a/src/mongo/db/pipeline/value_internal.h +++ b/src/mongo/db/pipeline/value_internal.h @@ -32,6 +32,7 @@ #include <boost/config.hpp> #include <boost/intrusive_ptr.hpp> +#include "mongo/base/static_assert.h" #include "mongo/bson/bsonmisc.h" #include "mongo/bson/bsonobj.h" #include "mongo/bson/bsontypes.h" @@ -358,6 +359,6 @@ public: long long i64[2]; }; }; -static_assert(sizeof(ValueStorage) == 16, "sizeof(ValueStorage) == 16"); +MONGO_STATIC_ASSERT(sizeof(ValueStorage) == 16); #pragma pack() } diff --git a/src/mongo/db/repl/member_state.h b/src/mongo/db/repl/member_state.h index 44b8eb7976d..9a012bb8291 100644 --- a/src/mongo/db/repl/member_state.h +++ b/src/mongo/db/repl/member_state.h @@ -34,6 +34,7 @@ #include <type_traits> #include "mongo/base/error_codes.h" +#include "mongo/base/static_assert.h" #include "mongo/base/status_with.h" #include "mongo/util/mongoutils/str.h" @@ -68,7 +69,7 @@ struct MemberState { template <typename T> static StatusWith<MemberState> create(T t) { - static_assert(std::is_integral<T>::value, "T must be an integral type"); + MONGO_STATIC_ASSERT_MSG(std::is_integral<T>::value, "T must be an integral type"); using UnderlyingType = std::underlying_type<MS>::type; if (std::is_signed<T>::value && (t < 0)) return {ErrorCodes::BadValue, str::stream() << "MemberState cannot be negative"}; diff --git a/src/mongo/db/server_parameters.h b/src/mongo/db/server_parameters.h index 9ce8d8b76be..e4b71c93d26 100644 --- a/src/mongo/db/server_parameters.h +++ b/src/mongo/db/server_parameters.h @@ -33,6 +33,7 @@ #include <map> #include <string> +#include "mongo/base/static_assert.h" #include "mongo/base/status.h" #include "mongo/db/jsobj.h" #include "mongo/platform/atomic_proxy.h" @@ -192,9 +193,9 @@ public: template <typename T, ServerParameterType paramType> class ExportedServerParameter : public ServerParameter { public: - static_assert(paramType == ServerParameterType::kStartupOnly || - is_safe_runtime_parameter_type<T>::value, - "This type is not supported as a runtime server parameter."); + MONGO_STATIC_ASSERT_MSG(paramType == ServerParameterType::kStartupOnly || + is_safe_runtime_parameter_type<T>::value, + "This type is not supported as a runtime server parameter."); using storage_type = typename server_parameter_storage_type<T, paramType>::value_type; diff --git a/src/mongo/db/sorter/sorter_test.cpp b/src/mongo/db/sorter/sorter_test.cpp index 37bf118fe98..19171fb13ba 100644 --- a/src/mongo/db/sorter/sorter_test.cpp +++ b/src/mongo/db/sorter/sorter_test.cpp @@ -34,6 +34,7 @@ #include "mongo/base/data_type_endian.h" #include "mongo/base/init.h" +#include "mongo/base/static_assert.h" #include "mongo/config.h" #include "mongo/db/service_context.h" #include "mongo/db/service_context_noop.h" @@ -488,10 +489,8 @@ public: SortOptions adjustSortOptions(SortOptions opts) { // Make sure we use a reasonable number of files when we spill - static_assert((NUM_ITEMS * sizeof(IWPair)) / MEM_LIMIT > 50, - "(NUM_ITEMS * sizeof(IWPair)) / MEM_LIMIT > 50"); - static_assert((NUM_ITEMS * sizeof(IWPair)) / MEM_LIMIT < 500, - "(NUM_ITEMS * sizeof(IWPair)) / MEM_LIMIT < 500"); + MONGO_STATIC_ASSERT((NUM_ITEMS * sizeof(IWPair)) / MEM_LIMIT > 50); + MONGO_STATIC_ASSERT((NUM_ITEMS * sizeof(IWPair)) / MEM_LIMIT < 500); return opts.MaxMemoryUsageBytes(MEM_LIMIT).ExtSortAllowed(); } @@ -527,17 +526,13 @@ class LotsOfDataWithLimit : public LotsOfDataLittleMemory<Random> { typedef LotsOfDataLittleMemory<Random> Parent; SortOptions adjustSortOptions(SortOptions opts) { // Make sure our tests will spill or not as desired - static_assert(MEM_LIMIT / 2 > (100 * sizeof(IWPair)), - "MEM_LIMIT / 2 > (100 * sizeof(IWPair))"); - static_assert(MEM_LIMIT < (5000 * sizeof(IWPair)), "MEM_LIMIT < (5000 * sizeof(IWPair))"); - static_assert(MEM_LIMIT * 2 > (5000 * sizeof(IWPair)), - "MEM_LIMIT * 2 > (5000 * sizeof(IWPair))"); + MONGO_STATIC_ASSERT(MEM_LIMIT / 2 > (100 * sizeof(IWPair))); + MONGO_STATIC_ASSERT(MEM_LIMIT < (5000 * sizeof(IWPair))); + MONGO_STATIC_ASSERT(MEM_LIMIT * 2 > (5000 * sizeof(IWPair))); // Make sure we use a reasonable number of files when we spill - static_assert((Parent::NUM_ITEMS * sizeof(IWPair)) / MEM_LIMIT > 100, - "(Parent::NUM_ITEMS * sizeof(IWPair)) / MEM_LIMIT > 100"); - static_assert((Parent::NUM_ITEMS * sizeof(IWPair)) / MEM_LIMIT < 500, - "(Parent::NUM_ITEMS * sizeof(IWPair)) / MEM_LIMIT < 500"); + MONGO_STATIC_ASSERT((Parent::NUM_ITEMS * sizeof(IWPair)) / MEM_LIMIT > 100); + MONGO_STATIC_ASSERT((Parent::NUM_ITEMS * sizeof(IWPair)) / MEM_LIMIT < 500); return opts.MaxMemoryUsageBytes(MEM_LIMIT).ExtSortAllowed().Limit(Limit); } diff --git a/src/mongo/db/stats/snapshots.cpp b/src/mongo/db/stats/snapshots.cpp index a9d31319d2b..c1088f4d12f 100644 --- a/src/mongo/db/stats/snapshots.cpp +++ b/src/mongo/db/stats/snapshots.cpp @@ -34,6 +34,7 @@ #include "mongo/db/stats/snapshots.h" +#include "mongo/base/static_assert.h" #include "mongo/db/client.h" #include "mongo/db/clientcursor.h" #include "mongo/db/service_context.h" @@ -93,7 +94,7 @@ StatusWith<SnapshotDiff> Snapshots::computeDelta() { } // The following logic depends on there being exactly 2 stored snapshots - static_assert(kNumSnapshots == 2, "kNumSnapshots == 2"); + MONGO_STATIC_ASSERT(kNumSnapshots == 2); // Current and previous napshot alternates between indexes 0 and 1 int currIdx = _loc; diff --git a/src/mongo/db/storage/key_string.cpp b/src/mongo/db/storage/key_string.cpp index 5c6adfc37c2..368ea038dd6 100644 --- a/src/mongo/db/storage/key_string.cpp +++ b/src/mongo/db/storage/key_string.cpp @@ -35,6 +35,7 @@ #include "mongo/db/storage/key_string.h" #include <cmath> +#include <type_traits> #include "mongo/base/data_view.h" #include "mongo/platform/bits.h" @@ -98,12 +99,11 @@ const uint8_t kNumericPositive6ByteInt = kNumeric + 18; const uint8_t kNumericPositive7ByteInt = kNumeric + 19; const uint8_t kNumericPositive8ByteInt = kNumeric + 20; const uint8_t kNumericPositiveLargeMagnitude = kNumeric + 21; // >= 2**63 including +Inf -static_assert(kNumericPositiveLargeMagnitude < kStringLike, - "kNumericPositiveLargeMagnitude < kStringLike"); +MONGO_STATIC_ASSERT(kNumericPositiveLargeMagnitude < kStringLike); const uint8_t kBoolFalse = kBool + 0; const uint8_t kBoolTrue = kBool + 1; -static_assert(kBoolTrue < kDate, "kBoolTrue < kDate"); +MONGO_STATIC_ASSERT(kBoolTrue < kDate); size_t numBytesForInt(uint8_t ctype) { if (ctype >= kNumericPositive1ByteInt) { @@ -240,7 +240,7 @@ void memcpy_flipBits(void* dst, const void* src, size_t bytes) { template <typename T> T readType(BufReader* reader, bool inverted) { - // TODO for C++11 to static_assert that T is integral + MONGO_STATIC_ASSERT(std::is_integral<T>::value); T t = ConstDataView(static_cast<const char*>(reader->skip(sizeof(T)))).read<T>(); if (inverted) return ~t; diff --git a/src/mongo/db/storage/key_string.h b/src/mongo/db/storage/key_string.h index 5b3d256f0d4..5884c707082 100644 --- a/src/mongo/db/storage/key_string.h +++ b/src/mongo/db/storage/key_string.h @@ -32,6 +32,7 @@ #include <limits> +#include "mongo/base/static_assert.h" #include "mongo/bson/bsonmisc.h" #include "mongo/bson/bsonobj.h" #include "mongo/bson/bsonobjbuilder.h" @@ -67,8 +68,9 @@ public: static const uint32_t kBytesForTypeAndEmptyKey = 2; static const uint32_t kMaxDecimalsPerKey = kMaxKeyBytes / (sizeof(Decimal128::Value) + kBytesForTypeAndEmptyKey); - static_assert(kMaxTypeBitsPerDecimal * kMaxDecimalsPerKey < kMaxBytesNeeded * 8UL, - "encoding needs change to contain all type bits for worst case key"); + MONGO_STATIC_ASSERT_MSG( + kMaxTypeBitsPerDecimal* kMaxDecimalsPerKey < kMaxBytesNeeded * 8UL, + "encoding needs change to contain all type bits for worst case key"); static const uint8_t kStoredDecimalExponentBits = 6; static const uint32_t kStoredDecimalExponentMask = (1U << kStoredDecimalExponentBits) - 1; diff --git a/src/mongo/db/storage/mmap_v1/aligned_builder.cpp b/src/mongo/db/storage/mmap_v1/aligned_builder.cpp index 2af4891fe60..96e7ddd936e 100644 --- a/src/mongo/db/storage/mmap_v1/aligned_builder.cpp +++ b/src/mongo/db/storage/mmap_v1/aligned_builder.cpp @@ -32,6 +32,7 @@ #include "mongo/db/storage/mmap_v1/aligned_builder.h" +#include "mongo/base/static_assert.h" #include "mongo/util/debug_util.h" #include "mongo/util/log.h" @@ -45,7 +46,7 @@ AlignedBuilder::AlignedBuilder(unsigned initSize) { uassert(13584, "out of memory AlignedBuilder", _p._allocationAddress); } -static_assert(sizeof(void*) == sizeof(size_t), "sizeof(void*) == sizeof(size_t)"); +MONGO_STATIC_ASSERT(sizeof(void*) == sizeof(size_t)); /** reset for a re-use. shrinks if > 128MB */ void AlignedBuilder::reset() { diff --git a/src/mongo/db/storage/mmap_v1/btree/btree_ondisk.h b/src/mongo/db/storage/mmap_v1/btree/btree_ondisk.h index 26c99cd50cb..9be2f947772 100644 --- a/src/mongo/db/storage/mmap_v1/btree/btree_ondisk.h +++ b/src/mongo/db/storage/mmap_v1/btree/btree_ondisk.h @@ -28,6 +28,7 @@ #pragma once +#include "mongo/base/static_assert.h" #include "mongo/db/jsobj.h" #include "mongo/db/storage/mmap_v1/btree/key.h" #include "mongo/db/storage/mmap_v1/diskloc.h" @@ -181,10 +182,8 @@ struct BtreeBucketV0 { }; // BtreeBucketV0 is part of the on-disk format, so it should never be changed -static_assert(sizeof(BtreeBucketV0) - sizeof(static_cast<BtreeBucketV0*>(NULL)->data) == - BtreeBucketV0::HeaderSize, - "sizeof(BtreeBucketV0) - sizeof(static_cast<BtreeBucketV0*>(NULL)->data) == " - "BtreeBucketV0::HeaderSize"); +MONGO_STATIC_ASSERT(sizeof(BtreeBucketV0) - sizeof(static_cast<BtreeBucketV0*>(NULL)->data) == + BtreeBucketV0::HeaderSize); /** * A variant of DiskLoc Used by the V1 bucket type. @@ -324,10 +323,8 @@ struct BtreeBucketV1 { }; // BtreeBucketV1 is part of the on-disk format, so it should never be changed -static_assert(sizeof(BtreeBucketV1) - sizeof(static_cast<BtreeBucketV1*>(NULL)->data) == - BtreeBucketV1::HeaderSize, - "sizeof(BtreeBucketV1) - sizeof(static_cast<BtreeBucketV1*>(NULL)->data) == " - "BtreeBucketV1::HeaderSize"); +MONGO_STATIC_ASSERT(sizeof(BtreeBucketV1) - sizeof(static_cast<BtreeBucketV1*>(NULL)->data) == + BtreeBucketV1::HeaderSize); enum Flags { Packed = 1 }; diff --git a/src/mongo/db/storage/mmap_v1/catalog/hashtab.h b/src/mongo/db/storage/mmap_v1/catalog/hashtab.h index ecd0f8c4b4e..e22453b99db 100644 --- a/src/mongo/db/storage/mmap_v1/catalog/hashtab.h +++ b/src/mongo/db/storage/mmap_v1/catalog/hashtab.h @@ -28,6 +28,7 @@ #pragma once +#include "mongo/base/static_assert.h" #include "mongo/db/operation_context.h" #include "mongo/db/storage/mmap_v1/catalog/namespace.h" #include "mongo/db/storage/mmap_v1/catalog/namespace_details.h" @@ -116,7 +117,7 @@ private: }; #pragma pack() - static_assert(sizeof(Node) == 628, "sizeof(Node) == 628"); + MONGO_STATIC_ASSERT(sizeof(Node) == 628); int _find(const Namespace& k, bool& found) const; diff --git a/src/mongo/db/storage/mmap_v1/catalog/namespace.cpp b/src/mongo/db/storage/mmap_v1/catalog/namespace.cpp index b1e1d261dd6..a9ff70f8634 100644 --- a/src/mongo/db/storage/mmap_v1/catalog/namespace.cpp +++ b/src/mongo/db/storage/mmap_v1/catalog/namespace.cpp @@ -30,22 +30,18 @@ #include "mongo/platform/basic.h" +#include "mongo/base/static_assert.h" #include "mongo/db/storage/mmap_v1/catalog/namespace.h" - #include "mongo/db/namespace_string.h" namespace mongo { namespace { -static_assert(sizeof(Namespace) == 128, "sizeof(Namespace) == 128"); -static_assert(Namespace::MaxNsLenWithNUL == MaxDatabaseNameLen, - "Namespace::MaxNsLenWithNUL == MaxDatabaseNameLen"); -static_assert((int)Namespace::MaxNsLenWithNUL == (int)NamespaceString::MaxNsLenWithNUL, - "(int)Namespace::MaxNsLenWithNUL == (int)NamespaceString::MaxNsLenWithNUL"); -static_assert((int)Namespace::MaxNsLen == (int)NamespaceString::MaxNsLen, - "(int)Namespace::MaxNsLen == (int)NamespaceString::MaxNsLen"); +MONGO_STATIC_ASSERT(sizeof(Namespace) == 128); +MONGO_STATIC_ASSERT(Namespace::MaxNsLenWithNUL == MaxDatabaseNameLen); +MONGO_STATIC_ASSERT((int)Namespace::MaxNsLenWithNUL == (int)NamespaceString::MaxNsLenWithNUL); +MONGO_STATIC_ASSERT((int)Namespace::MaxNsLen == (int)NamespaceString::MaxNsLen); // Note the typo. -static_assert((int)Namespace::MaxNsColletionLen == (int)NamespaceString::MaxNsCollectionLen, - "(int)Namespace::MaxNsColletionLen == (int)NamespaceString::MaxNsCollectionLen"); +MONGO_STATIC_ASSERT((int)Namespace::MaxNsColletionLen == (int)NamespaceString::MaxNsCollectionLen); } } diff --git a/src/mongo/db/storage/mmap_v1/catalog/namespace_details.cpp b/src/mongo/db/storage/mmap_v1/catalog/namespace_details.cpp index a61a08261fb..d7f19c49f16 100644 --- a/src/mongo/db/storage/mmap_v1/catalog/namespace_details.cpp +++ b/src/mongo/db/storage/mmap_v1/catalog/namespace_details.cpp @@ -52,8 +52,7 @@ namespace mongo { NamespaceDetails::NamespaceDetails(const DiskLoc& loc, bool capped) { - static_assert(sizeof(NamespaceDetails::Extra) <= sizeof(NamespaceDetails), - "sizeof(NamespaceDetails::Extra) <= sizeof(NamespaceDetails)"); + MONGO_STATIC_ASSERT(sizeof(NamespaceDetails::Extra) <= sizeof(NamespaceDetails)); /* be sure to initialize new fields here -- doesn't default to zeroes the way we use it */ firstExtent = lastExtent = capExtent = loc; diff --git a/src/mongo/db/storage/mmap_v1/catalog/namespace_details.h b/src/mongo/db/storage/mmap_v1/catalog/namespace_details.h index 1da82400088..f1196bcd166 100644 --- a/src/mongo/db/storage/mmap_v1/catalog/namespace_details.h +++ b/src/mongo/db/storage/mmap_v1/catalog/namespace_details.h @@ -28,6 +28,7 @@ #pragma once +#include "mongo/base/static_assert.h" #include "mongo/db/namespace_string.h" #include "mongo/db/storage/mmap_v1/catalog/index_details.h" #include "mongo/db/storage/mmap_v1/catalog/namespace.h" @@ -240,12 +241,11 @@ private: /** Update cappedLastDelRecLastExtent() after capExtent changed in cappedTruncateAfter() */ void cappedTruncateLastDelUpdate(); - static_assert(NIndexesMax <= NIndexesBase + NIndexesExtra * 2, - "NIndexesMax <= NIndexesBase + NIndexesExtra * 2"); - static_assert(NIndexesMax <= 64, "NIndexesMax <= 64"); // multiKey bits - static_assert(sizeof(NamespaceDetails::Extra) == 496, "sizeof(NamespaceDetails::Extra) == 496"); + MONGO_STATIC_ASSERT(NIndexesMax <= NIndexesBase + NIndexesExtra * 2); + MONGO_STATIC_ASSERT(NIndexesMax <= 64); // multiKey bits + MONGO_STATIC_ASSERT(sizeof(NamespaceDetails::Extra) == 496); }; // NamespaceDetails -static_assert(sizeof(NamespaceDetails) == 496, "sizeof(NamespaceDetails) == 496"); +MONGO_STATIC_ASSERT(sizeof(NamespaceDetails) == 496); #pragma pack() } // namespace mongo diff --git a/src/mongo/db/storage/mmap_v1/catalog/namespace_details_rsv1_metadata.cpp b/src/mongo/db/storage/mmap_v1/catalog/namespace_details_rsv1_metadata.cpp index 219f410283b..eaa3a1cf958 100644 --- a/src/mongo/db/storage/mmap_v1/catalog/namespace_details_rsv1_metadata.cpp +++ b/src/mongo/db/storage/mmap_v1/catalog/namespace_details_rsv1_metadata.cpp @@ -30,7 +30,7 @@ #include "mongo/db/storage/mmap_v1/catalog/namespace_details_rsv1_metadata.h" - +#include "mongo/base/static_assert.h" #include "mongo/db/operation_context.h" namespace mongo { @@ -38,10 +38,8 @@ namespace mongo { using std::unique_ptr; using std::numeric_limits; -static_assert(RecordStoreV1Base::Buckets == - NamespaceDetails::SmallBuckets + NamespaceDetails::LargeBuckets, - "RecordStoreV1Base::Buckets == NamespaceDetails::SmallBuckets + " - "NamespaceDetails::LargeBuckets"); +MONGO_STATIC_ASSERT(RecordStoreV1Base::Buckets == + NamespaceDetails::SmallBuckets + NamespaceDetails::LargeBuckets); NamespaceDetailsRSV1MetaData::NamespaceDetailsRSV1MetaData(StringData ns, NamespaceDetails* details) : _ns(ns.toString()), _details(details) {} diff --git a/src/mongo/db/storage/mmap_v1/data_file.cpp b/src/mongo/db/storage/mmap_v1/data_file.cpp index b5fc8bf4d6c..c90ff1f74da 100644 --- a/src/mongo/db/storage/mmap_v1/data_file.cpp +++ b/src/mongo/db/storage/mmap_v1/data_file.cpp @@ -38,6 +38,7 @@ #include <utility> #include <vector> +#include "mongo/base/static_assert.h" #include "mongo/db/operation_context.h" #include "mongo/db/storage/mmap_v1/dur.h" #include "mongo/db/storage/mmap_v1/durable_mapped_file.h" @@ -64,13 +65,10 @@ void data_file_check(void* _mb) { } // namespace -static_assert(DataFileHeader::HeaderSize == 8192, "DataFileHeader::HeaderSize == 8192"); -static_assert(sizeof(static_cast<DataFileHeader*>(NULL)->data) == 4, - "sizeof(static_cast<DataFileHeader*>(NULL)->data) == 4"); -static_assert(sizeof(DataFileHeader) - sizeof(static_cast<DataFileHeader*>(NULL)->data) == - DataFileHeader::HeaderSize, - "sizeof(DataFileHeader) - sizeof(static_cast<DataFileHeader*>(NULL)->data) == " - "DataFileHeader::HeaderSize"); +MONGO_STATIC_ASSERT(DataFileHeader::HeaderSize == 8192); +MONGO_STATIC_ASSERT(sizeof(static_cast<DataFileHeader*>(NULL)->data) == 4); +MONGO_STATIC_ASSERT(sizeof(DataFileHeader) - sizeof(static_cast<DataFileHeader*>(NULL)->data) == + DataFileHeader::HeaderSize); int DataFile::maxSize() { diff --git a/src/mongo/db/storage/mmap_v1/dur.cpp b/src/mongo/db/storage/mmap_v1/dur.cpp index 480a6d34a89..1ed88c8d117 100644 --- a/src/mongo/db/storage/mmap_v1/dur.cpp +++ b/src/mongo/db/storage/mmap_v1/dur.cpp @@ -78,6 +78,7 @@ #include <iomanip> #include <utility> +#include "mongo/base/static_assert.h" #include "mongo/db/client.h" #include "mongo/db/commands/server_status.h" #include "mongo/db/concurrency/lock_state.h" @@ -149,10 +150,8 @@ unsigned remapFileToStartAt; enum { DurStatsResetIntervalMillis = 3 * 1000 }; // Size sanity checks -static_assert(UncommittedBytesLimit > BSONObjMaxInternalSize * 3, - "UncommittedBytesLimit > BSONObjMaxInternalSize * 3"); -static_assert(sizeof(void*) == 4 || UncommittedBytesLimit > BSONObjMaxInternalSize * 6, - "sizeof(void*) == 4 || UncommittedBytesLimit > BSONObjMaxInternalSize * 6"); +MONGO_STATIC_ASSERT(UncommittedBytesLimit > BSONObjMaxInternalSize * 3); +MONGO_STATIC_ASSERT(sizeof(void*) == 4 || UncommittedBytesLimit > BSONObjMaxInternalSize * 6); /** diff --git a/src/mongo/db/storage/mmap_v1/dur_journal.cpp b/src/mongo/db/storage/mmap_v1/dur_journal.cpp index e978e7e8e11..2d8e7b02fa6 100644 --- a/src/mongo/db/storage/mmap_v1/dur_journal.cpp +++ b/src/mongo/db/storage/mmap_v1/dur_journal.cpp @@ -38,6 +38,7 @@ #include <boost/filesystem/operations.hpp> #include "mongo/base/init.h" +#include "mongo/base/static_assert.h" #include "mongo/config.h" #include "mongo/db/client.h" #include "mongo/db/storage/mmap_v1/aligned_builder.h" @@ -96,12 +97,12 @@ MONGO_INITIALIZER(InitializeJournalingParams)(InitializerContext* context) { return Status::OK(); } -static_assert(sizeof(Checksum) == 16, "sizeof(Checksum) == 16"); -static_assert(sizeof(JHeader) == 8192, "sizeof(JHeader) == 8192"); -static_assert(sizeof(JSectHeader) == 20, "sizeof(JSectHeader) == 20"); -static_assert(sizeof(JSectFooter) == 32, "sizeof(JSectFooter) == 32"); -static_assert(sizeof(JEntry) == 12, "sizeof(JEntry) == 12"); -static_assert(sizeof(LSNFile) == 88, "sizeof(LSNFile) == 88"); +MONGO_STATIC_ASSERT(sizeof(Checksum) == 16); +MONGO_STATIC_ASSERT(sizeof(JHeader) == 8192); +MONGO_STATIC_ASSERT(sizeof(JSectHeader) == 20); +MONGO_STATIC_ASSERT(sizeof(JSectFooter) == 32); +MONGO_STATIC_ASSERT(sizeof(JEntry) == 12); +MONGO_STATIC_ASSERT(sizeof(LSNFile) == 88); bool usingPreallocate = false; diff --git a/src/mongo/db/storage/mmap_v1/durable_mapped_file.h b/src/mongo/db/storage/mmap_v1/durable_mapped_file.h index 404982b46e8..3175fa8fa73 100644 --- a/src/mongo/db/storage/mmap_v1/durable_mapped_file.h +++ b/src/mongo/db/storage/mmap_v1/durable_mapped_file.h @@ -31,6 +31,7 @@ #pragma once +#include "mongo/base/static_assert.h" #include "mongo/db/storage/mmap_v1/mmap.h" #include "mongo/db/storage/paths.h" #include "mongo/stdx/mutex.h" @@ -159,13 +160,13 @@ public: static const unsigned long long MaxWinMemory = 128ULL * 1024 * 1024 * 1024 * 1024; // Make sure that the chunk memory covers the Max Windows user process VM space - static_assert(MaxChunkMemory == MaxWinMemory, - "Need a larger bitset to cover max process VM space"); + MONGO_STATIC_ASSERT_MSG(MaxChunkMemory == MaxWinMemory, + "Need a larger bitset to cover max process VM space"); public: MemoryMappedCOWBitset() { - static_assert(MemoryMappedCOWBitset::MaxChunkBytes == sizeof(bits), - "Validate our predicted bitset size is correct"); + MONGO_STATIC_ASSERT_MSG(MemoryMappedCOWBitset::MaxChunkBytes == sizeof(bits), + "Validate our predicted bitset size is correct"); } bool get(uintptr_t i) const { diff --git a/src/mongo/db/storage/mmap_v1/extent.cpp b/src/mongo/db/storage/mmap_v1/extent.cpp index fb134504f10..92dd07933b6 100644 --- a/src/mongo/db/storage/mmap_v1/extent.cpp +++ b/src/mongo/db/storage/mmap_v1/extent.cpp @@ -30,6 +30,7 @@ #include "mongo/db/storage/mmap_v1/extent.h" +#include "mongo/base/static_assert.h" #include "mongo/db/storage/mmap_v1/extent_manager.h" #include "mongo/util/hex.h" #include "mongo/util/mongoutils/str.h" @@ -40,7 +41,7 @@ using std::iostream; using std::string; using std::vector; -static_assert(sizeof(Extent) - 4 == 48 + 128, "sizeof(Extent) - 4 == 48 + 128"); +MONGO_STATIC_ASSERT(sizeof(Extent) - 4 == 48 + 128); BSONObj Extent::dump() const { return BSON("loc" << myLoc.toString() << "xnext" << xnext.toString() << "xprev" diff --git a/src/mongo/db/storage/mmap_v1/logfile.cpp b/src/mongo/db/storage/mmap_v1/logfile.cpp index 401d9b234a9..acf2db64d74 100644 --- a/src/mongo/db/storage/mmap_v1/logfile.cpp +++ b/src/mongo/db/storage/mmap_v1/logfile.cpp @@ -199,8 +199,8 @@ LogFile::~LogFile() { void LogFile::truncate() { verify(_fd >= 0); - static_assert(sizeof(off_t) == 8, "sizeof(off_t) == 8"); // we don't want overflow here - const off_t pos = lseek(_fd, 0, SEEK_CUR); // doesn't actually seek + MONGO_STATIC_ASSERT(sizeof(off_t) == 8); // we don't want overflow here + const off_t pos = lseek(_fd, 0, SEEK_CUR); // doesn't actually seek if (ftruncate(_fd, pos) != 0) { msgasserted(15873, "Couldn't truncate file: " + errnoWithDescription()); } diff --git a/src/mongo/db/storage/mmap_v1/record.h b/src/mongo/db/storage/mmap_v1/record.h index a8b63b13390..401808742a9 100644 --- a/src/mongo/db/storage/mmap_v1/record.h +++ b/src/mongo/db/storage/mmap_v1/record.h @@ -30,6 +30,7 @@ #pragma once +#include "mongo/base/static_assert.h" #include "mongo/bson/bsonobjbuilder.h" #include "mongo/db/storage/mmap_v1/diskloc.h" #include "mongo/db/storage/record_data.h" @@ -175,6 +176,6 @@ private: DiskLoc _nextDeleted; }; -static_assert(16 == sizeof(DeletedRecord), "16 == sizeof(DeletedRecord)"); +MONGO_STATIC_ASSERT(16 == sizeof(DeletedRecord)); } // namespace mongo diff --git a/src/mongo/db/storage/mmap_v1/record_store_v1_base.cpp b/src/mongo/db/storage/mmap_v1/record_store_v1_base.cpp index fb3f101e172..6d9e263f7d6 100644 --- a/src/mongo/db/storage/mmap_v1/record_store_v1_base.cpp +++ b/src/mongo/db/storage/mmap_v1/record_store_v1_base.cpp @@ -33,6 +33,7 @@ #include "mongo/db/storage/mmap_v1/record_store_v1_base.h" +#include "mongo/base/static_assert.h" #include "mongo/db/catalog/collection.h" #include "mongo/db/client.h" #include "mongo/db/operation_context.h" @@ -86,10 +87,9 @@ const int RecordStoreV1Base::bucketSizes[] = { }; // If this fails, it means that bucketSizes doesn't have the correct number of entries. -static_assert(sizeof(RecordStoreV1Base::bucketSizes) / sizeof(RecordStoreV1Base::bucketSizes[0]) == - RecordStoreV1Base::Buckets, - "sizeof(RecordStoreV1Base::bucketSizes) / sizeof(RecordStoreV1Base::bucketSizes[0]) " - "== RecordStoreV1Base::Buckets"); +MONGO_STATIC_ASSERT(sizeof(RecordStoreV1Base::bucketSizes) / + sizeof(RecordStoreV1Base::bucketSizes[0]) == + RecordStoreV1Base::Buckets); SavedCursorRegistry::~SavedCursorRegistry() { for (SavedCursorSet::iterator it = _cursors.begin(); it != _cursors.end(); it++) { diff --git a/src/mongo/db/storage/wiredtiger/wiredtiger_record_store.cpp b/src/mongo/db/storage/wiredtiger/wiredtiger_record_store.cpp index 4c83764fa3c..3dd326ba9ac 100644 --- a/src/mongo/db/storage/wiredtiger/wiredtiger_record_store.cpp +++ b/src/mongo/db/storage/wiredtiger/wiredtiger_record_store.cpp @@ -38,6 +38,7 @@ #include <wiredtiger.h> #include "mongo/base/checked_cast.h" +#include "mongo/base/static_assert.h" #include "mongo/bson/util/builder.h" #include "mongo/db/concurrency/locker.h" #include "mongo/db/concurrency/write_conflict_exception.h" @@ -74,10 +75,8 @@ namespace { static const int kMinimumRecordStoreVersion = 1; static const int kCurrentRecordStoreVersion = 1; // New record stores use this by default. static const int kMaximumRecordStoreVersion = 1; -static_assert(kCurrentRecordStoreVersion >= kMinimumRecordStoreVersion, - "kCurrentRecordStoreVersion >= kMinimumRecordStoreVersion"); -static_assert(kCurrentRecordStoreVersion <= kMaximumRecordStoreVersion, - "kCurrentRecordStoreVersion <= kMaximumRecordStoreVersion"); +MONGO_STATIC_ASSERT(kCurrentRecordStoreVersion >= kMinimumRecordStoreVersion); +MONGO_STATIC_ASSERT(kCurrentRecordStoreVersion <= kMaximumRecordStoreVersion); bool shouldUseOplogHack(OperationContext* opCtx, const std::string& uri) { StatusWith<BSONObj> appMetadata = WiredTigerUtil::getApplicationMetadata(opCtx, uri); diff --git a/src/mongo/executor/network_interface_asio_command.cpp b/src/mongo/executor/network_interface_asio_command.cpp index f87b83736a4..4c981ff41e0 100644 --- a/src/mongo/executor/network_interface_asio_command.cpp +++ b/src/mongo/executor/network_interface_asio_command.cpp @@ -34,6 +34,7 @@ #include <type_traits> #include <utility> +#include "mongo/base/static_assert.h" #include "mongo/db/dbmessage.h" #include "mongo/db/jsobj.h" #include "mongo/executor/async_stream_interface.h" @@ -76,8 +77,9 @@ using IsNetworkHandler = template <typename Handler> void asyncSendMessage(AsyncStreamInterface& stream, Message* m, Handler&& handler) { - static_assert(IsNetworkHandler<Handler>::value, - "Handler passed to asyncSendMessage does not conform to NetworkHandler concept"); + MONGO_STATIC_ASSERT_MSG( + IsNetworkHandler<Handler>::value, + "Handler passed to asyncSendMessage does not conform to NetworkHandler concept"); m->header().setResponseToMsgId(0); m->header().setId(nextMessageId()); // TODO: Some day we may need to support vector messages. @@ -89,7 +91,7 @@ template <typename Handler> void asyncRecvMessageHeader(AsyncStreamInterface& stream, MSGHEADER::Value* header, Handler&& handler) { - static_assert( + MONGO_STATIC_ASSERT_MSG( IsNetworkHandler<Handler>::value, "Handler passed to asyncRecvMessageHeader does not conform to NetworkHandler concept"); stream.read(asio::buffer(header->view().view2ptr(), sizeof(decltype(*header))), @@ -101,7 +103,7 @@ void asyncRecvMessageBody(AsyncStreamInterface& stream, MSGHEADER::Value* header, Message* m, Handler&& handler) { - static_assert( + MONGO_STATIC_ASSERT_MSG( IsNetworkHandler<Handler>::value, "Handler passed to asyncRecvMessageBody does not conform to NetworkHandler concept"); // validate message length diff --git a/src/mongo/logger/log_component.cpp b/src/mongo/logger/log_component.cpp index 8b8db2e2c54..1599a05aaad 100644 --- a/src/mongo/logger/log_component.cpp +++ b/src/mongo/logger/log_component.cpp @@ -29,8 +29,8 @@ #include "mongo/logger/log_component.h" - #include "mongo/base/init.h" +#include "mongo/base/static_assert.h" #include "mongo/util/assert_util.h" namespace mongo { @@ -61,11 +61,11 @@ MONGO_INITIALIZER_WITH_PREREQUISITES(SetupDottedNames, MONGO_NO_PREREQUISITES) // Children always come after parent component. // This makes it unnecessary to compute children of each component // when setting/clearing log severities in LogComponentSettings. -#define DECLARE_LOG_COMPONENT_PARENT(CHILD, PARENT) \ - case (CHILD): \ - do { \ - static_assert(int(CHILD) > int(PARENT), "int(CHILD) > int(PARENT)"); \ - return (PARENT); \ +#define DECLARE_LOG_COMPONENT_PARENT(CHILD, PARENT) \ + case (CHILD): \ + do { \ + MONGO_STATIC_ASSERT(int(CHILD) > int(PARENT)); \ + return (PARENT); \ } while (0) LogComponent LogComponent::parent() const { diff --git a/src/mongo/platform/atomic_proxy.h b/src/mongo/platform/atomic_proxy.h index ae7960cb930..7f1dcb2061a 100644 --- a/src/mongo/platform/atomic_proxy.h +++ b/src/mongo/platform/atomic_proxy.h @@ -33,6 +33,7 @@ #include <cstring> #include <type_traits> +#include "mongo/base/static_assert.h" #include "mongo/config.h" namespace mongo { @@ -43,10 +44,12 @@ namespace mongo { */ template <typename T, typename BaseWordT> class AtomicProxy { - static_assert(sizeof(T) == sizeof(BaseWordT), "T and BaseWordT must have the same size"); - static_assert(std::is_integral<BaseWordT>::value, "BaseWordT must be an integral type"); + MONGO_STATIC_ASSERT_MSG(sizeof(T) == sizeof(BaseWordT), + "T and BaseWordT must have the same size"); + MONGO_STATIC_ASSERT_MSG(std::is_integral<BaseWordT>::value, + "BaseWordT must be an integral type"); #if MONGO_HAVE_STD_IS_TRIVIALLY_COPYABLE - static_assert(std::is_trivially_copyable<T>::value, "T must be trivially copyable"); + MONGO_STATIC_ASSERT_MSG(std::is_trivially_copyable<T>::value, "T must be trivially copyable"); #endif public: using value_type = T; diff --git a/src/mongo/platform/atomic_word.h b/src/mongo/platform/atomic_word.h index f38763719a1..eb19496f0ba 100644 --- a/src/mongo/platform/atomic_word.h +++ b/src/mongo/platform/atomic_word.h @@ -30,6 +30,7 @@ #include <atomic> #include <type_traits> +#include "mongo/base/static_assert.h" namespace mongo { @@ -149,11 +150,11 @@ private: std::atomic<WordType> _value; // NOLINT }; -#define _ATOMIC_WORD_DECLARE(NAME, WTYPE) \ - typedef class AtomicWord<WTYPE> NAME; \ - namespace { \ - static_assert(sizeof(NAME) == sizeof(WTYPE), "sizeof(NAME) == sizeof(WTYPE)"); \ - static_assert(std::is_standard_layout<WTYPE>::value, "std::is_standard_layout<WTYPE>::value"); \ +#define _ATOMIC_WORD_DECLARE(NAME, WTYPE) \ + typedef class AtomicWord<WTYPE> NAME; \ + namespace { \ + MONGO_STATIC_ASSERT(sizeof(NAME) == sizeof(WTYPE)); \ + MONGO_STATIC_ASSERT(std::is_standard_layout<WTYPE>::value); \ } // namespace _ATOMIC_WORD_DECLARE(AtomicUInt32, unsigned); diff --git a/src/mongo/platform/decimal128.cpp b/src/mongo/platform/decimal128.cpp index 8d6dad6f7e4..d6a57fde649 100644 --- a/src/mongo/platform/decimal128.cpp +++ b/src/mongo/platform/decimal128.cpp @@ -44,6 +44,7 @@ #include <third_party/IntelRDFPMathLib20U1/LIBRARY/src/bid_functions.h> #undef _WCHAR_T +#include "mongo/base/static_assert.h" #include "mongo/config.h" #include "mongo/util/assert_util.h" #include "mongo/util/stringutils.h" @@ -841,8 +842,8 @@ const std::uint64_t t17hi32 = t17 >> 32; // t17hi32*t17hi32 + 2*t17hi32*t17lo32 + t17lo32*t17lo32 where the 2nd term // is shifted right by 32 and the 3rd term by 64 (which effectively drops the 3rd term) const std::uint64_t t34hi64 = t17hi32 * t17hi32 + (((t17hi32 * t17lo32) >> 31)); -static_assert(t34hi64 == 0x1ed09bead87c0, ""); -static_assert(t34lo64 == 0x378d8e63ffffffff, ""); +MONGO_STATIC_ASSERT(t34hi64 == 0x1ed09bead87c0); +MONGO_STATIC_ASSERT(t34lo64 == 0x378d8e63ffffffff); } // namespace // (t34hi64 << 64) + t34lo64 == 1e34 - 1 diff --git a/src/mongo/platform/endian.h b/src/mongo/platform/endian.h index faa6f686e29..f94586dc84a 100644 --- a/src/mongo/platform/endian.h +++ b/src/mongo/platform/endian.h @@ -32,6 +32,7 @@ #include <cstring> #include <type_traits> +#include "mongo/base/static_assert.h" #include "mongo/config.h" #include "mongo/platform/decimal128.h" @@ -340,7 +341,7 @@ struct ByteOrderConverter<float> { typedef float T; inline static T nativeToBig(T t) { - static_assert(sizeof(T) == sizeof(uint32_t), "sizeof(T) == sizeof(uint32_t)"); + MONGO_STATIC_ASSERT(sizeof(T) == sizeof(uint32_t)); uint32_t temp; std::memcpy(&temp, &t, sizeof(t)); @@ -379,7 +380,7 @@ struct ByteOrderConverter<double> { typedef double T; inline static T nativeToBig(T t) { - static_assert(sizeof(T) == sizeof(uint64_t), "sizeof(T) == sizeof(uint64_t)"); + MONGO_STATIC_ASSERT(sizeof(T) == sizeof(uint64_t)); uint64_t temp; std::memcpy(&temp, &t, sizeof(t)); @@ -452,32 +453,31 @@ struct IntegralTypeMap { template <> struct IntegralTypeMap<signed char> { - static_assert(CHAR_BIT == 8, "CHAR_BIT == 8"); + MONGO_STATIC_ASSERT(CHAR_BIT == 8); typedef int8_t type; }; template <> struct IntegralTypeMap<unsigned char> { - static_assert(CHAR_BIT == 8, "CHAR_BIT == 8"); + MONGO_STATIC_ASSERT(CHAR_BIT == 8); typedef uint8_t type; }; template <> struct IntegralTypeMap<char> { - static_assert(CHAR_BIT == 8, "CHAR_BIT == 8"); + MONGO_STATIC_ASSERT(CHAR_BIT == 8); typedef std::conditional<std::is_signed<char>::value, int8_t, uint8_t>::type type; }; template <> struct IntegralTypeMap<long long> { - static_assert(sizeof(long long) == sizeof(int64_t), "sizeof(long long) == sizeof(int64_t)"); + MONGO_STATIC_ASSERT(sizeof(long long) == sizeof(int64_t)); typedef int64_t type; }; template <> struct IntegralTypeMap<unsigned long long> { - static_assert(sizeof(unsigned long long) == sizeof(uint64_t), - "sizeof(unsigned long long) == sizeof(uint64_t)"); + MONGO_STATIC_ASSERT(sizeof(unsigned long long) == sizeof(uint64_t)); typedef uint64_t type; }; diff --git a/src/mongo/platform/process_id.cpp b/src/mongo/platform/process_id.cpp index 12bab6fbeab..d7b51bb064a 100644 --- a/src/mongo/platform/process_id.cpp +++ b/src/mongo/platform/process_id.cpp @@ -33,10 +33,11 @@ #include <limits> #include <sstream> +#include "mongo/base/static_assert.h" + namespace mongo { -static_assert(sizeof(NativeProcessId) == sizeof(uint32_t), - "sizeof(NativeProcessId) == sizeof(uint32_t)"); +MONGO_STATIC_ASSERT(sizeof(NativeProcessId) == sizeof(uint32_t)); namespace { #ifdef _WIN32 diff --git a/src/mongo/scripting/bson_template_evaluator.cpp b/src/mongo/scripting/bson_template_evaluator.cpp index 78df916a88e..e662b464270 100644 --- a/src/mongo/scripting/bson_template_evaluator.cpp +++ b/src/mongo/scripting/bson_template_evaluator.cpp @@ -31,6 +31,7 @@ #include <cstddef> #include <cstdlib> +#include "mongo/base/static_assert.h" #include "mongo/util/map_util.h" #include "mongo/util/mongoutils/str.h" @@ -269,7 +270,7 @@ BsonTemplateEvaluator::Status BsonTemplateEvaluator::evalRandString(BsonTemplate "abcdefghijklmnopqrstuvwxyz" "0123456789+/"; static const size_t alphaNumLength = sizeof(alphanum) - 1; - static_assert(alphaNumLength == 64, "alphaNumLength == 64"); + MONGO_STATIC_ASSERT(alphaNumLength == 64); uint32_t currentRand = 0; std::string str; for (int i = 0; i < length; ++i, currentRand >>= 6) { diff --git a/src/mongo/scripting/mozjs/exception.cpp b/src/mongo/scripting/mozjs/exception.cpp index dd67fc41379..81f84dcb4d5 100644 --- a/src/mongo/scripting/mozjs/exception.cpp +++ b/src/mongo/scripting/mozjs/exception.cpp @@ -33,6 +33,7 @@ #include <jsfriendapi.h> #include <limits> +#include "mongo/base/static_assert.h" #include "mongo/scripting/mozjs/implscope.h" #include "mongo/scripting/mozjs/jsstringwrapper.h" #include "mongo/scripting/mozjs/objectwrapper.h" @@ -54,8 +55,9 @@ const JSErrorFormatString* uncatchableErrorCallback(void* data, const unsigned c return &kUncatchableErrorFormatString; } -static_assert(UINT_MAX - JSErr_Limit > ErrorCodes::MaxError, - "Not enough space in an unsigned int for Mongo ErrorCodes and JSErrorNumbers"); +MONGO_STATIC_ASSERT_MSG( + UINT_MAX - JSErr_Limit > ErrorCodes::MaxError, + "Not enough space in an unsigned int for Mongo ErrorCodes and JSErrorNumbers"); } // namespace diff --git a/src/mongo/util/decoration_registry.h b/src/mongo/util/decoration_registry.h index 5d04925c3db..408d24e1a51 100644 --- a/src/mongo/util/decoration_registry.h +++ b/src/mongo/util/decoration_registry.h @@ -32,6 +32,7 @@ #include <vector> #include "mongo/base/disallow_copying.h" +#include "mongo/base/static_assert.h" #include "mongo/stdx/functional.h" #include "mongo/util/decoration_container.h" @@ -59,8 +60,8 @@ public: */ template <typename T> DecorationContainer::DecorationDescriptorWithType<T> declareDecoration() { - static_assert(std::is_nothrow_destructible<T>::value, - "Decorations must be nothrow destructible"); + MONGO_STATIC_ASSERT_MSG(std::is_nothrow_destructible<T>::value, + "Decorations must be nothrow destructible"); return DecorationContainer::DecorationDescriptorWithType<T>(std::move(declareDecoration( sizeof(T), std::alignment_of<T>::value, &constructAt<T>, &destructAt<T>))); } diff --git a/src/mongo/util/duration.h b/src/mongo/util/duration.h index 353cb1fca9f..a040dd38d64 100644 --- a/src/mongo/util/duration.h +++ b/src/mongo/util/duration.h @@ -32,6 +32,7 @@ #include <limits> #include <ratio> +#include "mongo/base/static_assert.h" #include "mongo/platform/overflow_arithmetic.h" #include "mongo/stdx/chrono.h" #include "mongo/stdx/type_traits.h" @@ -147,8 +148,8 @@ inline long long durationCount(const stdx::chrono::duration<RepIn, PeriodIn>& d) template <typename Period> class Duration { public: - static_assert(Period::num > 0, "Duration::period's numerator must be positive"); - static_assert(Period::den > 0, "Duration::period's denominator must be positive"); + MONGO_STATIC_ASSERT_MSG(Period::num > 0, "Duration::period's numerator must be positive"); + MONGO_STATIC_ASSERT_MSG(Period::den > 0, "Duration::period's denominator must be positive"); using rep = int64_t; using period = Period; @@ -160,9 +161,10 @@ public: template <typename OtherDuration> struct IsHigherPrecisionThan { using OtherOverThis = std::ratio_divide<typename OtherDuration::period, period>; - static_assert(OtherOverThis::den == 1 || OtherOverThis::num == 1, - "Mongo duration types are only compatible with each other when one's period " - "is an even multiple of the other's."); + MONGO_STATIC_ASSERT_MSG( + OtherOverThis::den == 1 || OtherOverThis::num == 1, + "Mongo duration types are only compatible with each other when one's period " + "is an even multiple of the other's."); static constexpr bool value = OtherOverThis::den == 1 && OtherOverThis::num != 1; }; @@ -173,9 +175,10 @@ public: template <typename OtherDuration> struct IsLowerPrecisionThan { using OtherOverThis = std::ratio_divide<typename OtherDuration::period, period>; - static_assert(OtherOverThis::den == 1 || OtherOverThis::num == 1, - "Mongo duration types are only compatible with each other when one's period " - "is an even multiple of the other's."); + MONGO_STATIC_ASSERT_MSG( + OtherOverThis::den == 1 || OtherOverThis::num == 1, + "Mongo duration types are only compatible with each other when one's period " + "is an even multiple of the other's."); static constexpr bool value = OtherOverThis::num == 1 && OtherOverThis::den != 1; }; @@ -220,9 +223,10 @@ public: stdx::enable_if_t<std::is_convertible<Rep2, rep>::value && std::is_integral<Rep2>::value, int> = 0> constexpr explicit Duration(const Rep2& r) : _count(r) { - static_assert(std::is_signed<Rep2>::value || sizeof(Rep2) < sizeof(rep), - "Durations must be constructed from values of integral type that are " - "representable as 64-bit signed integers"); + MONGO_STATIC_ASSERT_MSG( + std::is_signed<Rep2>::value || sizeof(Rep2) < sizeof(rep), + "Durations must be constructed from values of integral type that are " + "representable as 64-bit signed integers"); } /** @@ -236,9 +240,10 @@ public: template <typename FromPeriod> /*implicit*/ Duration(const Duration<FromPeriod>& from) : Duration(duration_cast<Duration>(from)) { - static_assert(!isLowerPrecisionThan<Duration<FromPeriod>>(), - "Use duration_cast to convert from higher precision Duration types to lower " - "precision ones"); + MONGO_STATIC_ASSERT_MSG( + !isLowerPrecisionThan<Duration<FromPeriod>>(), + "Use duration_cast to convert from higher precision Duration types to lower " + "precision ones"); } stdx::chrono::system_clock::duration toSystemDuration() const { @@ -337,8 +342,9 @@ public: template <typename Rep2> Duration& operator*=(const Rep2& scale) { - static_assert(std::is_integral<Rep2>::value && std::is_signed<Rep2>::value, - "Durations may only be multiplied by values of signed integral type"); + MONGO_STATIC_ASSERT_MSG( + std::is_integral<Rep2>::value && std::is_signed<Rep2>::value, + "Durations may only be multiplied by values of signed integral type"); uassert(ErrorCodes::DurationOverflow, str::stream() << "Overflow while multiplying " << *this << " by " << scale, !mongoSignedMultiplyOverflow64(count(), scale, &_count)); @@ -347,8 +353,8 @@ public: template <typename Rep2> Duration& operator/=(const Rep2& scale) { - static_assert(std::is_integral<Rep2>::value && std::is_signed<Rep2>::value, - "Durations may only be divided by values of signed integral type"); + MONGO_STATIC_ASSERT_MSG(std::is_integral<Rep2>::value && std::is_signed<Rep2>::value, + "Durations may only be divided by values of signed integral type"); uassert(ErrorCodes::DurationOverflow, str::stream() << "Overflow while dividing " << *this << " by -1", (count() != min().count() || scale != -1)); diff --git a/src/mongo/util/heap_profiler.cpp b/src/mongo/util/heap_profiler.cpp index aa012a6388e..c2410ef2734 100644 --- a/src/mongo/util/heap_profiler.cpp +++ b/src/mongo/util/heap_profiler.cpp @@ -31,6 +31,7 @@ #include "mongo/platform/basic.h" #include "mongo/base/init.h" +#include "mongo/base/static_assert.h" #include "mongo/config.h" #include "mongo/db/commands/server_status.h" #include "mongo/db/server_parameters.h" @@ -310,8 +311,8 @@ private: Hash hash() { Hash hash; - static_assert(sizeof(frames) == sizeof(FrameInfo) * kMaxFramesPerStack, - "frames array is not dense"); + MONGO_STATIC_ASSERT_MSG(sizeof(frames) == sizeof(FrameInfo) * kMaxFramesPerStack, + "frames array is not dense"); MurmurHash3_x86_32(frames.data(), numFrames * sizeof(FrameInfo), 0, &hash); return hash; } diff --git a/src/mongo/util/net/asio_message_port.cpp b/src/mongo/util/net/asio_message_port.cpp index d883a474ab0..19413c53435 100644 --- a/src/mongo/util/net/asio_message_port.cpp +++ b/src/mongo/util/net/asio_message_port.cpp @@ -35,6 +35,7 @@ #include <set> #include "mongo/base/init.h" +#include "mongo/base/static_assert.h" #include "mongo/config.h" #include "mongo/stdx/memory.h" #include "mongo/util/fail_point_service.h" @@ -350,8 +351,8 @@ bool ASIOMessagingPort::recv(Message& m) { } if (_awaitingHandshake) { - static_assert(sizeof(kGET) - 1 <= kHeaderLen, - "HTTP GET string must be smaller than the message header."); + MONGO_STATIC_ASSERT_MSG(sizeof(kGET) - 1 <= kHeaderLen, + "HTTP GET string must be smaller than the message header."); if (memcmp(md.view2ptr(), kGET, strlen(kGET)) == 0) { std::string httpMsg = "It looks like you are trying to access MongoDB over HTTP on the native driver " diff --git a/src/mongo/util/net/message.h b/src/mongo/util/net/message.h index 69501802238..e1277917b44 100644 --- a/src/mongo/util/net/message.h +++ b/src/mongo/util/net/message.h @@ -35,6 +35,7 @@ #include "mongo/base/data_view.h" #include "mongo/base/disallow_copying.h" #include "mongo/base/encoded_value_storage.h" +#include "mongo/base/static_assert.h" #include "mongo/platform/atomic_word.h" #include "mongo/util/allocator.h" #include "mongo/util/mongoutils/str.h" @@ -278,7 +279,7 @@ private: class Value : public EncodedValueStorage<Layout, ConstView, View> { public: Value() { - static_assert(sizeof(Value) == sizeof(Layout), "sizeof(Value) == sizeof(Layout)"); + MONGO_STATIC_ASSERT(sizeof(Value) == sizeof(Layout)); } Value(ZeroInitTag_t zit) : EncodedValueStorage<Layout, ConstView, View>(zit) {} @@ -394,7 +395,7 @@ private: class Value : public EncodedValueStorage<Layout, ConstView, View> { public: Value() { - static_assert(sizeof(Value) == sizeof(Layout), "sizeof(Value) == sizeof(Layout)"); + MONGO_STATIC_ASSERT(sizeof(Value) == sizeof(Layout)); } Value(ZeroInitTag_t zit) : EncodedValueStorage<Layout, ConstView, View>(zit) {} diff --git a/src/mongo/util/represent_as.h b/src/mongo/util/represent_as.h index 2bdb12ce06e..f85805adbee 100644 --- a/src/mongo/util/represent_as.h +++ b/src/mongo/util/represent_as.h @@ -34,6 +34,7 @@ #include <boost/optional.hpp> +#include "mongo/base/static_assert.h" #include "mongo/stdx/type_traits.h" namespace mongo { @@ -48,7 +49,7 @@ namespace detail { // Floating point numbers -> double template <typename T> typename stdx::enable_if_t<std::is_floating_point<T>::value, double> upconvert(T t) { - static_assert(sizeof(double) >= sizeof(T), "sizeof(double) >= sizeof(T)"); + MONGO_STATIC_ASSERT(sizeof(double) >= sizeof(T)); return static_cast<double>(t); } @@ -56,7 +57,7 @@ typename stdx::enable_if_t<std::is_floating_point<T>::value, double> upconvert(T template <typename T> typename stdx::enable_if_t<std::is_integral<T>::value && std::is_signed<T>::value, int64_t> upconvert(T t) { - static_assert(sizeof(int64_t) >= sizeof(T), "sizeof(int64_t) >= sizeof(T)"); + MONGO_STATIC_ASSERT(sizeof(int64_t) >= sizeof(T)); return static_cast<int64_t>(t); } @@ -64,7 +65,7 @@ upconvert(T t) { template <typename T> typename stdx::enable_if_t<std::is_integral<T>::value && !std::is_signed<T>::value, uint64_t> upconvert(T t) { - static_assert(sizeof(uint64_t) >= sizeof(T), "sizeof(uint64_t) >= sizeof(T)"); + MONGO_STATIC_ASSERT(sizeof(uint64_t) >= sizeof(T)); return static_cast<uint64_t>(t); } |