STYLE: minor cleanup of contiguous (issue #769)

applications/test/contiguous/Make/files

+Test-contiguous.C
+
+EXE = $(FOAM_USER_APPBIN)/Test-contiguous

applications/test/contiguous/Test-contiguous.C

+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2018 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Application
+    Test-contiguous
+
+Description
+    Simple test of contiguous data
+
+\*---------------------------------------------------------------------------*/
+
+#include "OSspecific.H"
+#include "argList.H"
+#include "wordRes.H"
+#include "contiguous.H"
+
+#include "IOstreams.H"
+#include "scalar.H"
+#include "vector.H"
+
+#include "labelRange.H"
+#include "scalarList.H"
+#include "HashOps.H"
+#include "FixedList.H"
+#include "Pair.H"
+
+namespace Foam
+{
+
+// Wrong, but interesting to test
+// template<> struct contiguous<Pair<word>> : std::true_type {};
+
+} // end namespace Foam
+
+using namespace Foam;
+
+
+template<class T>
+void printContiguous()
+{
+    Info<<"contiguous " << typeid(T).name() << " () = "
+        << contiguous<T>()
+        // << " value = " << contiguous<T>::value
+        << nl;
+}
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+//  Main program:
+
+int main(int argc, char *argv[])
+{
+    argList::noBanner();
+    argList::noParallel();
+    argList::noFunctionObjects();
+
+    #include "setRootCase.H"
+
+    printContiguous<label>();
+    printContiguous<double>();
+    printContiguous<FixedList<int, 2>>();
+    printContiguous<FixedList<int, 3>>();
+    printContiguous<Pair<long>>();
+
+    printContiguous<FixedList<word, 2>>();
+    printContiguous<Pair<word>>();
+
+    printContiguous<FixedList<FixedList<int, 2>, 2>>();
+
+    return 0;
+}
+
+// ************************************************************************* //

src/OpenFOAM/primitives/contiguous/contiguous.H

@@ -36,113 +36,95 @@ Description
 #define contiguous_H
 
 #include "int.H"
+#include <type_traits>
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 namespace Foam
 {
 
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-// Forward declaration of friend functions and operators
-template<class T, unsigned Size> class FixedList;
+// Forward declarations
+template<class T, unsigned N> class FixedList;
 template<class T> class Pair;
 
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-//- Assume the data associated with type T are not contiguous
+//- Default definition: (integral | floating-point) are contiguous
 template<class T>
-inline bool contiguous()                                   {return false;}
-
+inline bool contiguous()
+{
+    return
+    std::integral_constant
+    <
+        bool,
+        std::is_integral<T>::value || std::is_floating_point<T>::value
+    >::value;
+}
 
-// Data associated with primitive types (and simple fixed size containers
-//  - only size 2 defined here) are contiguous
+//
+// Fixed size containers of (integral | floating-point) are contiguous
+//
 
-template<>
-inline bool contiguous<bool>()                              {return true;}
 template<>
 inline bool contiguous<FixedList<bool, 2>>()               {return true;}
 template<>
 inline bool contiguous<Pair<bool>>()                       {return true;}
 
-template<>
-inline bool contiguous<char>()                              {return true;}
 template<>
 inline bool contiguous<FixedList<char, 2>>()               {return true;}
 template<>
 inline bool contiguous<Pair<char>>()                       {return true;}
 
-template<>
-inline bool contiguous<int8_t>()                            {return true;}
 template<>
 inline bool contiguous<FixedList<int8_t, 2>>()             {return true;}
 template<>
 inline bool contiguous<Pair<int8_t>>()                     {return true;}
 
-template<>
-inline bool contiguous<uint8_t>()                           {return true;}
 template<>
 inline bool contiguous<FixedList<uint8_t, 2>>()            {return true;}
 template<>
 inline bool contiguous<Pair<uint8_t>>()                    {return true;}
 
-template<>
-inline bool contiguous<int16_t>()                           {return true;}
 template<>
 inline bool contiguous<FixedList<int16_t, 2>>()            {return true;}
 template<>
 inline bool contiguous<Pair<int16_t>>()                    {return true;}
 
-template<>
-inline bool contiguous<uint16_t>()                          {return true;}
 template<>
 inline bool contiguous<FixedList<uint16_t, 2>>()           {return true;}
 template<>
 inline bool contiguous<Pair<uint16_t>>()                   {return true;}
 
-template<>
-inline bool contiguous<int32_t>()                           {return true;}
 template<>
 inline bool contiguous<FixedList<int32_t, 2>>()            {return true;}
 template<>
 inline bool contiguous<Pair<int32_t>>()                    {return true;}
 
-template<>
-inline bool contiguous<uint32_t>()                          {return true;}
 template<>
 inline bool contiguous<FixedList<uint32_t, 2>>()           {return true;}
 template<>
 inline bool contiguous<Pair<uint32_t>>()                   {return true;}
 
-template<>
-inline bool contiguous<int64_t>()                           {return true;}
 template<>
 inline bool contiguous<FixedList<int64_t, 2>>()            {return true;}
 template<>
 inline bool contiguous<Pair<int64_t>>()                    {return true;}
 
-template<>
-inline bool contiguous<uint64_t>()                          {return true;}
 template<>
 inline bool contiguous<FixedList<uint64_t, 2>>()           {return true;}
 template<>
 inline bool contiguous<Pair<uint64_t>>()                   {return true;}
 
-template<>
-inline bool contiguous<float>()                             {return true;}
 template<>
 inline bool contiguous<FixedList<float, 2>>()              {return true;}
 template<>
 inline bool contiguous<Pair<float>>()                      {return true;}
 
-template<>
-inline bool contiguous<double>()                            {return true;}
 template<>
 inline bool contiguous<FixedList<double, 2>>()             {return true;}
 template<>
 inline bool contiguous<Pair<double>>()                     {return true;}
 
-template<>
-inline bool contiguous<long double>()                       {return true;}
 template<>
 inline bool contiguous<FixedList<long double, 2>>()        {return true;}
 template<>