FIX: static_string sign warnins

Author: jlblancoc

modules/mrpt_typemeta/include/mrpt/typemeta/static_string.h

@@ -21,7 +21,7 @@ namespace mrpt
 {
 namespace typemeta
 {
-template <int N>
+template <std::size_t N>
 class string_literal
 {
   const char (&_lit)[N + 1];
@@ -30,13 +30,13 @@ class string_literal
   /** Ctor from C string literal, with trailing zero. */
   constexpr string_literal(const char (&lit)[N + 1]) : _lit((MRPT_X_ASSERT(lit[N] == '\0'), lit)) {}
   constexpr std::size_t size() const { return N; }
-  constexpr char operator[](int i) const { return MRPT_X_ASSERT(i >= 0 && i < N), _lit[i]; }
+  constexpr char operator[](std::size_t i) const { return MRPT_X_ASSERT(i < N), _lit[i]; }
   constexpr const char* c_str() const { return _lit; }
   constexpr operator const char*() const { return _lit; }
   operator std::string() const { return _lit; }
 };
 
-template <int N_PLUS_1>
+template <std::size_t N_PLUS_1>
 constexpr auto literal(const char (&lit)[N_PLUS_1]) -> string_literal<N_PLUS_1 - 1>
 {
   return string_literal<N_PLUS_1 - 1>(lit);
@@ -47,7 +47,7 @@ constexpr auto literal(const char (&lit)[N_PLUS_1]) -> string_literal<N_PLUS_1 -
 namespace internal
 {
 // the type used to receive the pack
-template <int... I>
+template <std::size_t... I>
 struct sequence
 {
 };
@@ -57,18 +57,18 @@ struct sequence
 template <typename T>
 struct append;
 
-template <int... I>
+template <std::size_t... I>
 struct append<sequence<I...>>
 {
   using type = sequence<I..., sizeof...(I)>;
 };
 
 // recursive implementation of make_sequence
 
-template <int I>
+template <std::size_t I>
 struct make_sequence_;
 
-template <int I>
+template <std::size_t I>
 using make_sequence = typename make_sequence_<I>::type;
 
 template <>
@@ -77,19 +77,19 @@ struct make_sequence_<0>  // recursion end
   using type = sequence<>;
 };
 
-template <int I>
+template <std::size_t I>
 struct make_sequence_ : append<make_sequence<I - 1>>
 {
   static_assert(I >= 0, "negative size");
 };
 }  // namespace internal
 
-template <int N>
+template <std::size_t N>
 class array_string
 {
   char _array[N + 1];
 
-  template <typename S1, typename S2, int... PACK1, int... PACK2>
+  template <typename S1, typename S2, std::size_t... PACK1, std::size_t... PACK2>
   constexpr array_string(
       const S1& s1, const S2& s2, internal::sequence<PACK1...>, internal::sequence<PACK2...>) :
       _array{s1[PACK1]..., s2[PACK2]..., '\0'}
@@ -98,48 +98,48 @@ class array_string
 
  public:
   /** ctor: literal + literal */
-  template <int N1, REQUIRES(N1 <= N)>
+  template <std::size_t N1, REQUIRES(N1 <= N)>
   constexpr array_string(const string_literal<N1>& s1, const string_literal<N - N1>& s2) :
       array_string{s1, s2, internal::make_sequence<N1>{}, internal::make_sequence<N - N1>{}}
   {
   }
 
   /** ctor: string + literal */
-  template <int N1, REQUIRES(N1 <= N)>
+  template <std::size_t N1, REQUIRES(N1 <= N)>
   constexpr array_string(const array_string<N1>& s1, const string_literal<N - N1>& s2) :
       array_string{s1, s2, internal::make_sequence<N1>{}, internal::make_sequence<N - N1>{}}
   {
   }
 
   /** ctor: string + string */
-  template <int N1, REQUIRES(N1 <= N)>
+  template <std::size_t N1, REQUIRES(N1 <= N)>
   constexpr array_string(const array_string<N1>& s1, const array_string<N - N1>& s2) :
       array_string{s1, s2, internal::make_sequence<N1>{}, internal::make_sequence<N - N1>{}}
   {
   }
 
   constexpr std::size_t size() const { return N; }
-  constexpr char operator[](int i) const { return MRPT_X_ASSERT(i >= 0 && i < N), _array[i]; }
+  constexpr char operator[](std::size_t i) const { return MRPT_X_ASSERT(i < N), _array[i]; }
   constexpr const char* c_str() const { return _array; }
   constexpr operator const char*() const { return c_str(); }
   operator std::string() const { return c_str(); }
 };
 
-template <int N1, int N2>
+template <std::size_t N1, std::size_t N2>
 constexpr auto operator+(const string_literal<N1>& s1, const string_literal<N2>& s2)
     -> array_string<N1 + N2>
 {
   return array_string<N1 + N2>(s1, s2);
 }
 
-template <int N1, int N2>
+template <std::size_t N1, std::size_t N2>
 constexpr auto operator+(const array_string<N1>& s1, const string_literal<N2>& s2)
     -> array_string<N1 + N2>
 {
   return array_string<N1 + N2>(s1, s2);
 }
 
-template <int N1, int N2>
+template <std::size_t N1, std::size_t N2>
 constexpr auto operator+(const array_string<N1>& s1, const array_string<N2>& s2)
     -> array_string<N1 + N2>
 {