Modernization + AZStd::function compare fix. (#3680)

* Modernization + small fix.

Modernize ( `bool`/`override`/other) code in AzCore, AzFramework, AzQtComponents, AzToolsFramework, etc.
Replaced a `bind` or two, use `using` in a few places as well.

Fix nullptr comparison of AZStd::function.

Signed-off-by: nemerle <96597+nemerle@users.noreply.github.com>

* Apply review-based changes

Signed-off-by: nemerle <96597+nemerle@users.noreply.github.com>

Code/Framework/AzCore/AzCore/Asset/AssetCommon.cpp

@@ -456,7 +456,7 @@ namespace AZ
                 {
                     if (loadBehavior & (1 << thisFlag))
                     {
-                        returnFlags[thisFlag] = 1;
+                        returnFlags[thisFlag] = true;
                     }
                 }
                 return returnFlags;

Code/Framework/AzCore/AzCore/Asset/AssetManager.cpp

@@ -71,8 +71,8 @@ namespace AZ
             //////////////////////////////////////////////////////////////////////////
             // EBusTraits overrides
             static const AZ::EBusAddressPolicy AddressPolicy = AZ::EBusAddressPolicy::ById;
-            typedef AssetId                 BusIdType;
-            typedef AZStd::recursive_mutex  MutexType;
+            using BusIdType = AssetId;
+            using MutexType = AZStd::recursive_mutex;
 
             template <class Bus>
             struct AssetJobConnectionPolicy
@@ -107,7 +107,7 @@ namespace AZ
             virtual void OnLoadCanceled(AssetId assetId) = 0;
         };
 
-        typedef EBus<BlockingAssetLoadEvents> BlockingAssetLoadBus;
+        using BlockingAssetLoadBus = EBus<BlockingAssetLoadEvents>;
 
         /*
          * This class processes async AssetDatabase load jobs

Code/Framework/AzCore/AzCore/Component/ComponentApplication.cpp

@@ -644,7 +644,7 @@ namespace AZ
         NameDictionary::Create();
 
         // Call this and child class's reflects
-        ReflectionEnvironment::GetReflectionManager()->Reflect(azrtti_typeid(this), AZStd::bind(&ComponentApplication::Reflect, this, AZStd::placeholders::_1));
+        ReflectionEnvironment::GetReflectionManager()->Reflect(azrtti_typeid(this), [this](ReflectContext* context) {Reflect(context); });
 
         RegisterCoreComponents();
         TickBus::AllowFunctionQueuing(true);
@@ -970,7 +970,12 @@ namespace AZ
     {
         if (ReflectionEnvironment::GetReflectionManager())
         {
-            ReflectionEnvironment::GetReflectionManager()->Reflect(descriptor->GetUuid(), AZStd::bind(&ComponentDescriptor::Reflect, descriptor, AZStd::placeholders::_1));
+            ReflectionEnvironment::GetReflectionManager()->Reflect(
+                descriptor->GetUuid(),
+                [descriptor](ReflectContext* context)
+                {
+                    descriptor->Reflect(context);
+                });
         }
     }
 

Code/Framework/AzCore/AzCore/Compression/compression.cpp

@@ -23,8 +23,8 @@ using namespace AZ;
 // [3/21/2011]
 //=========================================================================
 ZLib::ZLib(IAllocator* workMemAllocator)
-    : m_strDeflate(NULL)
-    , m_strInflate(NULL)
+    : m_strDeflate(nullptr)
+    , m_strInflate(nullptr)
 {
     m_workMemoryAllocator = workMemAllocator ? workMemAllocator->GetAllocationSource() : nullptr;
     if (!m_workMemoryAllocator)
@@ -75,7 +75,7 @@ void ZLib::FreeMem(void* userData, void* address)
 //=========================================================================
 void ZLib::StartCompressor(unsigned int compressionLevel)
 {
-    AZ_Assert(m_strDeflate == NULL, "Compressor already started!");
+    AZ_Assert(m_strDeflate == nullptr, "Compressor already started!");
     m_strDeflate = reinterpret_cast< z_stream* >(AllocateMem(m_workMemoryAllocator, 1, sizeof(z_stream)));
     m_strDeflate->zalloc = &ZLib::AllocateMem;
     m_strDeflate->zfree = &ZLib::FreeMem;
@@ -91,10 +91,10 @@ void ZLib::StartCompressor(unsigned int compressionLevel)
 //=========================================================================
 void ZLib::StopCompressor()
 {
-    AZ_Assert(m_strDeflate != NULL, "Compressor not started!");
+    AZ_Assert(m_strDeflate != nullptr, "Compressor not started!");
     deflateEnd(m_strDeflate);
     FreeMem(m_workMemoryAllocator, m_strDeflate);
-    m_strDeflate = NULL;
+    m_strDeflate = nullptr;
 }
 
 //=========================================================================
@@ -103,7 +103,7 @@ void ZLib::StopCompressor()
 //=========================================================================
 void ZLib::ResetCompressor()
 {
-    AZ_Assert(m_strDeflate != NULL, "Compressor not started!");
+    AZ_Assert(m_strDeflate != nullptr, "Compressor not started!");
     int r = deflateReset(m_strDeflate);
     (void)r;
     AZ_Assert(r == Z_OK, "ZLib inconsistent state - deflateReset() failed !!!\n");
@@ -115,7 +115,7 @@ void ZLib::ResetCompressor()
 //=========================================================================
 unsigned int ZLib::Compress(const void* data, unsigned int& dataSize, void* compressedData, unsigned int compressedDataSize, FlushType flushType)
 {
-    AZ_Assert(m_strDeflate != NULL, "Compressor not started!");
+    AZ_Assert(m_strDeflate != nullptr, "Compressor not started!");
     m_strDeflate->avail_in = dataSize;
     m_strDeflate->next_in = (unsigned char*)data;
     m_strDeflate->avail_out = compressedDataSize;
@@ -158,7 +158,7 @@ unsigned int ZLib::Compress(const void* data, unsigned int& dataSize, void* comp
 //=========================================================================
 unsigned int ZLib::GetMinCompressedBufferSize(unsigned int sourceDataSize)
 {
-    AZ_Assert(m_strDeflate != NULL, "Compressor not started!");
+    AZ_Assert(m_strDeflate != nullptr, "Compressor not started!");
     return static_cast<unsigned int>(deflateBound(m_strDeflate, sourceDataSize));
 }
 
@@ -168,7 +168,7 @@ unsigned int ZLib::GetMinCompressedBufferSize(unsigned int sourceDataSize)
 //=========================================================================
 void ZLib::StartDecompressor(Header* header)
 {
-    AZ_Assert(m_strInflate == NULL, "Decompressor already started!");
+    AZ_Assert(m_strInflate == nullptr, "Decompressor already started!");
     m_strInflate = reinterpret_cast< z_stream* >(AllocateMem(m_workMemoryAllocator, 1, sizeof(z_stream)));
     m_strInflate->zalloc = &ZLib::AllocateMem;
     m_strInflate->zfree = &ZLib::FreeMem;
@@ -188,10 +188,10 @@ void ZLib::StartDecompressor(Header* header)
 //=========================================================================
 void ZLib::StopDecompressor()
 {
-    AZ_Assert(m_strInflate != NULL, "Decompressor not started!");
+    AZ_Assert(m_strInflate != nullptr, "Decompressor not started!");
     inflateEnd(m_strInflate);
     FreeMem(m_workMemoryAllocator, m_strInflate);
-    m_strInflate = NULL;
+    m_strInflate = nullptr;
 }
 
 //=========================================================================
@@ -200,7 +200,7 @@ void ZLib::StopDecompressor()
 //=========================================================================
 void ZLib::ResetDecompressor(Header* header)
 {
-    AZ_Assert(m_strInflate != NULL, "Decompressor not started!");
+    AZ_Assert(m_strInflate != nullptr, "Decompressor not started!");
     int r = inflateReset(m_strInflate);
     (void)r;
     AZ_Assert(r == Z_OK, "ZLib inconsistent state - inflateReset() failed !!!\n");
@@ -229,7 +229,7 @@ void ZLib::SetupDecompressHeader(Header header)
 //=========================================================================
 unsigned int ZLib::Decompress(const void* compressedData, unsigned int compressedDataSize, void* data, unsigned int& dataSize, FlushType flushType)
 {
-    AZ_Assert(m_strInflate != NULL, "Decompressor not started!");
+    AZ_Assert(m_strInflate != nullptr, "Decompressor not started!");
     m_strInflate->avail_in = compressedDataSize;
     m_strInflate->next_in = (unsigned char*)compressedData;
     m_strInflate->avail_out = dataSize;

Code/Framework/AzCore/AzCore/Debug/LocalFileEventLogger.cpp

@@ -242,7 +242,9 @@ namespace AZ::Debug
         ThreadData* threadData = threadStorage.m_data;
 
         // Set to nullptr so other threads doing a flush can't pick this up.
-        while (!threadStorage.m_data.compare_exchange_strong(threadData, nullptr));
+        while (!threadStorage.m_data.compare_exchange_strong(threadData, nullptr))
+        {
+        }
 
         uint32_t writeSize = AZ_SIZE_ALIGN_UP(sizeof(EventHeader) + size, EventBoundary);
         if (threadData->m_usedBytes + writeSize >= ThreadData::BufferSize)
@@ -270,7 +272,9 @@ namespace AZ::Debug
         // swap the pending data to commit the event
         ThreadStorage& threadStorage = GetThreadStorage();
         ThreadData* expectedData = nullptr;
-        while (!threadStorage.m_data.compare_exchange_strong(expectedData, threadStorage.m_pendingData));
+        while (!threadStorage.m_data.compare_exchange_strong(expectedData, threadStorage.m_pendingData))
+        {
+        }
         threadStorage.m_pendingData = nullptr;
     }
 

Code/Framework/AzCore/AzCore/Debug/Trace.cpp

@@ -218,7 +218,7 @@ namespace AZ
 
     void Debug::Trace::Crash()
     {
-        int* p = 0;
+        int* p = nullptr;
         *p = 1;
     }
 

Code/Framework/AzCore/AzCore/Debug/Trace.h

@@ -19,7 +19,7 @@ namespace AZ
         {
             void OutputToDebugger(const char* window, const char* message);
         }
-    
+
         /// Global instance to the tracer.
         extern class Trace      g_tracer;
 
@@ -41,7 +41,7 @@ namespace AZ
             static void Destroy();
             static int GetAssertVerbosityLevel();
             static void SetAssertVerbosityLevel(int level);
-            
+
             /**
             * Returns the default string used for a system window.
             * It can be useful for Trace message handlers to easily validate if the window they received is the fallback window used by this class,
@@ -109,7 +109,7 @@ namespace AZ
  * Correct usage:
  *     AZ_Assert(false, "Fail always");
  */
-    
+
     namespace AZ
     {
         namespace TraceInternal
@@ -121,7 +121,7 @@ namespace AZ
                 static constexpr ExpressionValidResult value = ExpressionValidResult::Valid;
             };
             template<>
-            struct ExpressionIsValid<const char*&> 
+            struct ExpressionIsValid<const char*&>
             {
                 static constexpr ExpressionValidResult value = ExpressionValidResult::Valid;
             };
@@ -228,7 +228,7 @@ namespace AZ
     {                                                                                                              \
         AZ::Debug::Trace::Instance().Printf(window, __VA_ARGS__);                                                  \
     }
-    
+
 
     //! The AZ_TrancePrintfOnce macro output the result of the format string only once for each use of the macro
     //! It does not take into account the result of the format string to determine whether to output the string or not

Code/Framework/AzCore/AzCore/Driller/Driller.cpp

@@ -208,7 +208,7 @@ namespace AZ
         {
             if (drillerList.empty())
             {
-                return NULL;
+                return nullptr;
             }
 
             m_sessions.push_back();
@@ -246,21 +246,21 @@ namespace AZ
                 AZStd::lock_guard<DrillerEBusMutex::MutexType> lock(DrillerEBusMutex::GetMutex());  ///< Make sure no driller is writing to the stream
                 for (DrillerListType::const_iterator iDriller = drillerList.begin(); iDriller != drillerList.end(); ++iDriller)
                 {
-                    Driller* driller = NULL;
+                    Driller* driller = nullptr;
                     const DrillerInfo& di = *iDriller;
                     for (size_t iDesc = 0; iDesc < m_drillers.size(); ++iDesc)
                     {
                         if (m_drillers[iDesc]->GetId() == di.id)
                         {
                             driller = m_drillers[iDesc];
-                            AZ_Assert(driller->m_output == NULL, "Driller with id %08x is already have an output stream %p (currently we support only 1 at a time)", di.id, driller->m_output);
+                            AZ_Assert(driller->m_output == nullptr, "Driller with id %08x is already have an output stream %p (currently we support only 1 at a time)", di.id, driller->m_output);
                             driller->m_output = &output;
                             driller->Start(di.params.data(), static_cast<unsigned int>(di.params.size()));
                             s.drillers.push_back(driller);
                             break;
                         }
                     }
-                    AZ_Warning("Driller", driller != NULL, "We can't start a driller with id %d!", di.id);
+                    AZ_Warning("Driller", driller != nullptr, "We can't start a driller with id %d!", di.id);
                 }
             }
             return &s;
@@ -293,7 +293,7 @@ namespace AZ
                     for (size_t i = 0; i < s.drillers.size(); ++i)
                     {
                         s.drillers[i]->Stop();
-                        s.drillers[i]->m_output = NULL;
+                        s.drillers[i]->m_output = nullptr;
                     }
                 }
                 s.output->EndTag(AZ_CRC("Frame", 0xb5f83ccd));

Code/Framework/AzCore/AzCore/Driller/Stream.cpp

@@ -677,7 +677,7 @@ namespace AZ
                         AZStd::endian_swap(crc32);
                     }
                     stringPtr = m_stringPool->Find(crc32);
-                    AZ_Assert(stringPtr != NULL, "Failed to find string with id 0x%08x in the string pool, proper stream read is impossible!", crc32);
+                    AZ_Assert(stringPtr != nullptr, "Failed to find string with id 0x%08x in the string pool, proper stream read is impossible!", crc32);
                     stringLength = static_cast<unsigned int>(strlen(stringPtr));
                 }
                 else if (m_isPooledString)
@@ -710,7 +710,7 @@ namespace AZ
         //=========================================================================
         const DrillerDOMParser::Node* DrillerDOMParser::Node::GetTag(u32 tagName) const
         {
-            const Node* tagNode = NULL;
+            const Node* tagNode = nullptr;
             for (Node::NodeListType::const_iterator i = m_tags.begin(); i != m_tags.end(); ++i)
             {
                 if ((*i).m_name == tagName)
@@ -728,7 +728,7 @@ namespace AZ
         //=========================================================================
         const DrillerDOMParser::Data* DrillerDOMParser::Node::GetData(u32 dataName) const
         {
-            const Data* dataNode = NULL;
+            const Data* dataNode = nullptr;
             for (Node::DataListType::const_iterator i = m_data.begin(); i != m_data.end(); ++i)
             {
                 if (i->m_name == dataName)
@@ -749,7 +749,7 @@ namespace AZ
             , m_isPersistentInputData(isPersistentInputData)
         {
             m_root.m_name = 0;
-            m_root.m_parent = NULL;
+            m_root.m_parent = nullptr;
             m_topNode = &m_root;
         }
         static int g_numFree = 0;
@@ -850,14 +850,14 @@ namespace AZ
                 return;
             }
 
-            DrillerHandlerParser* childHandler = NULL;
+            DrillerHandlerParser* childHandler = nullptr;
             DrillerHandlerParser* currentHandler = m_stack.back();
             if (isOpen)
             {
-                if (currentHandler != NULL)
+                if (currentHandler != nullptr)
                 {
                     childHandler = currentHandler->OnEnterTag(name);
-                    AZ_Warning("Driller", !currentHandler->IsWarnOnUnsupportedTags() || childHandler != NULL, "Could not find handler for tag 0x%08x", name);
+                    AZ_Warning("Driller", !currentHandler->IsWarnOnUnsupportedTags() || childHandler != nullptr, "Could not find handler for tag 0x%08x", name);
                 }
                 m_stack.push_back(childHandler);
             }

Code/Framework/AzCore/AzCore/IO/CompressorZLib.cpp

@@ -22,10 +22,10 @@ namespace AZ
         // [12/13/2012]
         //=========================================================================
         CompressorZLib::CompressorZLib(unsigned int decompressionCachePerStream, unsigned int dataBufferSize)
-            : m_lastReadStream(NULL)
+            : m_lastReadStream(nullptr)
             , m_lastReadStreamOffset(0)
             , m_lastReadStreamSize(0)
-            , m_compressedDataBuffer(NULL)
+            , m_compressedDataBuffer(nullptr)
             , m_compressedDataBufferSize(dataBufferSize)
             , m_compressedDataBufferUseCount(0)
             , m_decompressionCachePerStream(decompressionCachePerStream)
@@ -63,7 +63,7 @@ namespace AZ
         //=========================================================================
         bool        CompressorZLib::ReadHeaderAndData(CompressorStream* stream, AZ::u8* data, unsigned int dataSize)
         {
-            if (stream->GetCompressorData() != NULL)  // we already have compressor data
+            if (stream->GetCompressorData() != nullptr)  // we already have compressor data
             {
                 return false;
             }
@@ -347,7 +347,7 @@ namespace AZ
             AZ_Assert(stream && stream->GetCompressorData(), "This stream doesn't have compression enabled! Call Stream::WriteCompressed after you create the file!");
             AZ_Assert(offset == SizeType(-1) || offset == stream->GetCurPos(), "We can write compressed data only at the end of the stream!");
 
-            m_lastReadStream = NULL; // invalidate last read position, otherwise m_dataBuffer will be corrupted (as we are about to write in it).
+            m_lastReadStream = nullptr; // invalidate last read position, otherwise m_dataBuffer will be corrupted (as we are about to write in it).
 
             CompressorZLibData* zlibData = static_cast<CompressorZLibData*>(stream->GetCompressorData());
             AZ_Assert(!zlibData->m_zlib.IsDecompressorStarted(), "You can't write while reading/decompressing a compressed stream!");
@@ -398,13 +398,13 @@ namespace AZ
             AZ_Assert(stream && stream->GetCompressorData(), "This stream doesn't have compression enabled! Call Stream::WriteCompressed after you create the file!");
             CompressorZLibData* zlibData = static_cast<CompressorZLibData*>(stream->GetCompressorData());
 
-            m_lastReadStream = NULL; // invalidate last read position, otherwise m_dataBuffer will be corrupted (as we are about to write in it).
+            m_lastReadStream = nullptr; // invalidate last read position, otherwise m_dataBuffer will be corrupted (as we are about to write in it).
 
             unsigned int compressedSize;
             unsigned int dataToCompress = 0;
             do
             {
-                compressedSize = zlibData->m_zlib.Compress(NULL, dataToCompress, m_compressedDataBuffer, m_compressedDataBufferSize, ZLib::FT_FULL_FLUSH);
+                compressedSize = zlibData->m_zlib.Compress(nullptr, dataToCompress, m_compressedDataBuffer, m_compressedDataBufferSize, ZLib::FT_FULL_FLUSH);
                 if (compressedSize)
                 {
                     GenericStream* baseStream = stream->GetWrappedStream();
@@ -429,7 +429,7 @@ namespace AZ
         //=========================================================================
         bool        CompressorZLib::StartCompressor(CompressorStream* stream, int compressionLevel, SizeType autoSeekDataSize)
         {
-            AZ_Assert(stream && stream->GetCompressorData() == NULL, "Stream has compressor already enabled!");
+            AZ_Assert(stream && stream->GetCompressorData() == nullptr, "Stream has compressor already enabled!");
 
             AcquireDataBuffer();
 
@@ -470,14 +470,14 @@ namespace AZ
             bool result = true;
             if (zlibData->m_zlib.IsCompressorStarted())
             {
-                m_lastReadStream = NULL; // invalidate last read position, otherwise m_dataBuffer will be corrupted (as we are about to write in it).
+                m_lastReadStream = nullptr; // invalidate last read position, otherwise m_dataBuffer will be corrupted (as we are about to write in it).
 
                 // flush all compressed data
                 unsigned int compressedSize;
                 unsigned int dataToCompress = 0;
                 do
                 {
-                    compressedSize = zlibData->m_zlib.Compress(NULL, dataToCompress, m_compressedDataBuffer, m_compressedDataBufferSize, ZLib::FT_FINISH);
+                    compressedSize = zlibData->m_zlib.Compress(nullptr, dataToCompress, m_compressedDataBuffer, m_compressedDataBufferSize, ZLib::FT_FINISH);
                     if (compressedSize)
                     {
                         baseStream->Write(compressedSize, m_compressedDataBuffer);
@@ -502,7 +502,7 @@ namespace AZ
             {
                 if (m_lastReadStream == stream)
                 {
-                    m_lastReadStream = NULL; // invalidate the data in m_dataBuffer if it was from the current stream.
+                    m_lastReadStream = nullptr; // invalidate the data in m_dataBuffer if it was from the current stream.
                 }
             }
 
@@ -525,11 +525,11 @@ namespace AZ
         //=========================================================================
         void CompressorZLib::AcquireDataBuffer()
         {
-            if (m_compressedDataBuffer == NULL)
+            if (m_compressedDataBuffer == nullptr)
             {
                 AZ_Assert(m_compressedDataBufferUseCount == 0, "Buffer usecount should be 0 if the buffer is NULL");
                 m_compressedDataBuffer = reinterpret_cast<unsigned char*>(azmalloc(m_compressedDataBufferSize, m_CompressedDataBufferAlignment, AZ::SystemAllocator, "CompressorZLib"));
-                m_lastReadStream = NULL; // reset the cache info in the m_dataBuffer
+                m_lastReadStream = nullptr; // reset the cache info in the m_dataBuffer
             }
             ++m_compressedDataBufferUseCount;
         }
@@ -543,10 +543,10 @@ namespace AZ
             --m_compressedDataBufferUseCount;
             if (m_compressedDataBufferUseCount == 0)
             {
-                AZ_Assert(m_compressedDataBuffer != NULL, "Invalid data buffer! We should have a non null pointer!");
+                AZ_Assert(m_compressedDataBuffer != nullptr, "Invalid data buffer! We should have a non null pointer!");
                 azfree(m_compressedDataBuffer, AZ::SystemAllocator, m_compressedDataBufferSize, m_CompressedDataBufferAlignment);
-                m_compressedDataBuffer = NULL;
-                m_lastReadStream = NULL; // reset the cache info in the m_dataBuffer
+                m_compressedDataBuffer = nullptr;
+                m_lastReadStream = nullptr; // reset the cache info in the m_dataBuffer
             }
         }
     }   // namespace IO

Code/Framework/AzCore/AzCore/IO/SystemFile.cpp

@@ -127,7 +127,7 @@ bool SystemFile::Open(const char* fileName, int mode, int platformFlags)
 bool SystemFile::ReOpen(int mode, int platformFlags)
 {
     AZ_Assert(!m_fileName.empty(), "Missing filename. You must call open first!");
-    return Open(0, mode, platformFlags);
+    return Open(nullptr, mode, platformFlags);
 }
 
 void SystemFile::Close()

Code/Framework/AzCore/AzCore/IPC/SharedMemory.cpp

@@ -125,7 +125,7 @@ SharedMemory::Close()
 bool
 SharedMemory::Map(AccessMode mode, unsigned int size)
 {
-    AZ_Assert(m_mappedBase == NULL, "We already have data mapped");
+    AZ_Assert(m_mappedBase == nullptr, "We already have data mapped");
     AZ_Assert(Platform::IsMapHandleValid(), "You must call Map() first!");
 
     bool result = Platform::Map(mode, size);
@@ -232,7 +232,7 @@ bool SharedMemory::CheckMappedBaseValid()
 // [4/29/2011]
 //=========================================================================
 SharedMemoryRingBuffer::SharedMemoryRingBuffer()
-    : m_info(NULL)
+    : m_info(nullptr)
 {}
 
 //=========================================================================
@@ -279,7 +279,7 @@ SharedMemoryRingBuffer::Map(AccessMode mode, unsigned int size)
 bool
 SharedMemoryRingBuffer::UnMap()
 {
-    m_info = NULL;
+    m_info = nullptr;
     return SharedMemory::UnMap();
 }
 
@@ -291,7 +291,7 @@ bool
 SharedMemoryRingBuffer::Write(const void* data, unsigned int dataSize)
 {
     AZ_Warning("AZSystem", !Platform::IsWaitFailed(), "You are writing the ring buffer %s while the Global lock is NOT locked! This can lead to data corruption!", m_name);
-    AZ_Assert(m_info != NULL, "You need to Create and Map the buffer first!");
+    AZ_Assert(m_info != nullptr, "You need to Create and Map the buffer first!");
     if (m_info->m_writeOffset >= m_info->m_readOffset)
     {
         unsigned int freeSpace = m_dataSize - (m_info->m_writeOffset - m_info->m_readOffset);
@@ -346,7 +346,7 @@ SharedMemoryRingBuffer::Read(void* data, unsigned int maxDataSize)
         return 0;
     }
 
-    AZ_Assert(m_info != NULL, "You need to Create and Map the buffer first!");
+    AZ_Assert(m_info != nullptr, "You need to Create and Map the buffer first!");
     unsigned int dataRead;
     if (m_info->m_writeOffset > m_info->m_readOffset)
     {

Code/Framework/AzCore/AzCore/Jobs/Internal/JobManagerWorkStealing.cpp

@@ -192,15 +192,15 @@ void JobManagerWorkStealing::SuspendJobUntilReady(Job* job)
     ThreadInfo* info = GetCurrentOrCreateThreadInfo();
     AZ_Assert(info->m_currentJob == job, ("Can't suspend a job which isn't currently running"));
 
-    info->m_currentJob = NULL; //clear current job
+    info->m_currentJob = nullptr; //clear current job
 
     if (IsAsynchronous())
     {
-        ProcessJobsAssist(info, job, NULL);
+        ProcessJobsAssist(info, job, nullptr);
     }
     else
     {
-        ProcessJobsSynchronous(info, job, NULL);
+        ProcessJobsSynchronous(info, job, nullptr);
     }
 
     info->m_currentJob = job; //restore current job
@@ -223,11 +223,11 @@ void JobManagerWorkStealing::StartJobAndAssistUntilComplete(Job* job)
     //the processing functions will return when the empty job dependent count has reached 1
     if (IsAsynchronous())
     {
-        ProcessJobsAssist(info, NULL, &notifyFlag);
+        ProcessJobsAssist(info, nullptr, &notifyFlag);
     }
     else
     {
-        ProcessJobsSynchronous(info, NULL, &notifyFlag);
+        ProcessJobsSynchronous(info, nullptr, &notifyFlag);
     }
 
     AZ_Assert(!m_currentThreadInfo, "");
@@ -306,9 +306,9 @@ void JobManagerWorkStealing::ProcessJobsWorker(ThreadInfo* info)
     //setup thread-local storage
     m_currentThreadInfo = info;
 
-    ProcessJobsInternal(info, NULL, NULL);
+    ProcessJobsInternal(info, nullptr, nullptr);
 
-    m_currentThreadInfo = NULL;
+    m_currentThreadInfo = nullptr;
 }
 
 void JobManagerWorkStealing::ProcessJobsAssist(ThreadInfo* info, Job* suspendedJob, AZStd::atomic<bool>* notifyFlag)
@@ -529,7 +529,7 @@ void JobManagerWorkStealing::ProcessJobsSynchronous(ThreadInfo* info, Job* suspe
 
         info->m_currentJob = job;
         Process(job);
-        info->m_currentJob = NULL;
+        info->m_currentJob = nullptr;
 
         //...after calling Process we cannot use the job pointer again, the job has completed and may not exist anymore
 #ifdef JOBMANAGER_ENABLE_STATS

Code/Framework/AzCore/AzCore/Jobs/Job.cpp

@@ -36,7 +36,7 @@ namespace AZ
         }
         countAndFlags |= (unsigned int)((priority << FLAG_PRIORITY_START_BIT) & FLAG_PRIORITY_MASK);
         SetDependentCountAndFlags(countAndFlags);
-        StoreDependent(NULL);
+        StoreDependent(nullptr);
 
     #ifdef AZ_DEBUG_JOB_STATE
         SetState(STATE_SETUP);
@@ -66,7 +66,7 @@ namespace AZ
         SetDependentCountAndFlags(countAndFlags);
         if (isClearDependent)
         {
-            StoreDependent(NULL);
+            StoreDependent(nullptr);
         }
         else
         {

Code/Framework/AzCore/AzCore/Math/Uuid.cpp

@@ -56,7 +56,7 @@ namespace AZ
 
     Uuid Uuid::CreateStringSkipWarnings(const char* string, size_t stringLength, [[maybe_unused]] bool skipWarnings)
     {
-        if (string == NULL)
+        if (string == nullptr)
         {
             return Uuid::CreateNull();
         }
@@ -71,7 +71,7 @@ namespace AZ
 
         if (len < 32 || len > 38)
         {
-            AZ_Warning("Math", skipWarnings, "Invalid UUID format %s (must be) {xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx} (or without dashes and braces)", string != NULL ? string : "null");
+            AZ_Warning("Math", skipWarnings, "Invalid UUID format %s (must be) {xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx} (or without dashes and braces)", string != nullptr ? string : "null");
             return Uuid::CreateNull();
         }
 

Code/Framework/AzCore/AzCore/Memory/AllocationRecords.cpp

@@ -169,7 +169,7 @@ AllocationRecords::RegisterAllocation(void* address, size_t byteSize, size_t ali
     ai.m_timeStamp = AZStd::GetTimeNowMicroSecond();
 
     // if we don't have a fileName,lineNum record the stack or if the user requested it.
-    if ((fileName == 0 && m_mode == RECORD_STACK_IF_NO_FILE_LINE) || m_mode == RECORD_FULL)
+    if ((fileName == nullptr && m_mode == RECORD_STACK_IF_NO_FILE_LINE) || m_mode == RECORD_FULL)
     {
         ai.m_stackFrames = m_numStackLevels ? reinterpret_cast<AZ::Debug::StackFrame*>(m_records.get_allocator().allocate(sizeof(AZ::Debug::StackFrame)*m_numStackLevels, 1)) : nullptr;
         if (ai.m_stackFrames)

Code/Framework/AzCore/AzCore/Memory/AllocatorManager.cpp

@@ -39,9 +39,9 @@ namespace AZ
                 return AZStd::hash<AZStd::string_view>{}(key);
             }
         };
-        typedef AZStd::basic_string<char, AZStd::char_traits<char>, AZStdIAllocator> AMString;
-        typedef AZStd::unordered_map<AMString, IAllocator*, AMStringHasher, AZStd::equal_to<>, AZStdIAllocator> AllocatorNameMap;
-        typedef AZStd::unordered_map<AMString, AMString, AMStringHasher, AZStd::equal_to<>, AZStdIAllocator> AllocatorRemappings;
+        using AMString = AZStd::basic_string<char, AZStd::char_traits<char>, AZStdIAllocator>;
+        using AllocatorNameMap = AZStd::unordered_map<AMString, IAllocator*, AMStringHasher, AZStd::equal_to<>, AZStdIAllocator>;
+        using AllocatorRemappings = AZStd::unordered_map<AMString, AMString, AMStringHasher, AZStd::equal_to<>, AZStdIAllocator>;
 
         // For allocators that are created before we have an environment, we keep some module-local data for them so that we can register them 
         // properly once the environment is attached.
@@ -403,7 +403,7 @@ AllocatorManager::AddOutOfMemoryListener(const OutOfMemoryCBType& cb)
 void
 AllocatorManager::RemoveOutOfMemoryListener()
 {
-    m_outOfMemoryListener = 0;
+    m_outOfMemoryListener = nullptr;
 }
 
 //=========================================================================
@@ -660,13 +660,13 @@ void AllocatorManager::GetAllocatorStats(size_t& allocatedBytes, size_t& capacit
 //=========================================================================
 AllocatorManager::MemoryBreak::MemoryBreak()
 {
-    addressStart = NULL;
-    addressEnd = NULL;
+    addressStart = nullptr;
+    addressEnd = nullptr;
     byteSize = 0;
     alignment = static_cast<size_t>(0xffffffff);
-    name = NULL;
+    name = nullptr;
 
-    fileName = NULL;
+    fileName = nullptr;
     lineNum = -1;
 }
 
@@ -729,14 +729,14 @@ AllocatorManager::DebugBreak(void* address, const Debug::AllocationInfo& info)
 
                 AZ_Assert(!(m_memoryBreak[i].alignment == info.m_alignment), "User triggered breakpoint - alignment (%d)", info.m_alignment);
                 AZ_Assert(!(m_memoryBreak[i].byteSize == info.m_byteSize), "User triggered breakpoint - allocation size (%d)", info.m_byteSize);
-                AZ_Assert(!(info.m_name != NULL && m_memoryBreak[i].name != NULL && strcmp(m_memoryBreak[i].name, info.m_name) == 0), "User triggered breakpoint - name \"%s\"", info.m_name);
+                AZ_Assert(!(info.m_name != nullptr && m_memoryBreak[i].name != nullptr && strcmp(m_memoryBreak[i].name, info.m_name) == 0), "User triggered breakpoint - name \"%s\"", info.m_name);
                 if (m_memoryBreak[i].lineNum != 0)
                 {
-                    AZ_Assert(!(info.m_fileName != NULL && m_memoryBreak[i].fileName != NULL && strcmp(m_memoryBreak[i].fileName, info.m_fileName) == 0 && m_memoryBreak[i].lineNum == info.m_lineNum), "User triggered breakpoint - file/line number : %s(%d)", info.m_fileName, info.m_lineNum);
+                    AZ_Assert(!(info.m_fileName != nullptr && m_memoryBreak[i].fileName != nullptr && strcmp(m_memoryBreak[i].fileName, info.m_fileName) == 0 && m_memoryBreak[i].lineNum == info.m_lineNum), "User triggered breakpoint - file/line number : %s(%d)", info.m_fileName, info.m_lineNum);
                 }
                 else
                 {
-                    AZ_Assert(!(info.m_fileName != NULL && m_memoryBreak[i].fileName != NULL && strcmp(m_memoryBreak[i].fileName, info.m_fileName) == 0), "User triggered breakpoint - file name \"%s\"", info.m_fileName);
+                    AZ_Assert(!(info.m_fileName != nullptr && m_memoryBreak[i].fileName != nullptr && strcmp(m_memoryBreak[i].fileName, info.m_fileName) == 0), "User triggered breakpoint - file name \"%s\"", info.m_fileName);
                 }
             }
         }

Code/Framework/AzCore/AzCore/Memory/BestFitExternalMapAllocator.cpp

@@ -22,7 +22,7 @@ using namespace AZ;
 //=========================================================================
 BestFitExternalMapAllocator::BestFitExternalMapAllocator()
     : AllocatorBase(this, "BestFitExternalMapAllocator", "Best fit allocator with external tracking storage!")
-    , m_schema(NULL)
+    , m_schema(nullptr)
 {}
 
 //=========================================================================
@@ -47,7 +47,7 @@ BestFitExternalMapAllocator::Create(const Descriptor& desc)
     schemaDesc.m_memoryBlockByteSize = desc.m_memoryBlockByteSize;
 
     m_schema = azcreate(BestFitExternalMapSchema, (schemaDesc), SystemAllocator);
-    if (m_schema == NULL)
+    if (m_schema == nullptr)
     {
         isReady = false;
     }
@@ -63,7 +63,7 @@ void
 BestFitExternalMapAllocator::Destroy()
 {
     azdestroy(m_schema, SystemAllocator);
-    m_schema = NULL;
+    m_schema = nullptr;
 }
 
 AllocatorDebugConfig BestFitExternalMapAllocator::GetDebugConfig()
@@ -89,7 +89,7 @@ BestFitExternalMapAllocator::Allocate(size_type byteSize, size_type alignment, i
     byteSize = MemorySizeAdjustedUp(byteSize);
 
     BestFitExternalMapAllocator::pointer_type address = m_schema->Allocate(byteSize, alignment, flags);
-    if (address == 0)
+    if (address == nullptr)
     {
         if (!OnOutOfMemory(byteSize, alignment, flags, name, fileName, lineNum))
         {
@@ -100,7 +100,7 @@ BestFitExternalMapAllocator::Allocate(size_type byteSize, size_type alignment, i
         }
     }
 
-    AZ_Assert(address != 0, "BestFitExternalMapAllocator: Failed to allocate %d bytes aligned on %d (flags: 0x%08x) %s : %s (%d)!", byteSize, alignment, flags, name ? name : "(no name)", fileName ? fileName : "(no file name)", lineNum);
+    AZ_Assert(address != nullptr, "BestFitExternalMapAllocator: Failed to allocate %d bytes aligned on %d (flags: 0x%08x) %s : %s (%d)!", byteSize, alignment, flags, name ? name : "(no name)", fileName ? fileName : "(no file name)", lineNum);
     AZ_MEMORY_PROFILE(ProfileAllocation(address, byteSize, alignment, name, fileName, lineNum, suppressStackRecord + 1));
 
     return address;
@@ -145,7 +145,7 @@ BestFitExternalMapAllocator::ReAllocate(pointer_type ptr, size_type newSize, siz
     (void)newSize;
     (void)newAlignment;
     AZ_Assert(false, "Not supported!");
-    return NULL;
+    return nullptr;
 }
 
 //=========================================================================

Code/Framework/AzCore/AzCore/Memory/BestFitExternalMapSchema.cpp

@@ -18,15 +18,15 @@ using namespace AZ;
 BestFitExternalMapSchema::BestFitExternalMapSchema(const Descriptor& desc)
     : m_desc(desc)
     , m_used(0)
-    , m_freeChunksMap(FreeMapType::key_compare(), AZStdIAllocator(desc.m_mapAllocator != NULL ? desc.m_mapAllocator : &AllocatorInstance<SystemAllocator>::Get()))
-    , m_allocChunksMap(AllocMapType::hasher(), AllocMapType::key_eq(), AZStdIAllocator(desc.m_mapAllocator != NULL ? desc.m_mapAllocator : &AllocatorInstance<SystemAllocator>::Get()))
+    , m_freeChunksMap(FreeMapType::key_compare(), AZStdIAllocator(desc.m_mapAllocator != nullptr ? desc.m_mapAllocator : &AllocatorInstance<SystemAllocator>::Get()))
+    , m_allocChunksMap(AllocMapType::hasher(), AllocMapType::key_eq(), AZStdIAllocator(desc.m_mapAllocator != nullptr ? desc.m_mapAllocator : &AllocatorInstance<SystemAllocator>::Get()))
 {
-    if (m_desc.m_mapAllocator == NULL)
+    if (m_desc.m_mapAllocator == nullptr)
     {
         m_desc.m_mapAllocator = &AllocatorInstance<SystemAllocator>::Get(); // used as our sub allocator
     }
     AZ_Assert(m_desc.m_memoryBlockByteSize > 0, "You must provide memory block size!");
-    AZ_Assert(m_desc.m_memoryBlock != NULL, "You must provide memory block allocated as you with!");
+    AZ_Assert(m_desc.m_memoryBlock != nullptr, "You must provide memory block allocated as you with!");
     //if( m_desc.m_memoryBlock == NULL) there is no point to automate this cause we need to flag this memory special, otherwise there is no point to use this allocator at all
     //  m_desc.m_memoryBlock = azmalloc(SystemAllocator,m_desc.m_memoryBlockByteSize,16);
     m_freeChunksMap.insert(AZStd::make_pair(m_desc.m_memoryBlockByteSize, reinterpret_cast<char*>(m_desc.m_memoryBlock)));
@@ -40,13 +40,13 @@ BestFitExternalMapSchema::pointer_type
 BestFitExternalMapSchema::Allocate(size_type byteSize, size_type alignment, int flags)
 {
     (void)flags;
-    char* address = NULL;
+    char* address = nullptr;
     AZ_Assert(alignment > 0 && (alignment & (alignment - 1)) == 0, "Alignment must be >0 and power of 2!");
     for (int i = 0; i < 2; ++i) // max 2 attempts to allocate
     {
         FreeMapType::iterator iter = m_freeChunksMap.find(byteSize);
         size_t  blockSize = 0;
-        char*   blockAddress = NULL;
+        char*   blockAddress = nullptr;
         size_t  preAllocBlockSize = 0;
         while (iter != m_freeChunksMap.end())
         {
@@ -64,7 +64,7 @@ BestFitExternalMapSchema::Allocate(size_type byteSize, size_type alignment, int
             }
             ++iter;
         }
-        if (address != NULL)
+        if (address != nullptr)
         {
             // split blocks
             if (preAllocBlockSize)  // if we have a block before the alignment
@@ -94,7 +94,7 @@ BestFitExternalMapSchema::Allocate(size_type byteSize, size_type alignment, int
 void
 BestFitExternalMapSchema::DeAllocate(pointer_type ptr)
 {
-    if (ptr == 0)
+    if (ptr == nullptr)
     {
         return;
     }

Code/Framework/AzCore/AzCore/Memory/HeapSchema.cpp

@@ -107,17 +107,17 @@ namespace AZ
         m_used = 0;
 
         m_desc = desc;
-        m_subAllocator = 0;
+        m_subAllocator = nullptr;
 
         for (int i = 0; i < Descriptor::m_maxNumBlocks; ++i)
         {
-            m_memSpaces[i] = 0;
+            m_memSpaces[i] = nullptr;
             m_ownMemoryBlock[i] = false;
         }
 
         for (int i = 0; i < m_desc.m_numMemoryBlocks; ++i)
         {
-            if (m_desc.m_memoryBlocks[i] == 0)  // Allocate memory block if requested!
+            if (m_desc.m_memoryBlocks[i] == nullptr)  // Allocate memory block if requested!
             {
                 AZ_Assert(AllocatorInstance<SystemAllocator>::IsReady(), "You requested to allocate memory using the system allocator, but it's not created yet!");
                 m_subAllocator = &AllocatorInstance<SystemAllocator>::Get();
@@ -152,7 +152,7 @@ namespace AZ
             if (m_memSpaces[i])
             {
                 AZDLMalloc::destroy_mspace(m_memSpaces[i]);
-                m_memSpaces[i] = 0;
+                m_memSpaces[i] = nullptr;
 
                 if (m_ownMemoryBlock[i])
                 {
@@ -172,7 +172,7 @@ namespace AZ
         AZ_UNUSED(lineNum);
         AZ_UNUSED(suppressStackRecord);
         int blockId = flags;
-        AZ_Assert(m_memSpaces[blockId]!=0, "Invalid block id!");
+        AZ_Assert(m_memSpaces[blockId]!=nullptr, "Invalid block id!");
         HeapSchema::pointer_type address = AZDLMalloc::mspace_memalign(m_memSpaces[blockId], alignment, byteSize);
         if (address)
         {
@@ -186,7 +186,7 @@ namespace AZ
     {
         AZ_UNUSED(byteSize);
         AZ_UNUSED(alignment);
-        if (ptr==0)
+        if (ptr==nullptr)
         {
             return;
         }
@@ -194,7 +194,7 @@ namespace AZ
         // if we use m_spaces just count the chunk sizes.
         m_used -= ChunckSize(ptr);
 #ifdef FOOTERS
-        AZDLMalloc::mspace_free(0, ptr);                        ///< We use footers so we know which memspace the pointer belongs to.
+        AZDLMalloc::mspace_free(nullptr, ptr);                        ///< We use footers so we know which memspace the pointer belongs to.
 #else
         int i = 0;
         for (; i < m_desc.m_numMemoryBlocks; ++i)
@@ -248,7 +248,7 @@ namespace AZ
     HeapSchema::ChunckSize(pointer_type ptr)
     {
         // based on azmalloc_usable_size + the overhead
-        if (ptr != 0)
+        if (ptr != nullptr)
         {
             mchunkptr p = mem2chunk(ptr);
             //if (is_inuse(p))  // we can even skip this check since we track for double free and so on anyway

Code/Framework/AzCore/AzCore/Memory/HphaSchema.cpp

@@ -784,17 +784,17 @@ namespace AZ {
         // size == 0 acts as free
         void* realloc(void* ptr, size_t size)
         {
-            if (ptr == NULL)
+            if (ptr == nullptr)
             {
                 return alloc(size);
             }
             if (size == 0)
             {
                 free(ptr);
-                return NULL;
+                return nullptr;
             }
             debug_check(ptr);
-            void* newPtr = NULL;
+            void* newPtr = nullptr;
             if (ptr_in_bucket(ptr))
             {
                 if (is_small_allocation(size)) // no point to check m_isPoolAllocations as if it's false pointer can't be in a bucket.
@@ -853,21 +853,21 @@ namespace AZ {
             {
                 return realloc(ptr, size);
             }
-            if (ptr == NULL)
+            if (ptr == nullptr)
             {
                 return alloc(size, alignment);
             }
             if (size == 0)
             {
                 free(ptr);
-                return NULL;
+                return nullptr;
             }
             if ((size_t)ptr & (alignment - 1))
             {
                 void* newPtr = alloc(size, alignment);
                 if (!newPtr)
                 {
-                    return NULL;
+                    return nullptr;
                 }
                 size_t count = this->size(ptr);
                 if (count > size)
@@ -879,7 +879,7 @@ namespace AZ {
                 return newPtr;
             }
             debug_check(ptr);
-            void* newPtr = NULL;
+            void* newPtr = nullptr;
             if (ptr_in_bucket(ptr))
             {
                 if (is_small_allocation(size) && alignment <= MAX_SMALL_ALLOCATION) // no point to check m_isPoolAllocations as if it was false, pointer can't be in a bucket
@@ -931,7 +931,7 @@ namespace AZ {
         // returns the size of the resulting memory block
         inline size_t resize(void* ptr, size_t size)
         {
-            if (ptr == NULL)
+            if (ptr == nullptr)
             {
                 return 0;
             }
@@ -957,7 +957,7 @@ namespace AZ {
         // query the size of the memory block
         inline size_t size(void* ptr) const
         {
-            if (ptr == NULL)
+            if (ptr == nullptr)
             {
                 return 0;
             }
@@ -993,7 +993,7 @@ namespace AZ {
         // free the memory block
         inline void free(void* ptr)
         {
-            if (ptr == NULL)
+            if (ptr == nullptr)
             {
                 return;
             }
@@ -1009,7 +1009,7 @@ namespace AZ {
         // free the memory block supplying the original size with DEFAULT_ALIGNMENT
         inline void free(void* ptr, size_t origSize)
         {
-            if (ptr == NULL)
+            if (ptr == nullptr)
             {
                 return;
             }
@@ -1027,7 +1027,7 @@ namespace AZ {
         // free the memory block supplying the original size and alignment
         inline void free(void* ptr, size_t origSize, size_t oldAlignment)
         {
-            if (ptr == NULL)
+            if (ptr == nullptr)
             {
                 return;
             }
@@ -1134,10 +1134,10 @@ namespace AZ {
         // If m_systemChunkSize is specified, use that size for allocating tree blocks from the OS
         // m_treePageAlignment should be OS_VIRTUAL_PAGE_SIZE in all cases with this trait as we work 
         // with virtual memory addresses when the tree grows and we cannot specify an alignment in all cases
-        : m_treePageSize(desc.m_fixedMemoryBlock != NULL ? desc.m_pageSize :
+        : m_treePageSize(desc.m_fixedMemoryBlock != nullptr ? desc.m_pageSize :
             desc.m_systemChunkSize != 0 ? desc.m_systemChunkSize : OS_VIRTUAL_PAGE_SIZE)
         , m_treePageAlignment(desc.m_pageSize)
-        , m_poolPageSize(desc.m_fixedMemoryBlock != NULL ? desc.m_poolPageSize : OS_VIRTUAL_PAGE_SIZE)
+        , m_poolPageSize(desc.m_fixedMemoryBlock != nullptr ? desc.m_poolPageSize : OS_VIRTUAL_PAGE_SIZE)
         , m_subAllocator(desc.m_subAllocator)
     {
 #ifdef DEBUG_ALLOCATOR
@@ -1246,7 +1246,7 @@ namespace AZ {
                 return p;
             }
         }
-        return NULL;
+        return nullptr;
     }
 
     const HpAllocator::page* HpAllocator::bucket::get_free_page() const
@@ -1259,7 +1259,7 @@ namespace AZ {
                 return p;
             }
         }
-        return NULL;
+        return nullptr;
     }
 
     void* HpAllocator::bucket::alloc(page* p)
@@ -1359,7 +1359,7 @@ namespace AZ {
             p = bucket_grow(bsize, mBuckets[bi].marker());
             if (!p)
             {
-                return NULL;
+                return nullptr;
             }
             mBuckets[bi].add_free_page(p);
         }
@@ -1385,7 +1385,7 @@ namespace AZ {
             p = bucket_grow(bsize, mBuckets[bi].marker());
             if (!p)
             {
-                return NULL;
+                return nullptr;
             }
             mBuckets[bi].add_free_page(p);
         }
@@ -1406,7 +1406,7 @@ namespace AZ {
         void* newPtr = bucket_alloc(size);
         if (!newPtr)
         {
-            return NULL;
+            return nullptr;
         }
         memcpy(newPtr, ptr, AZStd::GetMin(elemSize - MEMORY_GUARD_SIZE, size - MEMORY_GUARD_SIZE));
         bucket_free(ptr);
@@ -1426,7 +1426,7 @@ namespace AZ {
         void* newPtr = bucket_alloc_direct(bucket_spacing_function(AZ::SizeAlignUp(size, alignment)));
         if (!newPtr)
         {
-            return NULL;
+            return nullptr;
         }
         memcpy(newPtr, ptr, AZStd::GetMin(elemSize - MEMORY_GUARD_SIZE, size - MEMORY_GUARD_SIZE));
         bucket_free(ptr);
@@ -1638,7 +1638,7 @@ namespace AZ {
         // create a dummy block to avoid prev() NULL checks and allow easy block shifts
         // potentially this dummy block might grow (due to shift_block) but not more than sizeof(free_node)
         block_header* front = (block_header*)mem;
-        front->prev(0);
+        front->prev(nullptr);
         front->size(0);
         front->set_used();
         block_header* back = (block_header*)front->mem();
@@ -1777,7 +1777,7 @@ namespace AZ {
             newBl = tree_grow(size);
             if (!newBl)
             {
-                return NULL;
+                return nullptr;
             }
         }
         HPPA_ASSERT(!newBl->used());
@@ -1956,7 +1956,7 @@ namespace AZ {
             tree_free(ptr);
             return newPtr;
         }
-        return NULL;
+        return nullptr;
     }
 
     void* HpAllocator::tree_realloc_aligned(void* ptr, size_t size, size_t alignment)
@@ -2044,7 +2044,7 @@ namespace AZ {
             tree_free(ptr);
             return newPtr;
         }
-        return NULL;
+        return nullptr;
     }
 
     size_t HpAllocator::tree_resize(void* ptr, size_t size)
@@ -2121,7 +2121,7 @@ namespace AZ {
         HPPA_ASSERT(!bl->used());
         HPPA_ASSERT(bl->prev() && bl->prev()->used());
         HPPA_ASSERT(bl->next() && bl->next()->used());
-        if (bl->prev()->prev() == NULL && bl->next()->size() == 0)
+        if (bl->prev()->prev() == nullptr && bl->next()->size() == 0)
         {
             tree_detach(bl);
             char* memStart = (char*)bl->prev();
@@ -2539,11 +2539,11 @@ namespace AZ {
         if (m_desc.m_fixedMemoryBlockByteSize > 0)
         {
             AZ_Assert((m_desc.m_fixedMemoryBlockByteSize & (m_desc.m_pageSize - 1)) == 0, "Memory block size %d MUST be multiples of the of the page size %d!", m_desc.m_fixedMemoryBlockByteSize, m_desc.m_pageSize);
-            if (m_desc.m_fixedMemoryBlock == NULL)
+            if (m_desc.m_fixedMemoryBlock == nullptr)
             {
-                AZ_Assert(m_desc.m_subAllocator != NULL, "Sub allocator must point to a valid allocator if m_fixedMemoryBlock is NOT allocated (NULL)!");
+                AZ_Assert(m_desc.m_subAllocator != nullptr, "Sub allocator must point to a valid allocator if m_fixedMemoryBlock is NOT allocated (NULL)!");
                 m_desc.m_fixedMemoryBlock = m_desc.m_subAllocator->Allocate(m_desc.m_fixedMemoryBlockByteSize, m_desc.m_fixedMemoryBlockAlignment, 0, "HphaSchema", __FILE__, __LINE__, 1);
-                AZ_Assert(m_desc.m_fixedMemoryBlock != NULL, "Failed to allocate %d bytes!", m_desc.m_fixedMemoryBlockByteSize);
+                AZ_Assert(m_desc.m_fixedMemoryBlock != nullptr, "Failed to allocate %d bytes!", m_desc.m_fixedMemoryBlockByteSize);
                 m_ownMemoryBlock = true;
             }
             AZ_Assert((reinterpret_cast<size_t>(m_desc.m_fixedMemoryBlock) & static_cast<size_t>(desc.m_fixedMemoryBlockAlignment - 1)) == 0, "Memory block must be page size (%d bytes) aligned!", desc.m_fixedMemoryBlockAlignment);
@@ -2570,7 +2570,7 @@ namespace AZ {
         if (m_ownMemoryBlock)
         {
             m_desc.m_subAllocator->DeAllocate(m_desc.m_fixedMemoryBlock, m_desc.m_fixedMemoryBlockByteSize, m_desc.m_fixedMemoryBlockAlignment);
-            m_desc.m_fixedMemoryBlock = NULL;
+            m_desc.m_fixedMemoryBlock = nullptr;
         }
     }
 
@@ -2587,7 +2587,7 @@ namespace AZ {
         (void)lineNum;
         (void)suppressStackRecord;
         pointer_type address = m_allocator->alloc(byteSize, alignment);
-        if (address == NULL)
+        if (address == nullptr)
         {
             GarbageCollect();
             address = m_allocator->alloc(byteSize, alignment);
@@ -2603,7 +2603,7 @@ namespace AZ {
     HphaSchema::ReAllocate(pointer_type ptr, size_type newSize, size_type newAlignment)
     {
         pointer_type address = m_allocator->realloc(ptr, newSize, newAlignment);
-        if (address == NULL && newSize > 0)
+        if (address == nullptr && newSize > 0)
         {
             GarbageCollect();
             address = m_allocator->realloc(ptr, newSize, newAlignment);
@@ -2618,7 +2618,7 @@ namespace AZ {
     void
     HphaSchema::DeAllocate(pointer_type ptr, size_type size, size_type alignment)
     {
-        if (ptr == 0)
+        if (ptr == nullptr)
         {
             return;
         }

Code/Framework/AzCore/AzCore/Memory/MemoryDriller.cpp

@@ -106,7 +106,7 @@ namespace AZ
 
                 m_allAllocatorRecords.push_back(allocator->GetRecords());
 
-                if (m_output == NULL)
+                if (m_output == nullptr)
                 {
                     return;                    // we have no active output
                 }
@@ -154,7 +154,7 @@ namespace AZ
             delete allocatorRecords;
             allocator->SetRecords(nullptr);
 
-            if (m_output == NULL)
+            if (m_output == nullptr)
             {
                 return;                    // we have no active output
             }
@@ -173,7 +173,7 @@ namespace AZ
             if (records)
             {
                 const AllocationInfo* info = records->RegisterAllocation(address, byteSize, alignment, name, fileName, lineNum, stackSuppressCount + 1);
-                if (m_output == NULL)
+                if (m_output == nullptr)
                 {
                     return;                   // we have no active output
                 }
@@ -226,7 +226,7 @@ namespace AZ
             {
                 records->UnregisterAllocation(address, byteSize, alignment, info);
 
-                if (m_output == NULL)
+                if (m_output == nullptr)
                 {
                     return;                    // we have no active output
                 }
@@ -261,7 +261,7 @@ namespace AZ
             {
                 records->ResizeAllocation(address, newSize);
 
-                if (m_output == NULL)
+                if (m_output == nullptr)
                 {
                     return;                    // we have no active output
                 }

Code/Framework/AzCore/AzCore/Memory/OSAllocator.cpp

@@ -75,7 +75,7 @@ namespace AZ
             address = AZ_OS_MALLOC(byteSize, alignment);
         }
 
-        if (address == 0 && byteSize > 0)
+        if (address == nullptr && byteSize > 0)
         {
             AZ_Printf("Memory", "======================================================\n");
             AZ_Printf("Memory", "OSAllocator run out of system memory!\nWe can't track the debug allocator, since it's used for tracking and pipes trought the OS... here are the other allocator status:\n");

Code/Framework/AzCore/AzCore/Memory/OverrunDetectionAllocator.cpp

@@ -216,9 +216,9 @@ namespace AZ
     class OverrunDetectionSchemaImpl
     {
     public:
-        typedef void*       pointer_type;
-        typedef size_t      size_type;
-        typedef ptrdiff_t   difference_type;
+        using pointer_type = void *;
+        using size_type = size_t;
+        using difference_type = ptrdiff_t;
 
         OverrunDetectionSchemaImpl(const OverrunDetectionSchema::Descriptor& desc);
         ~OverrunDetectionSchemaImpl();
@@ -241,8 +241,8 @@ namespace AZ
         Internal::AllocationRecord* CreateAllocationRecord(void* p, size_t size) const;
 
     private:
-        typedef AZStd::mutex mutex_type;
-        typedef AZStd::lock_guard<mutex_type> lock_type;
+        using mutex_type = AZStd::mutex;
+        using lock_type = AZStd::lock_guard<mutex_type>;
 
         AZStd::unique_ptr<OverrunDetectionSchema::PlatformAllocator> m_platformAllocator;
         mutex_type m_mutex;

Code/Framework/AzCore/AzCore/Memory/PoolSchema.cpp

@@ -278,7 +278,7 @@ namespace AZ
             Page* page = reinterpret_cast<Page*>(memBlock);
             if (!page->m_magic.Validate())
             {
-                return NULL;
+                return nullptr;
             }
             return page;
         }
@@ -403,7 +403,7 @@ PoolAllocation<Allocator>::Allocate(size_t byteSize, size_t alignment)
 
     u32 bucketIndex = static_cast<u32>((byteSize >> m_minAllocationShift)-1);
     BucketType& bucket = m_buckets[bucketIndex];
-    PageType* page = 0;
+    PageType* page = nullptr;
     if (!bucket.m_pages.empty())
     {
         page = &bucket.m_pages.front();
@@ -411,7 +411,7 @@ PoolAllocation<Allocator>::Allocate(size_t byteSize, size_t alignment)
         // check if we have free slot in the page
         if (page->m_freeList.empty())
         {
-            page = 0;
+            page = nullptr;
         }
         else if (page->m_freeList.size()==1)
         {
@@ -464,7 +464,7 @@ AZ_INLINE void
 PoolAllocation<Allocator>::DeAllocate(void* ptr)
 {
     PageType* page = m_allocator->PageFromAddress(ptr);
-    if (page==NULL)
+    if (page==nullptr)
     {
         AZ_Error("Memory", false, "Address 0x%08x is not in the ThreadPool!", ptr);
         return;
@@ -503,7 +503,7 @@ PoolAllocation<Allocator>::DeAllocate(void* ptr)
                 m_allocator->PushFreePage(page);
             }
         }
-        else if (frontPage->m_next != 0)
+        else if (frontPage->m_next != nullptr)
         {
             // if the next page has free slots free the current page
             if (frontPage->m_next->m_freeList.size() < maxElementsPerBucket)
@@ -584,7 +584,7 @@ PoolAllocation<Allocator>::GarbageCollect(bool isForceFreeAllPages)
 // [9/15/2009]
 //=========================================================================
 PoolSchema::PoolSchema(const Descriptor& desc)
-    : m_impl(NULL)
+    : m_impl(nullptr)
 {
     (void)desc;  // ignored here, applied in Create()
 }
@@ -595,7 +595,7 @@ PoolSchema::PoolSchema(const Descriptor& desc)
 //=========================================================================
 PoolSchema::~PoolSchema()
 {
-    AZ_Assert(m_impl==NULL, "You did not destroy the pool schema!");
+    AZ_Assert(m_impl==nullptr, "You did not destroy the pool schema!");
     delete m_impl;
 }
 
@@ -605,12 +605,12 @@ PoolSchema::~PoolSchema()
 //=========================================================================
 bool PoolSchema::Create(const Descriptor& desc)
 {
-    AZ_Assert(m_impl==NULL, "PoolSchema already created!");
-    if (m_impl == NULL)
+    AZ_Assert(m_impl==nullptr, "PoolSchema already created!");
+    if (m_impl == nullptr)
     {
         m_impl = aznew PoolSchemaImpl(desc);
     }
-    return (m_impl!=NULL);
+    return (m_impl!=nullptr);
 }
 
 //=========================================================================
@@ -620,7 +620,7 @@ bool PoolSchema::Create(const Descriptor& desc)
 bool PoolSchema::Destroy()
 {
     delete m_impl;
-    m_impl = NULL;
+    m_impl = nullptr;
     return true;
 }
 
@@ -751,7 +751,7 @@ PoolSchema::GetSubAllocator()
 PoolSchemaImpl::PoolSchemaImpl(const PoolSchema::Descriptor& desc)
     : m_pageAllocator(desc.m_pageAllocator ? desc.m_pageAllocator : &AllocatorInstance<SystemAllocator>::Get())
     , m_allocator(this, desc.m_pageSize, desc.m_minAllocationSize, desc.m_maxAllocationSize)
-    , m_staticDataBlock(0)
+    , m_staticDataBlock(nullptr)
     , m_numStaticPages(desc.m_numStaticPages)
     , m_isDynamic(desc.m_isDynamic)
     , m_pageSize(desc.m_pageSize)
@@ -851,7 +851,7 @@ PoolSchemaImpl::AllocationSize(PoolSchema::pointer_type ptr)
 AZ_FORCE_INLINE PoolSchemaImpl::Page*
 PoolSchemaImpl::PopFreePage()
 {
-    Page* page = 0;
+    Page* page = nullptr;
     if (!m_freePages.empty())
     {
         page = &m_freePages.front();
@@ -938,7 +938,7 @@ PoolSchemaImpl::Page::SetupFreeList(size_t elementSize, size_t pageDataBlockSize
 // [9/15/2009]
 //=========================================================================
 ThreadPoolSchema::ThreadPoolSchema(GetThreadPoolData getThreadPoolData, SetThreadPoolData setThreadPoolData)
-    : m_impl(NULL)
+    : m_impl(nullptr)
     , m_threadPoolGetter(getThreadPoolData)
     , m_threadPoolSetter(setThreadPoolData)
 {
@@ -950,7 +950,7 @@ ThreadPoolSchema::ThreadPoolSchema(GetThreadPoolData getThreadPoolData, SetThrea
 //=========================================================================
 ThreadPoolSchema::~ThreadPoolSchema()
 {
-    AZ_Assert(m_impl==NULL, "You did not destroy the thread pool schema!");
+    AZ_Assert(m_impl==nullptr, "You did not destroy the thread pool schema!");
     delete m_impl;
 }
 
@@ -960,12 +960,12 @@ ThreadPoolSchema::~ThreadPoolSchema()
 //=========================================================================
 bool ThreadPoolSchema::Create(const Descriptor& desc)
 {
-    AZ_Assert(m_impl==NULL, "PoolSchema already created!");
-    if (m_impl == NULL)
+    AZ_Assert(m_impl==nullptr, "PoolSchema already created!");
+    if (m_impl == nullptr)
     {
         m_impl = aznew ThreadPoolSchemaImpl(desc, m_threadPoolGetter, m_threadPoolSetter);
     }
-    return (m_impl!=NULL);
+    return (m_impl!=nullptr);
 }
 
 //=========================================================================
@@ -975,7 +975,7 @@ bool ThreadPoolSchema::Create(const Descriptor& desc)
 bool ThreadPoolSchema::Destroy()
 {
     delete m_impl;
-    m_impl = NULL;
+    m_impl = nullptr;
     return true;
 }
 //=========================================================================
@@ -1099,7 +1099,7 @@ ThreadPoolSchemaImpl::ThreadPoolSchemaImpl(const ThreadPoolSchema::Descriptor& d
     : m_threadPoolGetter(threadPoolGetter)
     , m_threadPoolSetter(threadPoolSetter)
     , m_pageAllocator(desc.m_pageAllocator)
-    , m_staticDataBlock(0)
+    , m_staticDataBlock(nullptr)
     , m_numStaticPages(desc.m_numStaticPages)
     , m_pageSize(desc.m_pageSize)
     , m_minAllocationSize(desc.m_minAllocationSize)
@@ -1112,7 +1112,7 @@ ThreadPoolSchemaImpl::ThreadPoolSchemaImpl(const ThreadPoolSchema::Descriptor& d
     SetCriticalSectionSpinCount(m_mutex.native_handle(), 4000);
 #   endif
 
-    if (m_pageAllocator == 0)
+    if (m_pageAllocator == nullptr)
     {
         m_pageAllocator = &AllocatorInstance<SystemAllocator>::Get();  // use the SystemAllocator if no page allocator is provided
     }
@@ -1211,7 +1211,7 @@ ThreadPoolSchemaImpl::Allocate(ThreadPoolSchema::size_type byteSize, ThreadPoolS
     {
         // deallocate elements if they were freed from other threads
         Page::FakeNodeLF* fakeLFNode;
-        while ((fakeLFNode = threadData->m_freedElements.pop())!=0)
+        while ((fakeLFNode = threadData->m_freedElements.pop())!=nullptr)
         {
             threadData->m_allocator.DeAllocate(fakeLFNode);
         }
@@ -1228,12 +1228,12 @@ void
 ThreadPoolSchemaImpl::DeAllocate(ThreadPoolSchema::pointer_type ptr)
 {
     Page* page = PageFromAddress(ptr);
-    if (page==NULL)
+    if (page==nullptr)
     {
         AZ_Error("Memory", false, "Address 0x%08x is not in the ThreadPool!", ptr);
         return;
     }
-    AZ_Assert(page->m_threadData!=0, ("We must have valid page thread data for the page!"));
+    AZ_Assert(page->m_threadData!=nullptr, ("We must have valid page thread data for the page!"));
     ThreadPoolData* threadData = m_threadPoolGetter();
     if (threadData == page->m_threadData)
     {
@@ -1262,11 +1262,11 @@ ThreadPoolSchema::size_type
 ThreadPoolSchemaImpl::AllocationSize(ThreadPoolSchema::pointer_type ptr)
 {
     Page* page = PageFromAddress(ptr);
-    if (page==NULL)
+    if (page==nullptr)
     {
         return 0;
     }
-    AZ_Assert(page->m_threadData!=0, ("We must have valid page thread data for the page!"));
+    AZ_Assert(page->m_threadData!=nullptr, ("We must have valid page thread data for the page!"));
     return page->m_threadData->m_allocator.AllocationSize(ptr);
 }
 
@@ -1282,7 +1282,7 @@ ThreadPoolSchemaImpl::PopFreePage()
         AZStd::lock_guard<AZStd::recursive_mutex> lock(m_mutex);
         if (m_freePages.empty())
         {
-            page = NULL;
+            page = nullptr;
         }
         else
         {
@@ -1387,7 +1387,7 @@ ThreadPoolData::~ThreadPoolData()
 {
     // deallocate elements if they were freed from other threads
     ThreadPoolSchemaImpl::Page::FakeNodeLF* fakeLFNode;
-    while ((fakeLFNode = m_freedElements.pop())!=0)
+    while ((fakeLFNode = m_freedElements.pop())!=nullptr)
     {
         m_allocator.DeAllocate(fakeLFNode);
     }

Code/Framework/AzCore/AzCore/Memory/SystemAllocator.cpp

@@ -153,7 +153,7 @@ SystemAllocator::Create(const Descriptor& desc)
 #elif AZCORE_SYSTEM_ALLOCATOR == AZCORE_SYSTEM_ALLOCATOR_HEAP
             m_allocator = azcreate(HeapSchema, (heapDesc), SystemAllocator);
 #endif
-            if (m_allocator == NULL)
+            if (m_allocator == nullptr)
             {
                 isReady = false;
             }
@@ -237,7 +237,7 @@ SystemAllocator::Allocate(size_type byteSize, size_type alignment, int flags, co
     byteSize = MemorySizeAdjustedUp(byteSize);
     SystemAllocator::pointer_type address = m_allocator->Allocate(byteSize, alignment, flags, name, fileName, lineNum, suppressStackRecord + 1);
 
-    if (address == 0)
+    if (address == nullptr)
     {
         // Free all memory we can and try again!
         AllocatorManager::Instance().GarbageCollect();
@@ -245,7 +245,7 @@ SystemAllocator::Allocate(size_type byteSize, size_type alignment, int flags, co
         address = m_allocator->Allocate(byteSize, alignment, flags, name, fileName, lineNum, suppressStackRecord + 1);
     }
 
-    if (address == 0)
+    if (address == nullptr)
     {
         byteSize = MemorySizeAdjustedDown(byteSize);  // restore original size
 
@@ -258,7 +258,7 @@ SystemAllocator::Allocate(size_type byteSize, size_type alignment, int flags, co
         }
     }
 
-    AZ_Assert(address != 0, "SystemAllocator: Failed to allocate %d bytes aligned on %d (flags: 0x%08x) %s : %s (%d)!", byteSize, alignment, flags, name ? name : "(no name)", fileName ? fileName : "(no file name)", lineNum);
+    AZ_Assert(address != nullptr, "SystemAllocator: Failed to allocate %d bytes aligned on %d (flags: 0x%08x) %s : %s (%d)!", byteSize, alignment, flags, name ? name : "(no name)", fileName ? fileName : "(no file name)", lineNum);
 
     AZ_PROFILE_MEMORY_ALLOC_EX(MemoryReserved, fileName, lineNum, address, byteSize, name);
     AZ_MEMORY_PROFILE(ProfileAllocation(address, byteSize, alignment, name, fileName, lineNum, suppressStackRecord + 1));

Code/Framework/AzCore/AzCore/Module/Environment.cpp

@@ -148,7 +148,7 @@ namespace AZ
                 AZ_Assert(m_numAttached == 0, "We should not delete an environment while there are %d modules attached! Unload all DLLs first!", m_numAttached);
 #endif
 
-                for (auto variableIt : m_variableMap)
+                for (const auto &variableIt : m_variableMap)
                 {
                     EnvironmentVariableHolderBase* holder = reinterpret_cast<EnvironmentVariableHolderBase*>(variableIt.second);
                     if (holder)

Code/Framework/AzCore/AzCore/NativeUI/NativeUISystemComponent.cpp

@@ -41,11 +41,17 @@ namespace AZ::NativeUI
         AZStd::string result = DisplayBlockingDialog("Assert Failed!", message, options);
 
         if (result.compare(buttonNames[0]) == 0)
+        {
             return AssertAction::IGNORE_ASSERT;
+        }
         else if (result.compare(buttonNames[1]) == 0)
+        {
             return AssertAction::IGNORE_ALL_ASSERTS;
+        }
         else if (result.compare(buttonNames[2]) == 0)
+        {
             return AssertAction::BREAK;
+        }
 
         return AssertAction::NONE;
     }

Code/Framework/AzCore/AzCore/RTTI/BehaviorContext.cpp

@@ -121,12 +121,12 @@ namespace AZ
         {
             delete attrIt.second;
         }
-        
+
         if (m_overload)
         {
             delete m_overload;
         }
-        
+
         m_attributes.clear();
     }
 
@@ -180,7 +180,7 @@ namespace AZ
         if (GetNumArguments() == overload->GetNumArguments())
         {
             bool anyDifference = false;
-            
+
             for (size_t i(0), sentinel(GetNumArguments()); !anyDifference && i < sentinel; ++i)
             {
                 const BehaviorParameter* thisArg = GetArgument(i);
@@ -273,7 +273,7 @@ namespace AZ
         auto attributes = AZStd::move(m_attributes);
 
         // Actually delete everything
-        for (auto propertyIt : events)
+        for (const auto &propertyIt : events)
         {
             delete propertyIt.second.m_broadcast;
             delete propertyIt.second.m_event;
@@ -519,20 +519,20 @@ namespace AZ
     AZStd::vector<BehaviorMethod*> BehaviorClass::GetOverloads(const AZStd::string& name) const
     {
         AZStd::vector<BehaviorMethod*> overloads;
-        
+
         auto methodIter = m_methods.find(name);
         if (methodIter != m_methods.end())
         {
             overloads = GetOverloadsIncludeMethod(methodIter->second);
-        }        
-        
+        }
+
         return overloads;
     }
 
     AZStd::vector<BehaviorMethod*> BehaviorClass::GetOverloadsIncludeMethod(BehaviorMethod* method) const
     {
         AZStd::vector<BehaviorMethod*> overloads;
-       
+
         auto iter = method;
         while (iter)
         {
@@ -546,7 +546,7 @@ namespace AZ
     AZStd::vector<BehaviorMethod*> BehaviorClass::GetOverloadsExcludeMethod(BehaviorMethod* method) const
     {
         AZStd::vector<BehaviorMethod*> overloads;
-        
+
         auto iter = method->m_overload;
         while (iter)
         {
@@ -972,5 +972,5 @@ namespace AZ
             return enumRttiHelper.GetTypeId();
         }
     }
- 
+
 } // namespace AZ

Code/Framework/AzCore/AzCore/RTTI/BehaviorContext.h

@@ -36,7 +36,7 @@ namespace AZ
 
     constexpr const char* k_PropertyNameGetterSuffix = "::Getter";
     constexpr const char* k_PropertyNameSetterSuffix = "::Setter";
-    
+
     /// Typedef for class unwrapping callback (i.e. used for things like smart_ptr<T> to unwrap for T)
     using BehaviorClassUnwrapperFunction = void(*)(void* /*classPtr*/, void*& /*unwrappedClass*/, AZ::Uuid& /*unwrappedClassTypeId*/, void* /*userData*/);
 
@@ -53,7 +53,7 @@ namespace AZ
         IfPresent,
     };
 
-    struct BehaviorObject // same as DynamicSerializableField, make sure we merge them... so we can store the object easily 
+    struct BehaviorObject // same as DynamicSerializableField, make sure we merge them... so we can store the object easily
     {
         AZ_TYPE_INFO(BehaviorObject, "{2813cdfb-0a4a-411c-9216-72a7b644d1dd}");
 
@@ -165,7 +165,7 @@ namespace AZ
         /// Convert to BehaviorObject implicitly for passing generic parameters (usually not known at compile time)
         operator BehaviorObject() const;
 
-        /// Converts internally the value to a specific type known at compile time. \returns true if conversion was successful. 
+        /// Converts internally the value to a specific type known at compile time. \returns true if conversion was successful.
         template<class T>
         bool ConvertTo();
 
@@ -452,7 +452,7 @@ namespace AZ
     namespace Internal
     {
         const AZ::TypeId& GetUnderlyingTypeId(const IRttiHelper& enumRttiHelper);
-        
+
         // Converts sourceAddress to targetType
         inline bool ConvertValueTo(void* sourceAddress, const IRttiHelper* sourceRtti, const AZ::Uuid& targetType, void*& targetAddress, BehaviorParameter::TempValueParameterAllocator& tempAllocator)
         {
@@ -520,7 +520,7 @@ namespace AZ
             static const int s_startNamedArgumentIndex = s_startArgumentIndex; // +1 for result type
 
             BehaviorMethodImpl(FunctionPointer functionPointer, BehaviorContext* context, const AZStd::string& name = AZStd::string());
-            
+
             bool Call(BehaviorValueParameter* arguments, unsigned int numArguments, BehaviorValueParameter* result) const override;
 
             bool HasResult() const override;
@@ -548,7 +548,7 @@ namespace AZ
             BehaviorParameter m_parameters[sizeof...(Args)+s_startNamedArgumentIndex];
             AZStd::array<BehaviorParameterMetadata, sizeof...(Args)+s_startNamedArgumentIndex> m_metadataParameters; ///< Stores the per parameter metadata which is used to add names, tooltips, trait, default values, etc... to the parameters
         };
-        
+
 #if __cpp_noexcept_function_type
         // C++17 makes exception specifications as part of the type in paper P0012R1
         // Therefore noexcept overloads must be distinguished from non-noexcept overloads
@@ -732,7 +732,7 @@ namespace AZ
 
             BehaviorEBusEvent(FunctionPointer functionPointer, BehaviorContext* context);
             BehaviorEBusEvent(FunctionPointerConst functionPointer, BehaviorContext* context);
-            
+
             template<bool IsBusId>
             inline AZStd::enable_if_t<IsBusId> SetBusIdType();
 
@@ -813,7 +813,7 @@ namespace AZ
             : SetFunctionParameters<R(C::*)(Args...)>
         {};
 #endif
-        
+
         template<class FunctionType>
         struct BehaviorOnDemandReflectHelper;
         template<class R, class... Args>
@@ -997,14 +997,14 @@ namespace AZ
     } // namespace Internal
 
     /**
-     * Behavior representation of reflected class. 
+     * Behavior representation of reflected class.
      */
     class BehaviorClass
     {
     public:
         AZ_CLASS_ALLOCATOR(BehaviorClass, SystemAllocator, 0);
 
-        BehaviorClass();      
+        BehaviorClass();
         ~BehaviorClass();
 
         /// Hooks to override default memory allocation for the class (AZ_CLASS_ALLOCATOR is used by default)
@@ -1065,7 +1065,7 @@ namespace AZ
 
         void* m_userData;
         AZStd::string m_name;
-        AZStd::vector<AZ::Uuid> m_baseClasses;  
+        AZStd::vector<AZ::Uuid> m_baseClasses;
         AZStd::unordered_map<AZStd::string, BehaviorMethod*> m_methods;
         AZStd::unordered_map<AZStd::string, BehaviorProperty*> m_properties;
         AttributeArray m_attributes;
@@ -1081,7 +1081,7 @@ namespace AZ
         AZ::Uuid m_wrappedTypeId;
         // Store all owned instances for unload verification?
     };
-        
+
     // Helper macros to generate getter and setter function from a pointer to value or member value
     // Syntax BehaviorValueGetter(&globalValue) BehaviorValueGetter(&Class::MemberValue)
 #   define BehaviorValueGetter(valueAddress) &AZ::Internal::BehaviorValuePropertyHelper<decltype(valueAddress)>::Get<valueAddress>
@@ -1095,7 +1095,7 @@ namespace AZ
      * Property representation, a property has getter and setter. A read only property will have a "nullptr" for a setter.
      * You can use lambdas, global of member function. If you want to just expose a variable (not write the function and handle changes)
      * you can use \ref BehaviorValueProperty macros (or BehaviorValueGetter/Setter to control read/write functionality)
-     * Member constants are a property too, use \ref BehaviorConstant for it. Everything is either a property or a method, the main reason 
+     * Member constants are a property too, use \ref BehaviorConstant for it. Everything is either a property or a method, the main reason
      * why we "push" people to use functions is that in most cases when we manipulate an object, you will need to do more than just set a value
      * to a new value.
      */
@@ -1163,7 +1163,7 @@ namespace AZ
     };
 
     /**
-     * RAII class which keeps track of functions reflected to the BehaviorContext 
+     * RAII class which keeps track of functions reflected to the BehaviorContext
      * when it is supplied as an OnDemandReflectionOwner
      */
     class ScopedBehaviorOnDemandReflector
@@ -1182,7 +1182,7 @@ namespace AZ
         AZ_CLASS_ALLOCATOR(BehaviorEBus, SystemAllocator, 0);
 
         typedef void(*QueueFunctionType)(void* /*userData1*/, void* /*userData2*/);
-    
+
         struct VirtualProperty
         {
             VirtualProperty(BehaviorEBusEventSender* getter, BehaviorEBusEventSender* setter)
@@ -1294,7 +1294,7 @@ namespace AZ
         AZStd::string m_scriptPath;
 #endif
 
-        AZStd::string GetScriptPath() const 
+        AZStd::string GetScriptPath() const
         {
 #if defined(PERFORMANCE_BUILD) || !defined(_RELEASE) // m_scriptPath is only available in non-Release mode
             return m_scriptPath;
@@ -1303,8 +1303,8 @@ namespace AZ
 #endif
         }
 
-        void SetScriptPath(const char* scriptPath) 
-        { 
+        void SetScriptPath(const char* scriptPath)
+        {
 #if defined(PERFORMANCE_BUILD) || !defined(_RELEASE) // m_scriptPath is only available in non-Release mode
             m_scriptPath = scriptPath;
 #else
@@ -1346,7 +1346,7 @@ namespace AZ
         virtual void OnAddGlobalProperty(const char* propertyName, BehaviorProperty* prop)  { (void)propertyName; (void)prop; }
         virtual void OnRemoveGlobalProperty(const char* propertyName, BehaviorProperty* prop) { (void)propertyName; (void)prop; }
 
-        /// Called when a class is added or removed 
+        /// Called when a class is added or removed
         virtual void OnAddClass(const char* className, BehaviorClass* behaviorClass)    { (void)className; (void)behaviorClass; }
         virtual void OnRemoveClass(const char* className, BehaviorClass* behaviorClass) { (void)className; (void)behaviorClass; }
 
@@ -1358,10 +1358,10 @@ namespace AZ
     using BehaviorContextBus = AZ::EBus<BehaviorContextEvents>;
 
     /**
-     * BehaviorContext is used to reflect classes, methods and EBuses for runtime interaction. A typical consumer of this context and different 
+     * BehaviorContext is used to reflect classes, methods and EBuses for runtime interaction. A typical consumer of this context and different
      * scripting systems (i.e. Lua, Visual Script, etc.). Even though (as designed) there are overlaps between some context they have very different
      * purpose and set of rules. For example SerializeContext, doesn't reflect any methods, it just reflects data fields that will be stored for initial object
-     * setup, it handles version conversion and so thing, this related to storing the object to a persistent storage. Behavior context, doesn't need to deal with versions as 
+     * setup, it handles version conversion and so thing, this related to storing the object to a persistent storage. Behavior context, doesn't need to deal with versions as
      * no data is stored, just methods for manipulating the object state.
      */
     class BehaviorContext : public ReflectContext
@@ -1379,7 +1379,7 @@ namespace AZ
         }
 
         template<class Bus>
-        static void QueueFunction(BehaviorEBus::QueueFunctionType f, void* userData1, void* userData2) 
+        static void QueueFunction(BehaviorEBus::QueueFunctionType f, void* userData1, void* userData2)
         {
             Bus::QueueFunction(f, userData1, userData2);
         }
@@ -1484,8 +1484,8 @@ namespace AZ
         }
 
         template<class T>
-        static void SetClassDefaultAllocator(BehaviorClass* behaviorClass, const AZStd::false_type& /*HasAZClassAllocator<T>*/) 
-        { 
+        static void SetClassDefaultAllocator(BehaviorClass* behaviorClass, const AZStd::false_type& /*HasAZClassAllocator<T>*/)
+        {
             behaviorClass->m_allocate = &DefaultSystemAllocator<T>::Allocate;
             behaviorClass->m_deallocate = &DefaultSystemAllocator<T>::DeAllocate;
         }
@@ -1522,20 +1522,20 @@ namespace AZ
         }
 
         template<class T>
-        static void SetClassDefaultConstructor(BehaviorClass* behaviorClass, const AZStd::true_type& /*AZStd::is_constructible<T>*/) 
+        static void SetClassDefaultConstructor(BehaviorClass* behaviorClass, const AZStd::true_type& /*AZStd::is_constructible<T>*/)
         {
             behaviorClass->m_defaultConstructor = &DefaultConstruct<T>;
         }
 
         template<class T>
-        static void SetClassDefaultDestructor(BehaviorClass* behaviorClass, const AZStd::true_type& /*AZStd::is_destructible<T>*/) 
+        static void SetClassDefaultDestructor(BehaviorClass* behaviorClass, const AZStd::true_type& /*AZStd::is_destructible<T>*/)
             {
                 behaviorClass->m_destructor = &DefaultDestruct<T>;
             }
 
         template<class T>
-        static void SetClassDefaultCopyConstructor(BehaviorClass* behaviorClass, const AZStd::true_type& /*AZStd::is_copy_constructible<T>*/) 
-        { 
+        static void SetClassDefaultCopyConstructor(BehaviorClass* behaviorClass, const AZStd::true_type& /*AZStd::is_copy_constructible<T>*/)
+        {
             behaviorClass->m_cloner = &DefaultCopyConstruct<T>;
         }
 
@@ -1585,7 +1585,7 @@ namespace AZ
             const char* m_name;
             BehaviorMethod* m_method;
         };
-         
+
         struct GlobalPropertyBuilder : public AZ::Internal::GenericAttributes<GlobalPropertyBuilder>
         {
             typedef AZ::Internal::GenericAttributes<GlobalPropertyBuilder> Base;
@@ -1608,7 +1608,7 @@ namespace AZ
             ClassBuilder(BehaviorContext* context, BehaviorClass* behaviorClass);
             ~ClassBuilder();
             ClassBuilder* operator->();
-          
+
             /**
             * Sets custom allocator for a class, this function will error if this not inside a class.
             * This is only for very specific cases when you want to override AZ_CLASS_ALLOCATOR or you are dealing with 3rd party classes, otherwise
@@ -1659,9 +1659,9 @@ namespace AZ
             ClassBuilder* Constant(const char* name, Getter getter);
 
             /**
-             * You can describe buses that this class uses to communicate. Those buses will be used by tools when 
+             * You can describe buses that this class uses to communicate. Those buses will be used by tools when
              * you need to give developers hints as to what buses this class interacts with.
-             * You don't need to reflect all buses that your class uses, just the ones related to 
+             * You don't need to reflect all buses that your class uses, just the ones related to
              * class behavior. Please refer to component documentation for more information on
              * the pattern of Request and Notification buses.
              * {@
@@ -1717,10 +1717,10 @@ namespace AZ
 
             /**
              * With request buses (please refer to component communication patterns documentation) we ofter have EBus events
-             * that represent a getter and a setter for a value. To allow our tools to take advantage of it, you can reflect 
+             * that represent a getter and a setter for a value. To allow our tools to take advantage of it, you can reflect
              * VirtualProperty to indicate which event is the getter and which is the setter.
              * This function validates that getter event has no argument and a result and setter function has no results and only
-             * one argument which is the same type as the result of the getter. 
+             * one argument which is the same type as the result of the getter.
              * \note Make sure you call this function after you have reflected the getter and setter events as it will report an error
              * if we can't find the function
              */
@@ -1731,7 +1731,7 @@ namespace AZ
 
          BehaviorContext();
         ~BehaviorContext();
-     
+
         ///< \deprecated Use "Method(const char*, Function, const AZStd::array<ParameterOverrides, AZStd::function_traits<Function>::num_args>&, const char*)" instead
         ///< This method does not support passing in argument names and tooltips nor does it support overriding specific parameter Behavior traits
         template<class Function>
@@ -1741,7 +1741,7 @@ namespace AZ
         ///< This method does not support passing in argument names and tooltips nor does it support overriding specific parameter Behavior traits
         template<class Function>
         GlobalMethodBuilder Method(const char* name, Function f, const char* deprecatedName, BehaviorValues* defaultValues = nullptr, const char* dbgDesc = nullptr);
-        
+
         template<class Function>
         GlobalMethodBuilder Method(const char* name, Function f, const AZStd::array<BehaviorParameterOverrides, AZStd::function_traits<Function>::num_args>& args, const char* dbgDesc = nullptr);
 
@@ -1836,13 +1836,13 @@ namespace AZ
 
 /**
  * Helper MACRO to help you write the EBus handler that you want to reflect to behavior. This is not required, but generally we recommend reflecting all useful
- * buses as this enable people to "script" complex behaviors. 
+ * buses as this enable people to "script" complex behaviors.
  * You don't have to use this macro to write a Handler, but some people find it useful
  * Here is an example how to use it:
  * class MyEBusBehaviorHandler : public MyEBus::Handler, public AZ::BehaviorEBusHandler
  * {
  * public:
- *      AZ_EBUS_BEHAVIOR_BINDER(MyEBusBehaviorHandler, "{XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXXXX}",Allocator, OnEvent1, OnEvent2 and so on);     
+ *      AZ_EBUS_BEHAVIOR_BINDER(MyEBusBehaviorHandler, "{XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXXXX}",Allocator, OnEvent1, OnEvent2 and so on);
  *      // now you need implementations for those event
  *
  *
@@ -1854,7 +1854,7 @@ namespace AZ
  *          // The AZ_EBUS_BEHAVIOR_BINDER defines FN_EventName for each index. You can also cache it yourself (but it's slower), static int cacheIndex = GetFunctionIndex("OnEvent1"); and use that .
  *          CallResult(result, FN_OnEvent1, data);  // forward to the binding (there can be none, this is why we need to always have properly set result, when there is one)
  *          return result; // return the result like you will in any normal EBus even with result
- *      } *      
+ *      } *
  *      // handle the other events here
  * };
  *
@@ -1922,7 +1922,7 @@ namespace AZ
  /**
  * Provides the same functionality of the AZ_EBUS_BEHAVIOR_BINDER macro above with the additional ability to specify the names and a tooltips of handler methods
  * after listing the handler method in the macro.
- * An example Usage is 
+ * An example Usage is
  * class MyEBusBehaviorHandler : public MyEBus::Handler, public AZ::BehaviorEBusHandler
  * {
  * public:
@@ -1930,7 +1930,7 @@ namespace AZ
  *            OnEvent2, ({#OnEvent2 first parameter name(float), #OnEvent2 first parameter tooltip(float)}, {#OnEvent2 second parameter name(bool), {#OnEvent2 second parameter tooltip(bool)}),
  *            OnEvent3, ());
  *      // The reason for needing parenthesis around the parameter name and tooltip object(AZ::BehaviorParameterOverrides) is to prevent the macro from parsing the comma in the intializer as seperate parameters
- *      // When using this macro, the BehaviorParameterOverrides objects must be placed after every listing a function as a handler. Furthermore the number of BehaviorParameterOverrides objects for each function must match the number of parameters 
+ *      // When using this macro, the BehaviorParameterOverrides objects must be placed after every listing a function as a handler. Furthermore the number of BehaviorParameterOverrides objects for each function must match the number of parameters
  *      // to that function
  *      // Ex. for a function called HugeEvent with a signature of void HugeEvent(int, float, double, char, short), two arguments must be supplied to the macro.
  *      // 1. HugeEvent
@@ -2181,7 +2181,7 @@ namespace AZ
     // Template implementations
     //////////////////////////////////////////////////////////////////////////
     //////////////////////////////////////////////////////////////////////////
-    
+
     //////////////////////////////////////////////////////////////////////////
     inline BehaviorObject::BehaviorObject()
         : m_address(nullptr)
@@ -2569,7 +2569,7 @@ namespace AZ
                     m_getter = nullptr;
                     return false;
                 }
-                
+
                 // assure that TR_THIS_PTR is set on the first parameter
                 m_getter->OverrideParameterTraits(0, AZ::BehaviorParameter::TR_THIS_PTR, 0);
             }
@@ -2847,7 +2847,7 @@ namespace AZ
     }
 
     //////////////////////////////////////////////////////////////////////////
-        
+
     template<class R, class... Args>
     void BehaviorEBusHandler::CallResult(R& result, int index, Args&&... args) const
     {
@@ -2904,7 +2904,7 @@ namespace AZ
         {
             return ClassBuilder<T>(this, static_cast<BehaviorClass*>(nullptr));
         }
-        
+
         auto classTypeIt = m_typeToClassMap.find(typeUuid);
         if (IsRemovingReflection())
         {
@@ -2933,7 +2933,7 @@ namespace AZ
                 // class already reflected, display name and uuid
                 char uuidName[AZ::Uuid::MaxStringBuffer];
                 classTypeIt->first.ToString(uuidName, AZ::Uuid::MaxStringBuffer);
-                
+
                 AZ_Error("Reflection", false, "Class '%s' is already registered using Uuid: %s!", name, uuidName);
                 return ClassBuilder<T>(this, static_cast<BehaviorClass*>(nullptr));
             }
@@ -3002,7 +3002,7 @@ namespace AZ
 
         if (m_class && (!Base::m_context->IsRemovingReflection()))
         {
-            for (auto method : m_class->m_methods)
+            for (const auto &method : m_class->m_methods)
             {
                 m_class->PostProcessMethod(Base::m_context, *method.second);
                 if (MethodReturnsAzEventByReferenceOrPointer(*method.second))
@@ -3485,7 +3485,7 @@ namespace AZ
         return this;
     }
 
-   
+
     //////////////////////////////////////////////////////////////////////////
     template<class T>
     BehaviorContext::EBusBuilder<T> BehaviorContext::EBus(const char* name, const char* deprecatedName /*=nullptr*/, const char* toolTip /*=nullptr*/)
@@ -3748,9 +3748,9 @@ namespace AZ
                     return this;
                 }
             }
-            
+
             m_ebus->m_virtualProperties.insert(AZStd::make_pair(name, BehaviorEBus::VirtualProperty(getter, setter)));
-        }        
+        }
         return this;
     }
 
@@ -3868,7 +3868,7 @@ namespace AZ
             SetParameters<R>(m_parameters, this);
             SetParameters<Args...>(&m_parameters[s_startNamedArgumentIndex], this);
         }
-        
+
         //////////////////////////////////////////////////////////////////////////
         template<class R, class... Args>
         bool BehaviorMethodImpl<R(Args...)>::Call(BehaviorValueParameter* arguments, unsigned int numArguments, BehaviorValueParameter* result) const
@@ -3876,7 +3876,7 @@ namespace AZ
             size_t totalArguments = GetNumArguments();
             if (numArguments < totalArguments)
             {
-                // We are cloning all arguments on the stack, since Call is called only from Invoke we can reserve bigger "arguments" array 
+                // We are cloning all arguments on the stack, since Call is called only from Invoke we can reserve bigger "arguments" array
                 // that can always handle all parameters. So far the don't use default values that ofter, so we will optimize for the common case first.
                 BehaviorValueParameter* newArguments = reinterpret_cast<BehaviorValueParameter*>(alloca(sizeof(BehaviorValueParameter)*  totalArguments));
                 // clone the input parameters (we don't need to clone temp buffers, etc. as they will be still on the stack)
@@ -4072,7 +4072,7 @@ namespace AZ
         {
             m_isConst = true;
         }
-        
+
         //////////////////////////////////////////////////////////////////////////
         template<class R, class C, class... Args>
         bool BehaviorMethodImpl<R(C::*)(Args...)>::Call(BehaviorValueParameter* arguments, unsigned int numArguments, BehaviorValueParameter* result) const
@@ -4080,7 +4080,7 @@ namespace AZ
             size_t totalArguments = GetNumArguments();
             if (numArguments < totalArguments)
             {
-                // We are cloning all arguments on the stack, since Call is called only from Invoke we can reserve bigger "arguments" array 
+                // We are cloning all arguments on the stack, since Call is called only from Invoke we can reserve bigger "arguments" array
                 // that can always handle all parameters. So far the don't use default values that ofter, so we will optimize for the common case first.
                 BehaviorValueParameter* newArguments = reinterpret_cast<BehaviorValueParameter*>(alloca(sizeof(BehaviorValueParameter)*  totalArguments));
                 // clone the input parameters (we don't need to clone temp buffers, etc. as they will be still on the stack)
@@ -4284,7 +4284,7 @@ namespace AZ
         {
             m_isConst = true;
         }
-        
+
         //////////////////////////////////////////////////////////////////////////
         template<class EBus, BehaviorEventType EventType, class R, class C, class... Args>
         template<bool IsBusId>
@@ -4307,7 +4307,7 @@ namespace AZ
             size_t totalArguments = GetNumArguments();
             if (numArguments < totalArguments)
             {
-                // We are cloning all arguments on the stack, since Call is called only from Invoke we can reserve bigger "arguments" array 
+                // We are cloning all arguments on the stack, since Call is called only from Invoke we can reserve bigger "arguments" array
                 // that can always handle all parameters. So far the don't use default values that ofter, so we will optimize for the common case first.
                 BehaviorValueParameter* newArguments = reinterpret_cast<BehaviorValueParameter*>(alloca(sizeof(BehaviorValueParameter)*  totalArguments));
                 // clone the input parameters (we don't need to clone temp buffers, etc. as they will be still on the stack)
@@ -4497,7 +4497,7 @@ namespace AZ
         template<class R, class... Args>
         void SetFunctionParameters<R(Args...)>::Set(AZStd::vector<BehaviorParameter>& params)
         {
-            // result, userdata, arguments  
+            // result, userdata, arguments
             params.resize(sizeof...(Args) + eBehaviorBusForwarderEventIndices::ParameterFirst);
             SetParameters<R>(&params[eBehaviorBusForwarderEventIndices::Result], nullptr);
             SetParameters<void*>(&params[eBehaviorBusForwarderEventIndices::UserData], nullptr);

Code/Framework/AzCore/AzCore/Script/ScriptContext.cpp

@@ -1463,9 +1463,9 @@ static void* LuaMemoryHook(void* userData, void* ptr, size_t osize, size_t nsize
         {
             allocator->DeAllocate(ptr);
         }
-        return NULL;
+        return nullptr;
     }
-    else if (ptr == NULL)
+    else if (ptr == nullptr)
     {
         return allocator->Allocate(nsize, LUA_DEFAULT_ALIGNMENT, 0, "Script", __FILE__, __LINE__, 1);
     }
@@ -1708,7 +1708,7 @@ LUA_API const Node* lua_getDummyNode()
                 "Invalid stack!");
             lua_pop(m_nativeContext, (currentTop - m_startVariableIndex) + 1);
 
-            m_nativeContext = NULL;
+            m_nativeContext = nullptr;
             m_startVariableIndex = 0;
             m_numArguments = 0;
             m_numResults = 0;
@@ -2038,7 +2038,7 @@ LUA_API const Node* lua_getDummyNode()
         LSV_BEGIN_VARIABLE(m_nativeContext);
 
         valueIndex = 0;
-        name = NULL;
+        name = nullptr;
         index = -1;
         if (m_mode == MD_INSPECT)
         {

Code/Framework/AzCore/AzCore/Script/ScriptContextDebug.cpp

@@ -43,7 +43,7 @@ public:
         , m_numErrors(0)
     {
         using namespace AZStd::placeholders;
-        m_context->SetErrorHook(AZStd::bind(&ScriptErrorCatcher::ErrorCB, this, _1, _2, _3));
+        m_context->SetErrorHook([this](ScriptContext* a, ScriptContext::ErrorType b, const char* c) { ErrorCB(a,b,c); });
     }
     ~ScriptErrorCatcher()
     {
@@ -66,7 +66,7 @@ public:
 // [6/29/2012]
 //=========================================================================
 ScriptContextDebug::ScriptContextDebug(ScriptContext& scriptContext, bool isEnableStackRecord)
-    : m_luaDebug(NULL)
+    : m_luaDebug(nullptr)
     , m_currentStackLevel(-1)
     , m_stepStackLevel(-1)
     , m_isRecordCallstack(isEnableStackRecord)
@@ -104,7 +104,7 @@ void ScriptContextDebug::ConnectHook()
 //=========================================================================
 void ScriptContextDebug::DisconnectHook()
 {
-    lua_sethook(m_context.NativeContext(), 0, 0, 0);
+    lua_sethook(m_context.NativeContext(), nullptr, 0, 0);
 }
 
 //=========================================================================
@@ -149,7 +149,7 @@ ScriptContextDebug::EnumRegisteredClasses(EnumClass enumClass, EnumMethod enumMe
 
             lua_rawgeti(l, -2, AZ_LUA_CLASS_METATABLE_NAME_INDEX); // load class name
             AZ_Assert(lua_isstring(l, -1), "Internal scipt error: class without a classname at index %d", AZ_LUA_CLASS_METATABLE_NAME_INDEX);
-            
+
             if (!enumClass(lua_tostring(l, -1), behaviorClass->m_typeId, userData))
             {
                 lua_pop(l, 5);
@@ -199,7 +199,7 @@ ScriptContextDebug::EnumRegisteredClasses(EnumClass enumClass, EnumMethod enumMe
                         // for any non-built in methods
                         if (strncmp(name, "__", 2) != 0)
                         {
-                            const char* dbgParamInfo = NULL;
+                            const char* dbgParamInfo = nullptr;
 
                             // attempt to get the name
                             bool popDebugName = lua_getupvalue(l, -1, 2) != nullptr;
@@ -278,7 +278,7 @@ ScriptContextDebug::EnumRegisteredGlobals(EnumMethod enumMethod, EnumProperty en
             {
                 if (strncmp(name, "__", 2) != 0)
                 {
-                    const char* dbgParamInfo = NULL;
+                    const char* dbgParamInfo = nullptr;
                     lua_getupvalue(l, -1, 2);
                     if (lua_isstring(l, -1))
                     {
@@ -606,7 +606,7 @@ void AZ::LuaHook(lua_State* l, lua_Debug* ar)
     lua_pop(l, 1);
     //
     bool doBreak = false;
-    ScriptContextDebug::Breakpoint* bp = NULL;
+    ScriptContextDebug::Breakpoint* bp = nullptr;
     ScriptContextDebug::Breakpoint  localBreakPoint;
 
     lua_getinfo(l, "Sunl", ar);
@@ -735,7 +735,7 @@ void AZ::LuaHook(lua_State* l, lua_Debug* ar)
     {
         context->m_luaDebug = ar;
         context->m_breakCallback(context, bp);
-        context->m_luaDebug = NULL;
+        context->m_luaDebug = nullptr;
     }
 }
 
@@ -752,7 +752,7 @@ ScriptContextDebug::EnumLocals(EnumLocalCallback& cb)
         int local = 1;
         const char* name;
         ScriptDataContext dc;
-        while ((name = lua_getlocal(l, m_luaDebug, local)) != NULL)
+        while ((name = lua_getlocal(l, m_luaDebug, local)) != nullptr)
         {
             if (name[0] != '(') // skip temporary variables
             {
@@ -846,7 +846,7 @@ ScriptContextDebug::EnableBreakpoints(BreakpointCallback& cb)
 void
 ScriptContextDebug::DisableBreakpoints()
 {
-    m_breakCallback = NULL;
+    m_breakCallback = nullptr;
 }
 
 //=========================================================================
@@ -1079,7 +1079,7 @@ ScriptContextDebug::WriteValue(const DebugValue& value, const char* valueName, i
     int valueTableIndex = -1;
     if (valueName[0] == '[')
     {
-        valueTableIndex = static_cast<int>(strtol(valueName + 1, NULL, 10));
+        valueTableIndex = static_cast<int>(strtol(valueName + 1, nullptr, 10));
     }
     if (strcmp(valueName, "__metatable__") == 0) // metatable are read only
     {
@@ -1114,7 +1114,7 @@ ScriptContextDebug::WriteValue(const DebugValue& value, const char* valueName, i
     } break;
     case LUA_TNUMBER:
     {
-        lua_pushnumber(l, static_cast<lua_Number>(strtod(value.m_value.c_str(), NULL)));
+        lua_pushnumber(l, static_cast<lua_Number>(strtod(value.m_value.c_str(), nullptr)));
         if (localIndex != -1)
         {
             lua_setlocal(l, m_luaDebug, localIndex);
@@ -1256,7 +1256,7 @@ ScriptContextDebug::WriteValue(const DebugValue& value, const char* valueName, i
                                 else
                                 {
                                     lua_pushvalue(l, -5);    // copy the user data (this pointer)
-                                    lua_pushnumber(l, static_cast<lua_Number>(strtod(subElement.m_value.c_str(), NULL)));
+                                    lua_pushnumber(l, static_cast<lua_Number>(strtod(subElement.m_value.c_str(), nullptr)));
                                     lua_call(l, 2, 0);   // call the setter
                                 }
                                 break;
@@ -1375,7 +1375,7 @@ ScriptContextDebug::GetValue(DebugValue& value)
     {
         int iLocal = 1;
         const char* localName;
-        while ((localName = lua_getlocal(l, m_luaDebug, iLocal)) != NULL)
+        while ((localName = lua_getlocal(l, m_luaDebug, iLocal)) != nullptr)
         {
             if (localName[0] != '(' && strcmp(name, localName) == 0)
             {
@@ -1460,7 +1460,7 @@ ScriptContextDebug::SetValue(const DebugValue& sourceValue)
     // create hierarchy from tokens
     const DebugValue* value = &sourceValue;
     DebugValue untokenizedValue;
-    
+
     if (tokens.size() > 1)
     {
         untokenizedValue.m_name = tokens[0];
@@ -1519,7 +1519,7 @@ ScriptContextDebug::SetValue(const DebugValue& sourceValue)
     {
         int iLocal = 1;
         const char* localName;
-        while ((localName = lua_getlocal(l, m_luaDebug, iLocal)) != NULL)
+        while ((localName = lua_getlocal(l, m_luaDebug, iLocal)) != nullptr)
         {
             lua_pop(l, 1);
             if (localName[0] != '(' && strcmp(name, localName) == 0)

Code/Framework/AzCore/AzCore/Serialization/SerializationUtils.cpp

@@ -42,7 +42,7 @@ namespace AZ
             AZ_Assert(targetPointer, "You must provide a target pointer");
 
             bool foundSuccess = false;
-            typedef AZStd::function<void(void**, const SerializeContext::ClassData**, const Uuid&, SerializeContext*)> CreationCallback;
+            using CreationCallback = AZStd::function<void (void **, const SerializeContext::ClassData **, const Uuid &, SerializeContext *)>;
             auto handler = [&targetPointer, objectClassData, &foundSuccess](void** instance, const SerializeContext::ClassData** classData, const Uuid& classId, SerializeContext* context)
                 {
                     void* convertibleInstance{};

Code/Framework/AzCore/AzCore/Serialization/SerializeContext.cpp

@@ -91,7 +91,7 @@ namespace AZ
         {
             AZ_Assert(textVersion == 0, "Unknown char, short, int version!");
             (void)textVersion;
-            long value = strtol(text, NULL, 10);
+            long value = strtol(text, nullptr, 10);
             AZ_SERIALIZE_SWAP_ENDIAN(value, isDataBigEndian);
             return static_cast<size_t>(stream.Write(sizeof(T), reinterpret_cast<void*>(&value)));
         }
@@ -124,7 +124,7 @@ namespace AZ
         {
             AZ_Assert(textVersion == 0, "Unknown unsigned char, short, int version!");
             (void)textVersion;
-            unsigned long value = strtoul(text, NULL, 10);
+            unsigned long value = strtoul(text, nullptr, 10);
             AZ_SERIALIZE_SWAP_ENDIAN(value, isDataBigEndian);
             return static_cast<size_t>(stream.Write(sizeof(T), reinterpret_cast<void*>(&value)));
         }
@@ -158,7 +158,7 @@ namespace AZ
         {
             AZ_Assert(textVersion == 0, "Unknown unsigned char, short, int version!");
             (void)textVersion;
-            long value = strtol(text, NULL, 10);
+            long value = strtol(text, nullptr, 10);
             AZ_SERIALIZE_SWAP_ENDIAN(value, isDataBigEndian);
             return static_cast<size_t>(stream.Write(sizeof(T), reinterpret_cast<void*>(&value)));
         }
@@ -192,7 +192,7 @@ namespace AZ
         {
             AZ_Assert(textVersion == 0, "Unknown unsigned char, short, int version!");
             (void)textVersion;
-            unsigned long value = strtoul(text, NULL, 10);
+            unsigned long value = strtoul(text, nullptr, 10);
             AZ_SERIALIZE_SWAP_ENDIAN(value, isDataBigEndian);
             return static_cast<size_t>(stream.Write(sizeof(T), reinterpret_cast<void*>(&value)));
         }
@@ -225,7 +225,7 @@ namespace AZ
         {
             AZ_Assert(textVersion == 0, "Unknown unsigned char, short, int version!");
             (void)textVersion;
-            AZ::s64 value = strtoll(text, NULL, 10);
+            AZ::s64 value = strtoll(text, nullptr, 10);
             AZ_SERIALIZE_SWAP_ENDIAN(value, isDataBigEndian);
             return static_cast<size_t>(stream.Write(sizeof(AZ::s64), reinterpret_cast<void*>(&value)));
         }
@@ -258,7 +258,7 @@ namespace AZ
         {
             AZ_Assert(textVersion == 0, "Unknown unsigned char, short, int version!");
             (void)textVersion;
-            unsigned long long value = strtoull(text, NULL, 10);
+            unsigned long long value = strtoull(text, nullptr, 10);
             AZ_SERIALIZE_SWAP_ENDIAN(value, isDataBigEndian);
             return static_cast<size_t>(stream.Write(sizeof(AZ::u64), reinterpret_cast<void*>(&value)));
         }
@@ -292,7 +292,7 @@ namespace AZ
         {
             AZ_Assert(textVersion == 0, "Unknown float/double version!");
             (void)textVersion;
-            double value = strtod(text, NULL);
+            double value = strtod(text, nullptr);
             AZ_SERIALIZE_SWAP_ENDIAN(value, isDataBigEndian);
 
             T data = static_cast<T>(value);
@@ -815,7 +815,7 @@ namespace AZ
             const ClassData* fromClass = FindClassData(fromClassId);
             if (!fromClass)
             {
-                return NULL;
+                return nullptr;
             }
 
             for (size_t i = 0; i < fromClass->m_elements.size(); ++i)
@@ -831,7 +831,7 @@ namespace AZ
 
             if (!fromClass->m_azRtti)
             {
-                return NULL;    // Reflection info failed to cast and we can't find rtti info
+                return nullptr;    // Reflection info failed to cast and we can't find rtti info
             }
             fromClassHelper = fromClass->m_azRtti;
         }
@@ -841,7 +841,7 @@ namespace AZ
             const ClassData* toClass = FindClassData(toClassId);
             if (!toClass || !toClass->m_azRtti)
             {
-                return NULL;    // We can't cast without class data or rtti helper
+                return nullptr;    // We can't cast without class data or rtti helper
             }
             toClassHelper = toClass->m_azRtti;
         }
@@ -855,7 +855,7 @@ namespace AZ
     // [5/22/2012]
     //=========================================================================
     SerializeContext::DataElement::DataElement()
-        : m_name(0)
+        : m_name(nullptr)
         , m_nameCrc(0)
         , m_dataSize(0)
         , m_byteStream(&m_buffer)
@@ -1045,7 +1045,7 @@ namespace AZ
     //=========================================================================
     bool SerializeContext::DataElementNode::Convert(SerializeContext& sc, const char* name, const Uuid& id)
     {
-        AZ_Assert(name != NULL && strlen(name) > 0, "Empty name is an INVALID element name!");
+        AZ_Assert(name != nullptr && strlen(name) > 0, "Empty name is an INVALID element name!");
         u32 nameCrc = Crc32(name);
 
 #if defined(AZ_ENABLE_TRACING)
@@ -1165,7 +1165,7 @@ namespace AZ
     int SerializeContext::DataElementNode::AddElement(SerializeContext& sc, const char* name, const ClassData& classData)
     {
         (void)sc;
-        AZ_Assert(name != NULL && strlen(name) > 0, "Empty name is an INVALID element name!");
+        AZ_Assert(name != nullptr && strlen(name) > 0, "Empty name is an INVALID element name!");
         u32 nameCrc = Crc32(name);
 
     #if defined(AZ_ENABLE_TRACING)
@@ -1703,7 +1703,7 @@ namespace AZ
 
         m_classData->second.m_serializer = AZStd::move(serializer);
         return this;
-        
+
     }
 
     //=========================================================================
@@ -1801,7 +1801,7 @@ namespace AZ
         void* objectPtr = ptr;
         const AZ::Uuid* classIdPtr = &classId;
         const SerializeContext::ClassData* dataClassInfo = classData;
-        
+
         if (classElement)
         {
             // if we are a pointer, then we may be pointing to a derived type.
@@ -1854,14 +1854,14 @@ namespace AZ
             DbgStackEntry de;
             de.m_dataPtr = objectPtr;
             de.m_uuidPtr = classIdPtr;
-            de.m_elementName = classElement ? classElement->m_name : NULL;
+            de.m_elementName = classElement ? classElement->m_name : nullptr;
             de.m_classData = dataClassInfo;
             de.m_classElement = classElement;
             callContext->m_errorHandler->Push(de);
         }
     #endif // AZ_ENABLE_SERIALIZER_DEBUG
 
-        if (dataClassInfo == NULL)
+        if (dataClassInfo == nullptr)
         {
     #if defined (AZ_ENABLE_SERIALIZER_DEBUG)
             AZStd::string error;
@@ -2182,9 +2182,9 @@ namespace AZ
 
     AZ::SerializeContext::DataPatchUpgradeHandler::~DataPatchUpgradeHandler()
     {
-        for (auto fieldUpgrades : m_upgrades)
+        for (const auto& fieldUpgrades : m_upgrades)
         {
-            for (auto versionUpgrades : fieldUpgrades.second)
+            for (const auto& versionUpgrades : fieldUpgrades.second)
             {
                 for (auto* upgrade : versionUpgrades.second)
                 {
@@ -2192,8 +2192,8 @@ namespace AZ
                 }
             }
         }
-    }           
-    
+    }
+
     void AZ::SerializeContext::DataPatchUpgradeHandler::AddFieldUpgrade(DataPatchUpgrade* upgrade)
     {
         // Find the field
@@ -2448,7 +2448,7 @@ namespace AZ
             classData->m_eventHandler->OnWriteEnd(dataPtr);
             classData->m_eventHandler->OnObjectCloned(dataPtr);
         }
-        
+
         if (classData->m_serializer)
         {
             classData->m_serializer->PostClone(dataPtr);
@@ -2489,7 +2489,7 @@ namespace AZ
             {
                 if (cd.m_azRtti->IsTypeOf(typeId))
                 {
-                    if (!callback(&cd, 0))
+                    if (!callback(&cd, nullptr))
                     {
                         return;
                     }
@@ -2507,7 +2507,7 @@ namespace AZ
                             // if both classes have azRtti they will be enumerated already by the code above (azrtti)
                             if (cd.m_azRtti == nullptr || cd.m_elements[i].m_azRtti == nullptr)
                             {
-                                if (!callback(&cd, 0))
+                                if (!callback(&cd, nullptr))
                                 {
                                     return;
                                 }
@@ -2539,7 +2539,7 @@ namespace AZ
                     if (baseClassData)
                     {
                         callbackData.m_reportedTypes.push_back(baseClassData->m_typeId);
-                        if (!callback(baseClassData, 0))
+                        if (!callback(baseClassData, nullptr))
                         {
                             return;
                         }
@@ -2586,8 +2586,8 @@ namespace AZ
     void SerializeContext::RegisterDataContainer(AZStd::unique_ptr<IDataContainer> dataContainer)
     {
         m_dataContainers.push_back(AZStd::move(dataContainer));
-    } 
-    
+    }
+
     //=========================================================================
     // EnumerateBaseRTTIEnumCallback
     // [11/13/2012]
@@ -2731,10 +2731,10 @@ namespace AZ
     //=========================================================================
     void SerializeContext::IDataContainer::DeletePointerData(SerializeContext* context, const ClassElement* classElement, const void* element)
     {
-        AZ_Assert(context != NULL && classElement != NULL && element != NULL, "Invalid input");
+        AZ_Assert(context != nullptr && classElement != nullptr && element != nullptr, "Invalid input");
         const AZ::Uuid* elemUuid = &classElement->m_typeId;
         // find the class data for the specific element
-        const SerializeContext::ClassData* classData = classElement->m_genericClassInfo ? classElement->m_genericClassInfo->GetClassData() : context->FindClassData(*elemUuid, NULL, 0);
+        const SerializeContext::ClassData* classData = classElement->m_genericClassInfo ? classElement->m_genericClassInfo->GetClassData() : context->FindClassData(*elemUuid, nullptr, 0);
         if (classElement->m_flags & SerializeContext::ClassElement::FLG_POINTER)
         {
             const void* dataPtr = *reinterpret_cast<void* const*>(element);
@@ -2745,7 +2745,7 @@ namespace AZ
                 if (*actualClassId != *elemUuid)
                 {
                     // we are pointing to derived type, adjust class data, uuid and pointer.
-                    classData = context->FindClassData(*actualClassId, NULL, 0);
+                    classData = context->FindClassData(*actualClassId, nullptr, 0);
                     elemUuid = actualClassId;
                     if (classData)
                     {
@@ -2754,7 +2754,7 @@ namespace AZ
                 }
             }
         }
-        if (classData == NULL)
+        if (classData == nullptr)
         {
             if ((classElement->m_flags & ClassElement::FLG_POINTER) != 0)
             {
@@ -3250,7 +3250,7 @@ namespace AZ
         return m_moduleOSAllocator;
     }
 
-    // Take advantage of static variables being unique per dll module to clean up module specific registered classes when the module unloads 
+    // Take advantage of static variables being unique per dll module to clean up module specific registered classes when the module unloads
     SerializeContext::PerModuleGenericClassInfo& GetCurrentSerializeContextModule()
     {
         static SerializeContext::PerModuleGenericClassInfo s_ModuleCleanupInstance;

Code/Framework/AzCore/AzCore/Serialization/SerializeContext.h

@@ -602,7 +602,7 @@ namespace AZ
             ///< @param resultPtr output parameter that is populated with the memory address that can be used to store an element of the convertible type
             ///< @param convertibleTypeId type to check to determine if it can converted to an element of class represent by this Class Data
             ///< @param classPtr memory address of the class represented by the ClassData
-            ///< @return true if a non-null memory address has been returned that can store the  convertible type 
+            ///< @return true if a non-null memory address has been returned that can store the  convertible type
             bool ConvertFromType(void*& convertibleTypePtr, const TypeId& convertibleTypeId, void* classPtr, AZ::SerializeContext& serializeContext) const;
 
             /// Find the persistence id (check base classes) \todo this is a TEMP fix, analyze and cache that information in the class
@@ -797,8 +797,8 @@ namespace AZ
             virtual void*   ReserveElement(void* instance, const ClassElement* classElement) = 0;
             /// Free an element that was reserved using ReserveElement, but was not stored by calling StoreElement.
             virtual void    FreeReservedElement(void* instance, void* element, SerializeContext* deletePointerDataContext)
-            { 
-                RemoveElement(instance, element, deletePointerDataContext); 
+            {
+                RemoveElement(instance, element, deletePointerDataContext);
             }
             /// Get an element's address by its index (called before the element is loaded).
             virtual void*   GetElementByIndex(void* instance, const ClassElement* classElement, size_t index) = 0;
@@ -858,7 +858,7 @@ namespace AZ
 
         /**
          * Data Converter interface which can be used to provide a conversion operation from to unrelated C++ types
-         * derived class to base class casting is taken care of through the RTTI system so those relations should not be 
+         * derived class to base class casting is taken care of through the RTTI system so those relations should not be
          * check within this class
          */
         class IDataConverter
@@ -879,7 +879,7 @@ namespace AZ
             ///< @param convertibleTypeId type to check to determine if it can converted to an element of class represent by this Class Data
             ///< @param classPtr memory address of the class represented by the @classData type
             ///< @param classData reference to the metadata representing the type stored in classPtr
-            ///< @return true if a non-null memory address has been returned that can store the convertible type 
+            ///< @return true if a non-null memory address has been returned that can store the convertible type
             virtual bool ConvertFromType(void*& convertibleTypePtr, const TypeId& convertibleTypeId, void* classPtr, const SerializeContext::ClassData& classData, SerializeContext& /*serializeContext*/)
             {
                 if (classData.m_typeId == convertibleTypeId)
@@ -1054,7 +1054,7 @@ namespace AZ
         AZStd::vector<AZ::Uuid> FindClassId(const AZ::Crc32& classNameCrc) const;
 
         /// Find GenericClassData data based on the supplied class ID
-        GenericClassInfo* FindGenericClassInfo(const Uuid& classId) const; 
+        GenericClassInfo* FindGenericClassInfo(const Uuid& classId) const;
 
         /// Creates an AZStd::any based on the provided class Uuid, or returns an empty AZStd::any if no class data is found or the class is virtual
         AZStd::any CreateAny(const Uuid& classId);
@@ -1161,7 +1161,7 @@ namespace AZ
 
             /* Declare a name change of a serialized field
              *  These are used by the serializer to repair old data patches
-             *  
+             *
              */
             ClassBuilder* NameChange(unsigned int fromVersion, unsigned int toVersion, AZStd::string_view oldFieldName, AZStd::string_view newFieldName);
 
@@ -1403,7 +1403,7 @@ namespace AZ
     template<class ValueType>
     struct SerializeGenericTypeInfo
     {
-        // Provides a specific type alias that can be used to create GenericClassInfo of the 
+        // Provides a specific type alias that can be used to create GenericClassInfo of the
         // specified type. By default this is GenericClassInfo class which is abstract
         using ClassInfoType = GenericClassInfo;
 
@@ -1938,7 +1938,7 @@ namespace AZ
         if (m_context->IsRemovingReflection())
         {
             // Delete any attributes allocated for this call.
-            for (auto attributePair : attributes)
+            for (auto& attributePair : attributes)
             {
                 delete attributePair.second;
             }
@@ -1955,7 +1955,7 @@ namespace AZ
             m_classData->second.m_name,
             AzTypeInfo<ClassType>::Name());
 
-        // SerializeGenericTypeInfo<ValueType>::GetClassTypeId() is needed solely because 
+        // SerializeGenericTypeInfo<ValueType>::GetClassTypeId() is needed solely because
         // the SerializeGenericTypeInfo specialization for AZ::Data::Asset<T> returns the GetAssetClassId() value
         // and not the AzTypeInfo<AZ::Data::Asset<T>>::Uuid()
         // Therefore in order to remain backwards compatible the SerializeGenericTypeInfo<ValueType>::GetClassTypeId specialization

Code/Framework/AzCore/AzCore/Settings/SettingsRegistryMergeUtils.cpp

@@ -1004,7 +1004,7 @@ namespace AZ::SettingsRegistryMergeUtils
             }
             AZ::SettingsRegistryInterface::VisitResponse Traverse(
                 AZStd::string_view path, AZStd::string_view valueName, AZ::SettingsRegistryInterface::VisitAction action,
-                AZ::SettingsRegistryInterface::Type type)
+                AZ::SettingsRegistryInterface::Type type) override
             {
                 // Pass the pointer path to the inclusion filter if available
                 if (m_dumperSettings.m_includeFilter && !m_dumperSettings.m_includeFilter(path))
@@ -1058,7 +1058,7 @@ namespace AZ::SettingsRegistryMergeUtils
                     AZ::SettingsRegistryInterface::VisitResponse::Done;
             }
 
-            void Visit(AZStd::string_view, AZStd::string_view valueName, AZ::SettingsRegistryInterface::Type, bool value)
+            void Visit(AZStd::string_view, AZStd::string_view valueName, AZ::SettingsRegistryInterface::Type, bool value) override
             {
                 m_result = m_result && WriteName(valueName) && m_writer.Bool(value);
             }
@@ -1073,12 +1073,12 @@ namespace AZ::SettingsRegistryMergeUtils
                 m_result = m_result && WriteName(valueName) && m_writer.Uint64(value);
             }
 
-            void Visit(AZStd::string_view, AZStd::string_view valueName, AZ::SettingsRegistryInterface::Type, double value)
+            void Visit(AZStd::string_view, AZStd::string_view valueName, AZ::SettingsRegistryInterface::Type, double value) override
             {
                 m_result = m_result && WriteName(valueName) && m_writer.Double(value);
             }
 
-            void Visit(AZStd::string_view, AZStd::string_view valueName, AZ::SettingsRegistryInterface::Type, AZStd::string_view value)
+            void Visit(AZStd::string_view, AZStd::string_view valueName, AZ::SettingsRegistryInterface::Type, AZStd::string_view value) override
             {
                 m_result = m_result && WriteName(valueName) && m_writer.String(value.data(), aznumeric_caster(value.size()));
             }

Code/Framework/AzCore/AzCore/State/HSM.cpp

@@ -187,7 +187,7 @@ void
 HSM::ClearStateHandler(StateId id)
 {
     m_states[id].handler.clear();
-    m_states[id].name = NULL;
+    m_states[id].name = nullptr;
     m_states[id].superId = InvalidStateId;
 }
 

Code/Framework/AzCore/AzCore/State/HSM.h

@@ -103,13 +103,10 @@ namespace AZ
 
         struct State
         {
-            State()
-                : superId(InvalidStateId)
-                , name(NULL) {}
             StateHandler handler;
-            StateId      superId;   ///< State id of the super state, InvalidStateId if this is a top state InvalidStateId.
-            StateId      subId;     ///< If != InvalidStateId it will enter the sub ID after the state Enter event is called.
-            const char*  name;
+            StateId      superId = InvalidStateId;   ///< State id of the super state, InvalidStateId if this is a top state InvalidStateId.
+            StateId      subId = InvalidStateId;     ///< If != InvalidStateId it will enter the sub ID after the state Enter event is called.
+            const char*  name = nullptr;
         };
         AZStd::array<State, MaxNumberOfStates>   m_states;
     };

Code/Framework/AzCore/AzCore/UserSettings/UserSettingsProvider.cpp

@@ -81,8 +81,12 @@ namespace AZ
             if (settingsFile.IsOpen())
             {
                 IO::SystemFileStream settingsFileStream(&settingsFile, false);
-                ObjectStream::ClassReadyCB readyCB(AZStd::bind(&UserSettingsProvider::OnSettingLoaded, this, AZStd::placeholders::_1, AZStd::placeholders::_2, AZStd::placeholders::_3));
-               
+                ObjectStream::ClassReadyCB readyCB(
+                    [this](void* classPtr, const Uuid& classId, const SerializeContext* sc)
+                    {
+                        OnSettingLoaded(classPtr, classId, sc);
+                    });
+
                 // do not try to load assets during User Settings Provider bootup - we are still initializing the application!
                 // in addition, the file may contain settings we don't understand, from other applications - don't error on those.
                 settingsLoaded = ObjectStream::LoadBlocking(&settingsFileStream, *sc, readyCB, ObjectStream::FilterDescriptor(&AZ::Data::AssetFilterNoAssetLoading, AZ::ObjectStream::FILTERFLAG_IGNORE_UNKNOWN_CLASSES));
@@ -104,7 +108,7 @@ namespace AZ
         {
             AZStd::vector<char> saveBuffer;
             AZ::IO::ByteContainerStream<AZStd::vector<char>> byteStream(&saveBuffer);
-            
+
             ObjectStream* objStream = ObjectStream::Create(&byteStream, *sc, ObjectStream::ST_XML);
             bool writtenOk = objStream->WriteClass(&m_settings);
             bool streamOk = objStream->Finalize();

Code/Framework/AzCore/AzCore/std/function/function_base.h

@@ -23,7 +23,7 @@
 #include <AzCore/std/createdestroy.h>
 
 #define AZSTD_FUNCTION_TARGET_FIX(x)
-#define AZSTD_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, Type)  AZStd::enable_if_t<!std::is_integral_v<Functor>, Type>
+#define AZSTD_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, Type)  AZStd::enable_if_t<!std::is_integral_v<Functor> && !std::is_null_pointer_v<Functor>, Type>
 
 
 

Code/Framework/AzCore/AzCore/std/function/function_template.h

@@ -531,7 +531,7 @@ namespace AZStd
             //! A static vtable is used to avoid the need to dynamically allocate a vtable
             //! whose purpose is to contain a function ptr that can the manage the function buffer
             //! i.e performs the copy, move and destruction operations for the function buffer
-            //! as well as to validate if a the stored function can be type_cast to the type supplied in 
+            //! as well as to validate if a the stored function can be type_cast to the type supplied in
             //! std::function::target
             //! The vtable other purpose is to store a function ptr that is used to wrap the invocation of the underlying function
             static vtable_type stored_vtable = get_invoker::template create_vtable<decay_t<Functor>>();
@@ -556,7 +556,7 @@ namespace AZStd
             //! A static vtable is used to avoid the need to dynamically allocate a vtable
             //! whose purpose is to contain a function ptr that can the manage the function buffer
             //! i.e performs the copy, move and destruction operations for the function buffer
-            //! as well as to validate if a the stored function can be type_cast to the type supplied in 
+            //! as well as to validate if a the stored function can be type_cast to the type supplied in
             //! std::function::target
             //! The vtable other purpose is to store a function ptr that is used to wrap the invocation of the underlying function
             static vtable_type stored_vtable = get_invoker::template create_vtable<decay_t<Functor>>();
@@ -633,7 +633,7 @@ namespace AZStd
         {}
 
         function(nullptr_t)
-            : base_type() {}
+            : base_type(nullptr) {}
         function(const self_type& f)
             : base_type(static_cast<const base_type&>(f)){}
         function(const base_type& f)
@@ -678,7 +678,7 @@ namespace AZStd
             return *this;
         }
 
-        R operator()(Args... args) const 
+        R operator()(Args... args) const
         {
             return base_type::operator()(AZStd::forward<Args>(args)...);
         }

Code/Framework/AzCore/AzCore/std/string/regex.cpp

@@ -31,7 +31,7 @@ namespace AZStd
         AZ_REGEX_CHAR_CLASS_NAME("upper", RegexTraits<char>::Ch_upper),
         AZ_REGEX_CHAR_CLASS_NAME("w", RegexTraits<char>::Ch_invalid),
         AZ_REGEX_CHAR_CLASS_NAME("xdigit", RegexTraits<char>::Ch_xdigit),
-        {0, 0, 0},
+        {nullptr, 0, 0},
     };
 
     template<>
@@ -52,7 +52,7 @@ namespace AZStd
         AZ_REGEX_CHAR_CLASS_NAME(L"upper", RegexTraits<wchar_t>::Ch_upper),
         AZ_REGEX_CHAR_CLASS_NAME(L"w", RegexTraits<char>::Ch_invalid),
         AZ_REGEX_CHAR_CLASS_NAME(L"xdigit", RegexTraits<wchar_t>::Ch_xdigit),
-        {0, 0, 0},
+        {nullptr, 0, 0},
     };
     #undef AZ_REGEX_CHAR_CLASS_NAME
 } // namespace AZStd