Refs #4399. Switch to non-fixed size types.

Avoids having to do anything special for some platforms.
mantidproject · Mar 5, 2012 · edb4c86 · edb4c86
1 parent 7134361
commit edb4c86
Show file tree

Hide file tree

Showing 6 changed files with 71 additions and 66 deletions.
diff --git a/Code/Mantid/Framework/PythonInterface/mantid/kernel/src/Converters/NDArrayToVector.cpp b/Code/Mantid/Framework/PythonInterface/mantid/kernel/src/Converters/NDArrayToVector.cpp
@@ -159,17 +159,19 @@ namespace Mantid
       //------------------------------------------------------------------------
       // Explicit instantiations
       //------------------------------------------------------------------------
-      template DLLExport struct NDArrayToVectorConverter<int16_t>;
-      template DLLExport struct NDArrayToVectorConverter<uint16_t>;
-      template DLLExport struct NDArrayToVectorConverter<int32_t>;
-      template DLLExport struct NDArrayToVectorConverter<uint32_t>;
-      template DLLExport struct NDArrayToVectorConverter<int64_t>;
-      template DLLExport struct NDArrayToVectorConverter<uint64_t>;
-#ifdef __APPLE__
-      template DLLExport struct NDArrayToVectorConverter<unsigned long>;
-#endif
-      template DLLExport struct NDArrayToVectorConverter<double>;
-      template DLLExport struct NDArrayToVectorConverter<std::string>;
+      #define INSTANTIATE(ElementType)\
+        template DLLExport struct NDArrayToVectorConverter<ElementType>;
+
+      INSTANTIATE(int);
+      INSTANTIATE(long);
+      INSTANTIATE(long long);
+      INSTANTIATE(unsigned int);
+      INSTANTIATE(unsigned long);
+      INSTANTIATE(unsigned long long);
+      INSTANTIATE(double);
+      INSTANTIATE(bool);
+      INSTANTIATE(std::string);
+
     }
   }
 }

diff --git a/Code/Mantid/Framework/PythonInterface/mantid/kernel/src/Converters/NDArrayTypeIndex.cpp b/Code/Mantid/Framework/PythonInterface/mantid/kernel/src/Converters/NDArrayTypeIndex.cpp
@@ -23,15 +23,13 @@ namespace Mantid
         int NDArrayTypeIndex<CType>::typenum = NDTypeNum;\
         template DLLExport struct NDArrayTypeIndex<CType>;
 
-      DEFINE_TYPE_MAPPING(int16_t, NPY_INT16);
-      DEFINE_TYPE_MAPPING(uint16_t, NPY_UINT16);
-      DEFINE_TYPE_MAPPING(int32_t, NPY_INT32);
-      DEFINE_TYPE_MAPPING(uint32_t, NPY_UINT32);
-      DEFINE_TYPE_MAPPING(int64_t, NPY_INT64);
-#ifdef __APPLE__
+      DEFINE_TYPE_MAPPING(int, NPY_INT);
+      DEFINE_TYPE_MAPPING(long, NPY_LONG);
+      DEFINE_TYPE_MAPPING(long long, NPY_LONGLONG);
+      DEFINE_TYPE_MAPPING(unsigned int, NPY_UINT);
       DEFINE_TYPE_MAPPING(unsigned long, NPY_ULONG);
-#endif
-      DEFINE_TYPE_MAPPING(uint64_t, NPY_UINT64);
+      DEFINE_TYPE_MAPPING(unsigned long long, NPY_ULONGLONG);
+      DEFINE_TYPE_MAPPING(bool, NPY_BOOL);
       DEFINE_TYPE_MAPPING(double, NPY_DOUBLE);
       DEFINE_TYPE_MAPPING(float, NPY_FLOAT);
 

diff --git a/Code/Mantid/Framework/PythonInterface/mantid/kernel/src/Converters/VectorToNDArray.cpp b/Code/Mantid/Framework/PythonInterface/mantid/kernel/src/Converters/VectorToNDArray.cpp
@@ -65,17 +65,13 @@ namespace Mantid { namespace PythonInterface
         template DLLExport PyObject * wrapWithNDArray<std::vector<ElementType> >(const std::vector<ElementType> &, const NumpyWrapMode);\
         template DLLExport PyObject * cloneToNDArray<std::vector<ElementType> >(const std::vector<ElementType> &);
 
-      INSTANTIATE(int16_t);
-      INSTANTIATE(uint16_t);
-      INSTANTIATE(int32_t);
-      INSTANTIATE(uint32_t);
-      INSTANTIATE(int64_t);
-      INSTANTIATE(uint64_t);
-#ifdef __APPLE__
+      INSTANTIATE(int);
+      INSTANTIATE(long);
+      INSTANTIATE(long long);
+      INSTANTIATE(unsigned int);
       INSTANTIATE(unsigned long);
-#endif
+      INSTANTIATE(unsigned long long);
       INSTANTIATE(double);
-
     }
   }
 }}

diff --git a/Code/Mantid/Framework/PythonInterface/mantid/kernel/src/Exports/PropertyWithValue.cpp b/Code/Mantid/Framework/PythonInterface/mantid/kernel/src/Exports/PropertyWithValue.cpp
@@ -2,22 +2,24 @@
 
 void export_BasicPropertyWithValueTypes()
 {
-  // See MantidPythonInterface/kernel/PropertyWithValue.h for macro definition
-  EXPORT_PROP_W_VALUE(int32_t, int32_t);
-  EXPORT_PROP_W_VALUE(std::vector<int32_t>, vector_int32_t);
-  EXPORT_PROP_W_VALUE(int64_t, int64_t);
-  EXPORT_PROP_W_VALUE(std::vector<int64_t>, vector_int64_t);
+  #define EXPORT_BASIC_INTEGER_TYPE(ctype, export_name)\
+    EXPORT_PROP_W_VALUE(ctype, export_name);\
+    EXPORT_PROP_W_VALUE(std::vector<ctype>, export_name);\
+    EXPORT_PROP_W_VALUE(unsigned ctype, unsigned ## _export_name);\
+    EXPORT_PROP_W_VALUE(std::vector<unsigned ctype>, vector_ ## export_name);
 
-  EXPORT_PROP_W_VALUE(size_t, size_t);
-  EXPORT_PROP_W_VALUE(std::vector<size_t>, vector_size_t);
+  #define EXPORT_BASIC_TYPE(ctype, export_name)\
+    EXPORT_PROP_W_VALUE(ctype, export_name);\
+    EXPORT_PROP_W_VALUE(std::vector<ctype>, vector_ ## export_name);
 
-  EXPORT_PROP_W_VALUE(double, dbl);
-  EXPORT_PROP_W_VALUE(std::vector<double>,vector_dbl);
+  // -- PropertyWithValueTypes
+  EXPORT_BASIC_INTEGER_TYPE(int, int);
+  EXPORT_BASIC_INTEGER_TYPE(long, long);
+  EXPORT_BASIC_INTEGER_TYPE(long long, long_long);
 
-  EXPORT_PROP_W_VALUE(bool, bool);
-
-  EXPORT_PROP_W_VALUE(std::string, string);
-  EXPORT_PROP_W_VALUE(std::vector<std::string>,vector_str);
+  EXPORT_BASIC_TYPE(double, double);
+  EXPORT_BASIC_TYPE(bool, bool);
+  EXPORT_BASIC_TYPE(std::string, string);
 }
 
 
diff --git a/Code/Mantid/Framework/PythonInterface/mantid/kernel/src/Registry/SequenceTypeHandler.cpp b/Code/Mantid/Framework/PythonInterface/mantid/kernel/src/Registry/SequenceTypeHandler.cpp
@@ -62,17 +62,19 @@ namespace Mantid
       //-----------------------------------------------------------------------
       // Concrete instantiations
       //-----------------------------------------------------------------------
-      template DLLExport struct SequenceTypeHandler<std::vector<int16_t> >;
-      template DLLExport struct SequenceTypeHandler<std::vector<uint16_t> >;
-      template DLLExport struct SequenceTypeHandler<std::vector<int32_t> >;
-      template DLLExport struct SequenceTypeHandler<std::vector<uint32_t> >;
-      template DLLExport struct SequenceTypeHandler<std::vector<int64_t> >;
-      template DLLExport struct SequenceTypeHandler<std::vector<uint64_t> >;
-#ifdef __APPLE__
-      template DLLExport struct SequenceTypeHandler<std::vector<unsigned long> >;
-#endif
-      template DLLExport struct SequenceTypeHandler<std::vector<double> >;
-      template DLLExport struct SequenceTypeHandler<std::vector<std::string> >;
+      #define INSTANTIATE(ElementType)\
+        template DLLExport struct SequenceTypeHandler<std::vector<ElementType> >;
+
+      INSTANTIATE(int);
+      INSTANTIATE(long);
+      INSTANTIATE(long long);
+      INSTANTIATE(unsigned int);
+      INSTANTIATE(unsigned long);
+      INSTANTIATE(unsigned long long);
+      INSTANTIATE(double);
+      INSTANTIATE(std::string);
+      INSTANTIATE(bool);
+
     }
   }
 }
diff --git a/Code/Mantid/Framework/PythonInterface/mantid/kernel/src/Registry/TypeRegistry.cpp b/Code/Mantid/Framework/PythonInterface/mantid/kernel/src/Registry/TypeRegistry.cpp
@@ -34,31 +34,36 @@ namespace Mantid
        */
       void registerBuiltins()
       {
-        // Register a handler for each basic type in IPropertyManager.cpp
-        REGISTER_SINGLEVALUE_HANDLER(int32_t);
-        REGISTER_SINGLEVALUE_HANDLER(uint32_t);
-        REGISTER_SINGLEVALUE_HANDLER(int64_t);
-        REGISTER_SINGLEVALUE_HANDLER(uint64_t);
+        // -- Register a handler for each basic type --
+
+        // unsigned ints
+        REGISTER_SINGLEVALUE_HANDLER(int);
+        REGISTER_SINGLEVALUE_HANDLER(long);
+        REGISTER_SINGLEVALUE_HANDLER(long long);
+        // signed ints
         REGISTER_SINGLEVALUE_HANDLER(unsigned int);
+        REGISTER_SINGLEVALUE_HANDLER(unsigned long);
+        REGISTER_SINGLEVALUE_HANDLER(unsigned long long);
+        //
         REGISTER_SINGLEVALUE_HANDLER(bool);
         REGISTER_SINGLEVALUE_HANDLER(double);
         REGISTER_SINGLEVALUE_HANDLER(std::string);
 
        #define REGISTER_ARRAYPROPERTY_HANDLER(TYPE) \
          registerHandler(typeid(TYPE), new SequenceTypeHandler<TYPE>());
 
-        REGISTER_ARRAYPROPERTY_HANDLER(std::vector<int16_t>);
-        REGISTER_ARRAYPROPERTY_HANDLER(std::vector<uint16_t>);
-        REGISTER_ARRAYPROPERTY_HANDLER(std::vector<int32_t>);
-        REGISTER_ARRAYPROPERTY_HANDLER(std::vector<uint32_t>);
-        REGISTER_ARRAYPROPERTY_HANDLER(std::vector<int64_t>);
-        REGISTER_ARRAYPROPERTY_HANDLER(std::vector<uint64_t>);
-#ifdef __APPLE__
+        // unsigned ints
+        REGISTER_ARRAYPROPERTY_HANDLER(std::vector<int>);
+        REGISTER_ARRAYPROPERTY_HANDLER(std::vector<long>);
+        REGISTER_ARRAYPROPERTY_HANDLER(std::vector<long long>);
+        // signed ints
+        REGISTER_ARRAYPROPERTY_HANDLER(std::vector<unsigned int>);
         REGISTER_ARRAYPROPERTY_HANDLER(std::vector<unsigned long>);
-#endif
+        REGISTER_ARRAYPROPERTY_HANDLER(std::vector<unsigned long long>);
+        //
+        REGISTER_ARRAYPROPERTY_HANDLER(std::vector<bool>);
         REGISTER_ARRAYPROPERTY_HANDLER(std::vector<double>);
         REGISTER_ARRAYPROPERTY_HANDLER(std::vector<std::string>);
-
       }
 
       /**