include/ninja/static_arrays.hh

0001 // -*- C++ -*- wrapper for static arrays.
0002
0003
0004 #ifndef NINJA_STATIC_ARRAYS_HH
0005 #define NINJA_STATIC_ARRAYS_HH
0006
0007
0008 #if !defined(HAVE_INIT_LIST) && !defined(NINJA_CONFIG_H_INTERNAL)
0009 #  if defined(__clang__)
0010 #    if __has_feature(cxx_generalized_initializers)
0011 #      define HAVE_INIT_LIST 1
0012 #    endif
0013 #  elif (defined __INTEL_COMPILER && __INTEL_COMPILER >= 1400) || (defined __ICC && __ICC >= 1400)
0014 #      define HAVE_INIT_LIST 1
0015 #  elif defined(__GNUC__) && defined(__GNUC_MINOR__)
0016 #    if (__GNUC__ > 4 ||  (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && defined(__GXX_EXPERIMENTAL_CXX0X__)
0017 #      define HAVE_INIT_LIST 1
0018 #    endif
0019 #  endif
0020 #endif
0021
0022
0023 #if HAVE_INIT_LIST
0024
0025 // Definition of a wrapper around 3 and 4-dimensional static arrays,
0026 // initialized with a C++11 initializer list.
0027
0028 namespace ninja {
0029   namespace details {
0030
0031     template<typename T>
0032     struct Array3D {
0033
0034       Array3D(const T & v0, const T & v1, const T & v2)
0035         : data{v0,v1,v2} {}
0036
0037       const T operator[] (unsigned i) const
0038       {
0039         return data[i];
0040       }
0041
0042       T & operator[] (unsigned i)
0043       {
0044         return data[i];
0045       }
0046
0047       T data[3];
0048     };
0049
0050
0051     template<typename T>
0052     struct Array4D {
0053
0054       Array4D(const T & v0, const T & v1, const T & v2, const T & v3)
0055         : data{v0,v1,v2,v3} {}
0056
0057       const T & operator[] (unsigned i) const
0058       {
0059         return data[i];
0060       }
0061
0062       T & operator[] (unsigned i)
0063       {
0064         return data[i];
0065       }
0066
0067       T data[4];
0068     };
0069
0070   } // namespace details
0071 } // namespace ninja
0072
0073 #else //  HAVE_INIT_LIST
0074
0075 // Definition of a wrapper around 3 and 4-dimensional static arrays,
0076 // initialized in the body of the constructor (should only be used
0077 // when C++11 initialization lists are not available).
0078
0079 namespace ninja {
0080   namespace details {
0081
0082     template<typename T>
0083     struct Array3D {
0084
0085       Array3D(const T & v0, const T & v1, const T & v2)
0086       {
0087         data[0]=v0; data[1]=v1; data[2]=v2;
0088       }
0089
0090       const T operator[] (unsigned i) const
0091       {
0092         return data[i];
0093       }
0094
0095       T & operator[] (unsigned i)
0096       {
0097         return data[i];
0098       }
0099
0100       T data[3];
0101     };
0102
0103
0104     template<typename T>
0105     struct Array4D {
0106
0107       Array4D(const T & v0)
0108       {
0109         data[0]=v0;
0110       }
0111
0112       Array4D(const T & v0, const T & v1)
0113       {
0114         data[0]=v0; data[1]=v1;
0115       }
0116
0117       Array4D(const T & v0, const T & v1, const T & v2, const T & v3)
0118       {
0119         data[0]=v0; data[1]=v1; data[2]=v2; data[3]=v3;
0120       }
0121
0122       const T & operator[] (unsigned i) const
0123       {
0124         return data[i];
0125       }
0126
0127       T & operator[] (unsigned i)
0128       {
0129         return data[i];
0130       }
0131
0132       T data[4];
0133     };
0134
0135   } // namespace details
0136 } // namespace ninja
0137
0138 #endif // ! HAVE_INIT_LIST
0139
0140 #endif // NINJA_STATIC_ARRAYS_HH