[cfe-commits] r73147 - /cfe/trunk/test/SemaTemplate/example-typelist.cpp

Tue Jun 9 14:22:32 PDT 2009

Author: dgregor
Date: Tue Jun  9 16:22:32 2009
New Revision: 73147

URL: http://llvm.org/viewvc/llvm-project?rev=73147&view=rev
Log:
Example metaprogram for reversing and searching in a type list

Modified:
    cfe/trunk/test/SemaTemplate/example-typelist.cpp

Modified: cfe/trunk/test/SemaTemplate/example-typelist.cpp
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/test/SemaTemplate/example-typelist.cpp?rev=73147&r1=73146&r2=73147&view=diff

==============================================================================

--- cfe/trunk/test/SemaTemplate/example-typelist.cpp (original)
+++ cfe/trunk/test/SemaTemplate/example-typelist.cpp Tue Jun  9 16:22:32 2009
@@ -1,5 +1,6 @@
 // RUN: clang-cc -fsyntax-only -verify %s
 
+// A simple cons-style typelist
 struct nil { };
 
 template<typename Head, typename Tail = nil>
@@ -8,6 +9,17 @@
   typedef Tail tail;
 };
 
+// is_same trait, for testing
+template<typename T, typename U>
+struct is_same {
+  static const bool value = false;
+};
+
+template<typename T>
+struct is_same<T, T> {
+  static const bool value = true;
+};
+
 // metaprogram that computes the length of a list
 template<typename T> struct length;
 
@@ -26,3 +38,61 @@
                   cons<unsigned int,
                        cons<unsigned long> > > > unsigned_inttypes;
 int length0[length<unsigned_inttypes>::value == 4? 1 : -1];
+
+// metaprogram that reverses a list
+
+// FIXME: I would prefer that this be a partial specialization, but
+// that requires partial ordering of class template partial
+// specializations.
+template<typename T> 
+class reverse {
+  typedef typename reverse<typename T::tail>::type reversed_tail;
+
+  typedef typename reverse<typename reversed_tail::tail>::type most_of_tail;
+
+public:
+  typedef cons<typename reversed_tail::head,
+               typename reverse<cons<typename T::head, most_of_tail> >::type> type;
+};
+
+template<typename Head>
+class reverse<cons<Head> > {
+public:
+  typedef cons<Head> type;
+};
+
+template<>
+class reverse<nil> {
+public:
+  typedef nil type;
+};
+
+int reverse0[is_same<reverse<unsigned_inttypes>::type,
+                     cons<unsigned long, 
+                          cons<unsigned int, 
+                               cons<unsigned short,
+                                    cons<unsigned char> > > > >::value? 1 : -1];
+
+// metaprogram that finds a type within a list
+
+// FIXME: I would prefer that this be a partial specialization, but
+// that requires partial ordering of class template partial
+// specializations.
+template<typename List, typename T>
+struct find : find<typename List::tail, T> { };
+
+template<typename Tail, typename T>
+struct find<cons<T, Tail>, T> {
+  typedef cons<T, Tail> type;
+};
+
+template<typename T>
+struct find<nil, T> {
+  typedef nil type;
+};
+
+int find0[is_same<find<unsigned_inttypes, unsigned int>::type,
+                       cons<unsigned int, cons<unsigned long> > >::value?
+             1 : -1];
+int find1[is_same<find<unsigned_inttypes, int>::type, nil>::value? 1 : -1];
+



