gmock/internal/gmock-internal-utils.h

58 // PointeeOf<Pointer>::type is the type of a value pointed to by a
64   // Smart pointer classes define type element_type as the type of
66   typedef typename Pointer::element_type type;
70 struct PointeeOf<T*> { typedef T type; };  // NOLINT
93 // type or a typedef.  Using Google Mock with OpenC without wchar_t
96 // MSVC treats wchar_t as a native type usually, but treats it as the
99 // is a native type.
121 // In what follows, we use the term "kind" to indicate whether a type
122 // is bool, an integer type (excluding bool), a floating-point type,
124 // when a matcher argument type can be safely converted to another
125 // type in the implementation of SafeMatcherCast.
130 // KindOf<T>::value is the kind of type T.
135 // This macro declares that the kind of 'type' is 'kind'.
136 #define GMOCK_DECLARE_KIND_(type, kind) \
137   template <> struct KindOf<type> { enum { value = kind }; }
167 // Evaluates to the kind of 'type'.
168 #define GMOCK_KIND_OF_(type) \
170       ::testing::internal::KindOf<type>::value)
172 // Evaluates to true iff integer type T is signed.
176 // is true iff arithmetic type From can be losslessly converted to
177 // arithmetic type To.
192 // Converting bool to any integer type is lossless.
197 // Converting bool to any floating-point type is lossless.
208 // the target type's range encloses the source type's range.
222 // Converting an integer to a floating-point type may be lossy, since
239 // iff the target type is at least as big as the source type.
246 // type From can be losslessly converted to arithmetic type To.
261   // The type of a failure (either non-fatal or fatal).
269   virtual void ReportFailure(FailureType type, const char* file, int line,
335 // TODO(wan@google.com): group all type utilities together.
339 // is_reference<T>::value is non-zero iff T is a reference type.
343 // type_equals<T1, T2>::value is non-zero iff T1 and T2 are the same type.
347 // remove_reference<T>::type removes the reference from type T, if any.
348 template <typename T> struct remove_reference { typedef T type; };  // NOLINT
349 template <typename T> struct remove_reference<T&> { typedef T type; }; // NOLINT
351 // DecayArray<T>::type turns an array type U[N] to const U* and preserves
353 template <typename T> struct DecayArray { typedef T type; };  // NOLINT
355   typedef const T* type;
361   typedef const T* type;
371 // Invalid<T>() is usable as an expression of type T, but will terminate
373 // when a value of type T is needed for compilation, but the statement
389 // Given a raw type (i.e. having no top-level reference or const
394 //   - type is a type that provides an STL-style container view to
396 //   - const_reference is a type that provides a reference to a const
408   typedef RawContainer type;
409   typedef const type& const_reference;
412     // Ensures that RawContainer is not a const type.
417   static type Copy(const RawContainer& container) { return container; }
420 // This specialization is used when RawContainer is a native array type.
425   typedef internal::NativeArray<RawElement> type;
427   // reference (selected by a constructor argument), so 'const type'
429   // 'typedef const type& const_reference' here, as that would mean
431   typedef const type const_reference;
434     // Ensures that Element is not a const type.
448     // (and though the N parameter type is mismatched in the above explicit
450     return type(const_cast<Element*>(&array[0]), N,
453     return type(array, N, RelationToSourceReference());
456   static type Copy(const Element (&array)[N]) {
458     return type(const_cast<Element*>(&array[0]), N, RelationToSourceCopy());
460     return type(array, N, RelationToSourceCopy());
471       typename internal::PointeeOf<ElementPointer>::type) RawElement;
472   typedef internal::NativeArray<RawElement> type;
473   typedef const type const_reference;
477     return type(get<0>(array), get<1>(array), RelationToSourceReference());
479   static type Copy(const ::testing::tuple<ElementPointer, Size>& array) {
480     return type(get<0>(array), get<1>(array), RelationToSourceCopy());
485 // StlContainer with a reference type.
488 // A type transform to remove constness from the first part of a pair.
493   typedef T type;
499   typedef std::pair<K, V> type;