| /ndk/sources/cxx-stl/llvm-libc++/test/strings/basic.string/ |
| test_traits.h | 4 template <class charT>
|
| /external/clang/test/CXX/temp/temp.spec/temp.expl.spec/ |
| p2.cpp | 17 // -- function template
19 template<typename T> void f0(T) { // expected-note{{here}}
23 template<> void f0(NonDefaultConstructible) { }
29 template<> void f0(int);
30 template<> void f0(long);
33 template<> void N0::f0(int) { } // okay
36 template<> void N0::f0(long) { } // expected-error{{does not enclose namespace}}
39 template<> void N0::f0(double); // expected-warning{{C++11 extension}}
40 template<> void N0::f0(double) { }
43 template<typename T> void f(T)
[all...] |
| p14.cpp | 3 template<class T> void f(T) { /* ... */ }
4 template<class T> inline void g(T) { /* ... */ }
7 template<> void g<>(int) { /* ... */ }
9 template<class T>
16 template<class T>
20 template<class T>
25 template<> void X<int>::f() { }
28 template<> void X<int>::h() { }
31 template<> inline void f<>(int) { /* ... */ }
34 template<> inline void X<int>::g() {
[all...] |
| /external/clang/test/CXX/temp/temp.decls/temp.class.spec/ |
| p9-0x.cpp | 4 // to the implicit argument list of the primary template.
6 template<typename T, typename ...Types>
9 template<typename T, typename ...Types>
10 struct X1<T, Types...> // expected-error{{class template partial specialization does not specialize any template argument; to define the primary template, remove the template argument list}}
|
| /external/clang/test/CXX/temp/temp.decls/temp.class.spec/temp.class.spec.mfunc/ |
| p1.cpp | 3 template<typename T, int N>
6 template<typename T>
18 template<class X> void A<X*, 2>::f(X*) { }
20 template<class X> X A<X*, 2>::value;
22 template<class X> A<X*, 2>::A(X) { value = 0; }
24 template<class X> A<X*, 2>::~A() { }
26 template<class X> A<X*, 2>::operator X*() { return 0; }
|
| /external/clang/test/CXX/temp/temp.type/ |
| p1-0x.cpp | 4 template<template<class> class TT> struct X { };
5 template<class> struct Y { };
6 template<class T> using Z = Y<T>;
15 template<class T> struct X { };
16 template<class> struct Y { };
17 template<class T> using Z = Y<T>;
|
| /external/clang/test/Sema/ |
| template-specialization.cpp | 3 // template member functions.
6 template <typename T>
7 static void bar(int) { } // expected-note {{candidate template ignored: couldn't infer template argument 'T'}}
11 template <int i>
14 A::template bar(array[0]); // expected-error {{no matching function for call to 'bar'}}
19 B::foo<4>(); // expected-note {{in instantiation of function template specialization 'B::foo<4>'}}
|
| /external/clang/test/SemaCXX/ |
| PR9902.cpp | 4 template <class _Tp, class _Up, bool = false>
9 template <template <class, class...> class _Alloc, class _Tp, class ..._Args,
16 template <class Alloc>
19 template <class T> using rebind_alloc = typename __allocator_traits_rebind<Alloc, T>::type;
20 template <class T> using rebind_traits = allocator_traits<rebind_alloc<T>>;
23 template <class T>
|
| /external/clang/test/SemaTemplate/ |
| instantiate-deeply.cpp | 3 template<typename a> struct A {
4 template <typename b> struct B {
5 template <typename c> struct C {
6 template <typename d> struct D {
7 template <typename e> struct E {
25 template <typename T>
37 template class Foo<int>;
|
| instantiate-function-params.cpp | 4 template<bool C> struct if_c { };
5 template<typename T1> struct if_ {
8 template <class Model, void (Model::*)()> struct wrap_constraints { };
9 template <class Model>
10 inline char has_constraints_(Model* , // expected-note 2{{while substituting deduced template arguments into function template 'has_constraints_' [with }} \
11 // expected-note 3{{candidate template ignored}}
14 template <class Model> struct not_satisfied {
17 template <class ModelFn> struct requirement_;
18 template <void(*)()> struct instantiate
[all...] |
| class-template-spec.cpp | 2 template<typename T, typename U = int> struct A; // expected-note {{template is declared here}} \
5 template<> struct A<double, double>; // expected-note{{forward declaration}}
7 template<> struct A<float, float> { // expected-note{{previous definition}}
11 template<> struct A<float> { // expected-note{{previous definition}}
23 (void)a2->x; // expected-error{{implicit instantiation of undefined template 'A<double, int>'}}
28 template<> struct A<float, FLOAT>;
30 template<> struct A<FLOAT, float> { }; // expected-error{{redefinition}}
32 template<> struct A<float, int> { }; // expected-error{{redefinition}}
34 template<typename T, typename U = int> struct X
[all...] |
| partial-spec-instantiate.cpp | 4 template <class T> struct X {};
6 template <> struct X<char>
11 template <class T> struct X2 {};
13 template <class U>
23 template<typename T>
28 template<typename U>
31 template<typename U>
34 template<>
44 template<typename T, T N> struct X { };
45 template<bool C> struct X<bool, C>
[all...] |
| template-decl-fail.cpp | 3 template<typename T> typedef T X; // expected-error{{typedef cannot be a template}}
5 template<typename T>
6 enum t0 { A = T::x }; // expected-error{{enumeration cannot be a template}} \
10 template<int x> enum e0 f0(int a=x) {}
|
| /external/webkit/Source/WebCore/manual-tests/wml/ |
| template-go.wml | 4 <template>
5 <do name="go" type="accept" label="Template Go">
8 </template>
11 <p>Test for template element in WML. Template go button is global</p>
12 <p>This is Card one, click 'Template Go' to jump to Card two</p>
16 <p>This is card two.<br/>The global template Go button is still visible for me</p>
|
| /external/clang/include/clang/Sema/ |
| ParsedTemplate.h | 1 //===--- ParsedTemplate.h - Template Parsing Data Types -------------------===//
22 /// \brief Represents the parsed form of a C++ template argument.
25 /// \brief Describes the kind of template argument that was parsed.
27 /// \brief A template type parameter, stored as a type.
29 /// \brief A non-type template parameter, stored as an expression.
31 /// \brief A template template argument, stored as a template name.
32 Template
35 /// \brief Build an empty template argument.
[all...] |
| /external/clang/test/CXX/temp/temp.fct.spec/temp.deduct/temp.deduct.type/ |
| p17.cpp | 3 template<int i> class A { };
4 template<short s> void f(A<s>); // expected-note{{candidate template ignored: substitution failure}}
11 template<const short cs> class B { };
12 template<short s> void g(B<s>);
15 g(b); // OK: cv-qualifiers are ignored on template parameter types
18 template<short s> void h(int (&)[s]); // expected-note{{candidate function template not viable: requires 1 argument, but 2 were provided}}
25 template<short s> void h(int (&)[s], A<s>); // expected-note{{candidate template ignored: substitution failure}
[all...] |
| /external/clang/test/CXX/temp/temp.param/ |
| p2.cpp | 5 // template-parameter. typename followed by an unqualified-id names a
6 // template type parameter.
7 template<class T> struct X;
8 template<typename T> struct X;
12 template<typename T, typename T::type Value> struct Y0;
13 template<typename T, typename X<T>::type Value> struct Y1;
15 // A storage class shall not be specified in a template-parameter declaration.
16 template<static int Value> struct Z; // FIXME: expect an error
18 // Make sure that we properly disambiguate non-type template parameters that
21 template<class X1 *xptr> struct Y2 { }
[all...] |
| /external/clang/test/CXX/temp/temp.spec/temp.explicit/ |
| p8.cpp | 3 template<typename T>
12 template class X0<int(int)>; // ok; nothing gets instantiated.
14 template<typename T>
19 template<typename T>
24 template<typename T>
27 template class X0<int>; // ok
30 template<typename T>
36 template struct X1<int>; // expected-note {{here}}
38 extern template struct X1<char>; // ok
40 template struct X1<char>; // expected-note {{here}
[all...] |
| p4.cpp | 3 template<typename T> void f0(T); // expected-note{{here}}
4 template void f0(int); // expected-error{{explicit instantiation of undefined function template}}
6 template<typename T>
15 template void X0<int>::f1(); // expected-error{{explicit instantiation of undefined member function}}
17 template int X0<int>::value; // expected-error{{explicit instantiation of undefined static data member}}
19 template<> void f0(long); // expected-note{{previous template specialization is here}}
20 template void f0(long); // expected-warning{{explicit instantiation of 'f0<long>' that occurs after an explicit specialization will be ignored}}
22 template<> void X0<long>::f1(); // expected-note{{previous template specialization is here}
[all...] |
| /external/clang/test/PCH/ |
| cxx-templates.h | 3 template <typename T1, typename T2>
6 template <typename T1, typename T2>
12 template <typename T>
17 template <>
22 template <int x>
25 template <typename T, int y>
36 template <typename T>
43 template <typename T>
49 int y = T::template my_templf<int>(0);
57 template<typename T, typename A1
[all...] |
| cxx-ms-function-specialization-class-scope.h | 4 template <class T>
7 template <class U>
10 template <>
14 template <class U>
20 template <>
|
| /external/clang/test/CXX/temp/temp.decls/temp.mem/ |
| p5.cpp | 3 template <class T> operator T*();
6 template <class T> A::operator T*() { return 0; }
7 template <> A::operator char*(){ return 0; } // specialization
8 template A::operator void*(); // explicit instantiation
18 template <class T> struct A { };
19 template <class T> struct B { };
22 template <class T> operator T();
35 template <typename T> operator T();
37 template <typename T>
42 template <typename T
[all...] |
| /external/clang/test/CXX/temp/temp.names/ |
| p2.cpp | 4 // Ensure that when enforcing access control an unqualified template name with
5 // explicit template arguments, we don't lose the context of the name lookup
6 // because of the required early lookup to determine if it names a template.
8 template <typename R, typename P> void h(R (*func)(P)) {}
10 template <typename T> static void g(T*) {};
|
| /external/stlport/test/compiler/ |
| ttei6.cpp | 12 * member template classes (!_STLP_NO_MEMBER_TEMPLATE_CLASSES)
15 template <typename T1>
18 template <typename T2>
26 template <typename T1, typename T2>
29 typedef typename A<T1>:: template B<T2>::_Type ABType;
|
| ttei7.cpp | 13 * the rebind member template class technique (!_STLP_DONT_SUPPORT_REBIND_MEMBER_TEMPLATE)
16 template <typename T1>
19 template <typename T2>
27 template <typename T, typename A>
30 typedef typename A:: template B<T>::_Type _ATType;
|
