replaced std::size() with AI_COUNT_OF for pre-C++20 compilers

code/AssetLib/3DS/3DSLoader.cpp

@@ -113,7 +113,7 @@ Discreet3DSImporter::~Discreet3DSImporter() {
 // Returns whether the class can handle the format of the given file.
 bool Discreet3DSImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*checkSig*/) const {
     static const uint16_t token[] = { 0x4d4d, 0x3dc2 /*, 0x3daa */ };
-    return CheckMagicToken(pIOHandler, pFile, token, std::size(token), 0, sizeof token[0]);
+    return CheckMagicToken(pIOHandler, pFile, token, AI_COUNT_OF(token), 0, sizeof token[0]);
 }
 
 // ------------------------------------------------------------------------------------------------

code/AssetLib/AC/ACLoader.cpp

@@ -154,7 +154,7 @@ AC3DImporter::~AC3DImporter() {
 // Returns whether the class can handle the format of the given file.
 bool AC3DImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*checkSig*/) const {
     static const uint32_t tokens[] = { AI_MAKE_MAGIC("AC3D") };
-    return CheckMagicToken(pIOHandler, pFile, tokens, std::size(tokens));
+    return CheckMagicToken(pIOHandler, pFile, tokens, AI_COUNT_OF(tokens));
 }
 
 // ------------------------------------------------------------------------------------------------

code/AssetLib/AMF/AMFImporter.cpp

@@ -504,7 +504,7 @@ void AMFImporter::ParseNode_Metadata(XmlNode &node) {
 
 bool AMFImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*pCheckSig*/) const {
     static const char *tokens[] = { "<amf" };
-    return SearchFileHeaderForToken(pIOHandler, pFile, tokens, std::size(tokens));
+    return SearchFileHeaderForToken(pIOHandler, pFile, tokens, AI_COUNT_OF(tokens));
 }
 
 const aiImporterDesc *AMFImporter::GetInfo() const {

code/AssetLib/ASE/ASELoader.cpp

@@ -99,7 +99,7 @@ ASEImporter::~ASEImporter() {
 // Returns whether the class can handle the format of the given file.
 bool ASEImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*checkSig*/) const {
     static const char *tokens[] = { "*3dsmax_asciiexport" };
-    return SearchFileHeaderForToken(pIOHandler, pFile, tokens, std::size(tokens));
+    return SearchFileHeaderForToken(pIOHandler, pFile, tokens, AI_COUNT_OF(tokens));
 }
 
 // ------------------------------------------------------------------------------------------------

code/AssetLib/BVH/BVHLoader.cpp

@@ -94,7 +94,7 @@ BVHLoader::~BVHLoader() {}
 // Returns whether the class can handle the format of the given file.
 bool BVHLoader::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*checkSig*/) const {
     static const char *tokens[] = { "HIERARCHY" };
-    return SearchFileHeaderForToken(pIOHandler, pFile, tokens, std::size(tokens));
+    return SearchFileHeaderForToken(pIOHandler, pFile, tokens, AI_COUNT_OF(tokens));
 }
 
 // ------------------------------------------------------------------------------------------------

code/AssetLib/Blender/BlenderLoader.cpp

@@ -120,7 +120,7 @@ static const char *TokensForSearch[] = { "blender" };
 // Returns whether the class can handle the format of the given file.
 bool BlenderImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*checkSig*/) const {
     // note: this won't catch compressed files
-    return SearchFileHeaderForToken(pIOHandler, pFile, TokensForSearch, std::size(TokensForSearch));
+    return SearchFileHeaderForToken(pIOHandler, pFile, TokensForSearch, AI_COUNT_OF(TokensForSearch));
 }
 
 // ------------------------------------------------------------------------------------------------

code/AssetLib/COB/COBLoader.cpp

@@ -105,7 +105,7 @@ COBImporter::~COBImporter() {
 // Returns whether the class can handle the format of the given file.
 bool COBImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*checkSig*/) const {
     static const char *tokens[] = { "Caligary" };
-    return SearchFileHeaderForToken(pIOHandler, pFile, tokens, std::size(tokens));
+    return SearchFileHeaderForToken(pIOHandler, pFile, tokens, AI_COUNT_OF(tokens));
 }
 
 // ------------------------------------------------------------------------------------------------

code/AssetLib/CSM/CSMLoader.cpp

@@ -93,7 +93,7 @@ CSMImporter::~CSMImporter()
 bool CSMImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler, bool /*checkSig*/) const
 {
     static const char* tokens[] = {"$Filename"};
-    return SearchFileHeaderForToken(pIOHandler,pFile,tokens,std::size(tokens));
+    return SearchFileHeaderForToken(pIOHandler,pFile,tokens,AI_COUNT_OF(tokens));
 }
 
 // ------------------------------------------------------------------------------------------------

code/AssetLib/Collada/ColladaLoader.cpp

@@ -125,7 +125,7 @@ bool ColladaLoader::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool
     }
 
     static const char *tokens[] = { "<collada" };
-    return SearchFileHeaderForToken(pIOHandler, pFile, tokens, std::size(tokens));
+    return SearchFileHeaderForToken(pIOHandler, pFile, tokens, AI_COUNT_OF(tokens));
 }
 
 // ------------------------------------------------------------------------------------------------

code/AssetLib/DXF/DXFLoader.cpp

@@ -127,7 +127,7 @@ DXFImporter::~DXFImporter() {
 // Returns whether the class can handle the format of the given file.
 bool DXFImporter::CanRead( const std::string& filename, IOSystem* pIOHandler, bool /*checkSig*/ ) const {
     static const char *tokens[] = { "SECTION", "HEADER", "ENDSEC", "BLOCKS" };
-    return SearchFileHeaderForToken(pIOHandler, filename, tokens, std::size(tokens), 32);
+    return SearchFileHeaderForToken(pIOHandler, filename, tokens, AI_COUNT_OF(tokens), 32);
 }
 
 // ------------------------------------------------------------------------------------------------

code/AssetLib/FBX/FBXImporter.cpp

@@ -103,7 +103,7 @@ FBXImporter::~FBXImporter() {
 bool FBXImporter::CanRead(const std::string & pFile, IOSystem * pIOHandler, bool /*checkSig*/) const {
 	// at least ASCII-FBX files usually have a 'FBX' somewhere in their head
 	static const char *tokens[] = { "fbx" };
-	return SearchFileHeaderForToken(pIOHandler, pFile, tokens, std::size(tokens));
+	return SearchFileHeaderForToken(pIOHandler, pFile, tokens, AI_COUNT_OF(tokens));
 }
 
 // ------------------------------------------------------------------------------------------------

code/AssetLib/HMP/HMPLoader.cpp

@@ -89,7 +89,7 @@ bool HMPImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /
         AI_HMP_MAGIC_NUMBER_LE_5,
         AI_HMP_MAGIC_NUMBER_LE_7
     };
-    return CheckMagicToken(pIOHandler, pFile, tokens, std::size(tokens));
+    return CheckMagicToken(pIOHandler, pFile, tokens, AI_COUNT_OF(tokens));
 }
 
 // ------------------------------------------------------------------------------------------------

code/AssetLib/IFC/IFCLoader.cpp

@@ -134,7 +134,7 @@ bool IFCImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /
     // it is only unambiguous as long as we don't support any further
     // file formats with STEP as their encoding.
     static const char *tokens[] = { "ISO-10303-21" };
-    return SearchFileHeaderForToken(pIOHandler, pFile, tokens, std::size(tokens));
+    return SearchFileHeaderForToken(pIOHandler, pFile, tokens, AI_COUNT_OF(tokens));
 }
 
 // ------------------------------------------------------------------------------------------------

code/AssetLib/Irr/IRRLoader.cpp

@@ -96,7 +96,7 @@ IRRImporter::~IRRImporter() {
 // Returns whether the class can handle the format of the given file.
 bool IRRImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*checkSig*/) const {
 	static const char *tokens[] = { "irr_scene" };
-	return SearchFileHeaderForToken(pIOHandler, pFile, tokens, std::size(tokens));
+	return SearchFileHeaderForToken(pIOHandler, pFile, tokens, AI_COUNT_OF(tokens));
 }
 
 // ------------------------------------------------------------------------------------------------

code/AssetLib/Irr/IRRMeshLoader.cpp

@@ -92,7 +92,7 @@ bool IRRMeshImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bo
 	 * search for typical tokens.
 	 */
 	static const char *tokens[] = { "irrmesh" };
-	return SearchFileHeaderForToken(pIOHandler, pFile, tokens, std::size(tokens));
+	return SearchFileHeaderForToken(pIOHandler, pFile, tokens, AI_COUNT_OF(tokens));
 }
 
 // ------------------------------------------------------------------------------------------------

code/AssetLib/LWO/LWOLoader.cpp

@@ -111,7 +111,7 @@ bool LWOImporter::CanRead(const std::string &file, IOSystem *pIOHandler, bool /*
         AI_LWO_FOURCC_LWO2,
         AI_LWO_FOURCC_LXOB
     };
-    return CheckMagicToken(pIOHandler, file, tokens, std::size(tokens), 8);
+    return CheckMagicToken(pIOHandler, file, tokens, AI_COUNT_OF(tokens), 8);
 }
 
 // ------------------------------------------------------------------------------------------------

code/AssetLib/LWS/LWSLoader.cpp

@@ -152,7 +152,7 @@ bool LWSImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /
         AI_MAKE_MAGIC("LWSC"),
         AI_MAKE_MAGIC("LWMO")
     };
-    return CheckMagicToken(pIOHandler, pFile, tokens, std::size(tokens));
+    return CheckMagicToken(pIOHandler, pFile, tokens, AI_COUNT_OF(tokens));
 }
 
 // ------------------------------------------------------------------------------------------------

code/AssetLib/MD2/MD2Loader.cpp

@@ -109,7 +109,7 @@ MD2Importer::~MD2Importer()
 bool MD2Importer::CanRead( const std::string& pFile, IOSystem* pIOHandler, bool /*checkSig*/) const
 {
     static const uint32_t tokens[] = { AI_MD2_MAGIC_NUMBER_LE };
-    return CheckMagicToken(pIOHandler,pFile,tokens,std::size(tokens));
+    return CheckMagicToken(pIOHandler,pFile,tokens,AI_COUNT_OF(tokens));
 }
 
 // ------------------------------------------------------------------------------------------------

code/AssetLib/MD3/MD3Loader.cpp

@@ -351,7 +351,7 @@ MD3Importer::~MD3Importer() {}
 // Returns whether the class can handle the format of the given file.
 bool MD3Importer::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*checkSig*/) const {
     static const uint32_t tokens[] = { AI_MD3_MAGIC_NUMBER_LE };
-    return CheckMagicToken(pIOHandler, pFile, tokens, std::size(tokens));
+    return CheckMagicToken(pIOHandler, pFile, tokens, AI_COUNT_OF(tokens));
 }
 
 // ------------------------------------------------------------------------------------------------

code/AssetLib/MD5/MD5Loader.cpp

@@ -102,7 +102,7 @@ MD5Importer::~MD5Importer() {
 // Returns whether the class can handle the format of the given file.
 bool MD5Importer::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*checkSig*/) const {
     static const char *tokens[] = { "MD5Version" };
-    return SearchFileHeaderForToken(pIOHandler, pFile, tokens, std::size(tokens));
+    return SearchFileHeaderForToken(pIOHandler, pFile, tokens, AI_COUNT_OF(tokens));
 }
 
 // ------------------------------------------------------------------------------------------------

code/AssetLib/MDC/MDCLoader.cpp

@@ -112,7 +112,7 @@ MDCImporter::~MDCImporter() {
 // Returns whether the class can handle the format of the given file.
 bool MDCImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*checkSig*/) const {
     static const uint32_t tokens[] = { AI_MDC_MAGIC_NUMBER_LE };
-    return CheckMagicToken(pIOHandler, pFile, tokens, std::size(tokens));
+    return CheckMagicToken(pIOHandler, pFile, tokens, AI_COUNT_OF(tokens));
 }
 
 // ------------------------------------------------------------------------------------------------

code/AssetLib/MDL/MDLLoader.cpp

@@ -115,7 +115,7 @@ bool MDLImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /
         AI_MDL_MAGIC_NUMBER_LE_GS3,
         AI_MDL_MAGIC_NUMBER_LE
     };
-    return CheckMagicToken(pIOHandler, pFile, tokens, std::size(tokens));
+    return CheckMagicToken(pIOHandler, pFile, tokens, AI_COUNT_OF(tokens));
 }
 
 // ------------------------------------------------------------------------------------------------

code/AssetLib/MMD/MMDImporter.cpp

@@ -91,7 +91,7 @@ MMDImporter::~MMDImporter() {
 bool MMDImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler,
         bool /*checkSig*/) const {
     static const char *tokens[] = { "PMX " };
-    return SearchFileHeaderForToken(pIOHandler, pFile, tokens, std::size(tokens));
+    return SearchFileHeaderForToken(pIOHandler, pFile, tokens, AI_COUNT_OF(tokens));
 }
 
 // ------------------------------------------------------------------------------------------------

code/AssetLib/MS3D/MS3DLoader.cpp

@@ -93,7 +93,7 @@ MS3DImporter::~MS3DImporter()
 bool MS3DImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler, bool /*checkSig*/) const
 {
     static const char* tokens[] = { "MS3D000000" };
-    return SearchFileHeaderForToken(pIOHandler,pFile,tokens,std::size(tokens));
+    return SearchFileHeaderForToken(pIOHandler,pFile,tokens,AI_COUNT_OF(tokens));
 }
 
 // ------------------------------------------------------------------------------------------------

code/AssetLib/NDO/NDOLoader.cpp

@@ -85,7 +85,7 @@ NDOImporter::~NDOImporter()
 bool NDOImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler, bool /*checkSig*/) const
 {
     static const char* tokens[] = {"nendo"};
-    return SearchFileHeaderForToken(pIOHandler,pFile,tokens,std::size(tokens),5);
+    return SearchFileHeaderForToken(pIOHandler,pFile,tokens,AI_COUNT_OF(tokens),5);
 }
 
 // ------------------------------------------------------------------------------------------------

code/AssetLib/OFF/OFFLoader.cpp

@@ -88,7 +88,7 @@ OFFImporter::~OFFImporter()
 bool OFFImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler, bool /*checkSig*/) const
 {
     static const char* tokens[] = { "off" };
-    return SearchFileHeaderForToken(pIOHandler,pFile,tokens,std::size(tokens),3);
+    return SearchFileHeaderForToken(pIOHandler,pFile,tokens,AI_COUNT_OF(tokens),3);
 }
 
 // ------------------------------------------------------------------------------------------------

code/AssetLib/Ogre/OgreImporter.cpp

@@ -76,7 +76,7 @@ void OgreImporter::SetupProperties(const Importer *pImp) {
 bool OgreImporter::CanRead(const std::string &pFile, Assimp::IOSystem *pIOHandler, bool /*checkSig*/) const {
     if (EndsWith(pFile, ".mesh.xml", false)) {
         static const char *tokens[] = { "<mesh>" };
-        return SearchFileHeaderForToken(pIOHandler, pFile, tokens, std::size(tokens));
+        return SearchFileHeaderForToken(pIOHandler, pFile, tokens, AI_COUNT_OF(tokens));
     } else {
         /// @todo Read and validate first header chunk?
         return false;

code/AssetLib/OpenGEX/OpenGEXImporter.cpp

@@ -283,7 +283,7 @@ OpenGEXImporter::~OpenGEXImporter() {
 //------------------------------------------------------------------------------------------------
 bool OpenGEXImporter::CanRead(const std::string &file, IOSystem *pIOHandler, bool /*checkSig*/) const {
     static const char *tokens[] = { "Metric", "GeometryNode", "VertexArray (attrib", "IndexArray" };
-    return SearchFileHeaderForToken(pIOHandler, file, tokens, std::size(tokens));
+    return SearchFileHeaderForToken(pIOHandler, file, tokens, AI_COUNT_OF(tokens));
 }
 
 //------------------------------------------------------------------------------------------------

code/AssetLib/Ply/PlyLoader.cpp

@@ -102,7 +102,7 @@ PLYImporter::~PLYImporter() {
 // Returns whether the class can handle the format of the given file.
 bool PLYImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*checkSig*/) const {
     static const char *tokens[] = { "ply" };
-    return SearchFileHeaderForToken(pIOHandler, pFile, tokens, std::size(tokens));
+    return SearchFileHeaderForToken(pIOHandler, pFile, tokens, AI_COUNT_OF(tokens));
 }
 
 // ------------------------------------------------------------------------------------------------

code/AssetLib/Q3D/Q3DLoader.cpp

@@ -85,7 +85,7 @@ Q3DImporter::~Q3DImporter() {
 // Returns whether the class can handle the format of the given file.
 bool Q3DImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*checkSig*/) const {
     static const char *tokens[] = { "quick3Do", "quick3Ds" };
-    return SearchFileHeaderForToken(pIOHandler, pFile, tokens, std::size(tokens));
+    return SearchFileHeaderForToken(pIOHandler, pFile, tokens, AI_COUNT_OF(tokens));
 }
 
 // ------------------------------------------------------------------------------------------------

code/AssetLib/STL/STLLoader.cpp

@@ -143,7 +143,7 @@ STLImporter::~STLImporter() {
 // Returns whether the class can handle the format of the given file.
 bool STLImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*checkSig*/) const {
     static const char *tokens[] = { "STL", "solid" };
-    return SearchFileHeaderForToken(pIOHandler, pFile, tokens, std::size(tokens));
+    return SearchFileHeaderForToken(pIOHandler, pFile, tokens, AI_COUNT_OF(tokens));
 }
 
 // ------------------------------------------------------------------------------------------------

code/AssetLib/Terragen/TerragenLoader.cpp

@@ -79,7 +79,7 @@ TerragenImporter::~TerragenImporter() {}
 // Returns whether the class can handle the format of the given file.
 bool TerragenImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*checkSig*/) const {
     static const char *tokens[] = { "terragen" };
-    return SearchFileHeaderForToken(pIOHandler, pFile, tokens, std::size(tokens));
+    return SearchFileHeaderForToken(pIOHandler, pFile, tokens, AI_COUNT_OF(tokens));
 }
 
 // ------------------------------------------------------------------------------------------------

code/AssetLib/X/XFileImporter.cpp

@@ -91,7 +91,7 @@ XFileImporter::~XFileImporter() {
 // Returns whether the class can handle the format of the given file.
 bool XFileImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler, bool /*checkSig*/) const {
     static const uint32_t token[] = { AI_MAKE_MAGIC("xof ") };
-    return CheckMagicToken(pIOHandler,pFile,token,std::size(token));
+    return CheckMagicToken(pIOHandler,pFile,token,AI_COUNT_OF(token));
 }
 
 // ------------------------------------------------------------------------------------------------

code/AssetLib/XGL/XGLLoader.cpp

@@ -107,7 +107,7 @@ XGLImporter::~XGLImporter() {
 // Returns whether the class can handle the format of the given file.
 bool XGLImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*checkSig*/) const {
 	static const char *tokens[] = { "<world>", "<World>", "<WORLD>" };
-	return SearchFileHeaderForToken(pIOHandler, pFile, tokens, std::size(tokens));
+	return SearchFileHeaderForToken(pIOHandler, pFile, tokens, AI_COUNT_OF(tokens));
 }
 
 // ------------------------------------------------------------------------------------------------

include/assimp/defs.h

@@ -322,4 +322,6 @@ static const ai_real ai_epsilon = (ai_real)0.00001;
 #define AI_DEBUG_INVALIDATE_PTR(x)
 #endif
 
+#define AI_COUNT_OF(X) (sizeof(X) / sizeof((X)[0]))
+
 #endif // !! AI_DEFINES_H_INC