搞定模板元编程（meta programming）

搞定模板元编程（meta programming）

    今天闲得无聊，早上起来习惯性瞟一瞟boost，突然看中了它的MPL库，所以自己实现了一个子集消磨时间。

    已经实现的功能有：整数运算、闭包、列表处理等。我用了自己的unit test框架，通过写一个函数输出一个属于自己的MPL类型的字符串（譬如List<Int<0>,List<Int<1>,Empty>>产生"[0 , 1]"），然后用自己写的字符串比较，可以发现库里面是否有错。

    一下有两份代码，第一份是使用，第二份是自己的MPL的源代码：

    首先是unit test的内容：

 1  void  Test_Type::TestMPL()
 2  {
 3      VL_UNITTEST_CHECK(ToString < Char < ' A ' >> ::Eval() == L " \'A\' " );
 4      VL_UNITTEST_CHECK(ToString < WChar < ' A ' >> ::Eval() == L " L\'A\' " );
 5      VL_UNITTEST_CHECK(ToString < Int < 100 >> ::Eval() == L " 100 " );
 6      VL_UNITTEST_CHECK(ToString < Bool < true >> ::Eval() == L " true " );
 7      VL_UNITTEST_CHECK(ToString < Bool < false >> ::Eval() == L " false " );
 8 
 9      VL_UNITTEST_CHECK((ToString <
10          Plus_ < Int < 1 > ,Int < 2 >> ::Type
11           > ::Eval() == L " 3 " ));
12      VL_UNITTEST_CHECK((ToString <
13          Empty
14           > ::Eval() == L " [] " ));
15      VL_UNITTEST_CHECK((ToString <
16          List < Char < ' A ' > ,List < Char < ' B ' > ,List < Char < ' C ' > ,Empty >>>
17           > ::Eval() == L " [\'A\' , \'B\' , \'C\'] " ));
18      VL_UNITTEST_CHECK((ToString <
19          List < Int < 0 > ,List < Int < 1 > ,List < Int < 2 > ,Empty >>>
20           > ::Eval() == L " [0 , 1 , 2] " ));
21 
22  typedef Iterate_ < Bind2 < Plus,Int < 1 >> ,Int < 0 > ,Int < 3 >> ::Type LIST_012;
23  typedef Iterate_ < Bind2 < Plus,Int < 1 >> ,Int < 3 > ,Int < 3 >> ::Type LIST_345;
24  typedef Iterate_ < Bind2 < Plus,Int < 1 >> ,Int < 1 > ,Int < 10 >> ::Type LONG_LIST;
25 
26      VL_UNITTEST_CHECK((ToString <
27          Reverse_ < LIST_012 > ::Type
28           > ::Eval() == L " [2 , 1 , 0] " ));
29 
30      VL_UNITTEST_CHECK((ToString <
31          Concat_ < LIST_012,LIST_345 > ::Type
32           > ::Eval() == L " [0 , 1 , 2 , 3 , 4 , 5] " ));
33 
34      VL_UNITTEST_CHECK((ToString <
35          Filter_ < Bind2 < RevOp < Egt > ,Int < 2 >> ,Concat_ < LIST_012,LIST_345 >> ::Type
36           > ::Eval() == L " [2 , 3 , 4 , 5] " ));
37 
38      VL_UNITTEST_CHECK((ToString <
39          Transform_ < Bind2 < Multiply,Int < 2 >> ,Concat_ < LIST_012,LIST_345 >> ::Type
40           > ::Eval() == L " [0 , 2 , 4 , 6 , 8 , 10] " ));
41 
42      VL_UNITTEST_CHECK((ToString <
43          Transform_ < Sqr,Concat_ < LIST_012,LIST_345 >> ::Type
44           > ::Eval() == L " [0 , 1 , 4 , 9 , 16 , 25] " ));
45 
46      VL_UNITTEST_CHECK((ToString <
47          Foldl_ < Plus,Int < 0 > ,LONG_LIST > ::Type
48           > ::Eval() == L " 55 " ));
49 
50      VL_UNITTEST_CHECK((ToString <
51          Foldr_ < Plus,Int < 0 > ,LONG_LIST > ::Type
52           > ::Eval() == L " 55 " ));
53 
54      VL_UNITTEST_CHECK((ToString <
55          Foldl_ < Minus,Int < 0 > ,LONG_LIST > ::Type
56           > ::Eval() == L " -55 " ));
57 
58      VL_UNITTEST_CHECK((ToString <
59          Foldr_ < Minus,Int < 0 > ,LONG_LIST > ::Type
60           > ::Eval() == L " -5 " ));
61 
62      VL_UNITTEST_CHECK((ToString <
63          Foldl_ < Plus,Int < 0 > ,Take_ < LONG_LIST,Int < 9 >>> ::Type
64           > ::Eval() == L " 45 " ));
65 
66      VL_UNITTEST_CHECK((ToString <
67          Foldl_ < Plus,Int < 0 > ,Drop_ < LONG_LIST,Int < 1 >>> ::Type
68           > ::Eval() == L " 54 " ));
69  }

    这里是MPL源代码：

  1  /* ******************************************************************************
  2  Vczh Library++ 2.0
  3  数据结构::元编程
  4  开发者：陈梓瀚
  5 
  6  函数：
  7    Plus
  8    Minus
  9    Multiply
 10    Divid
 11    Mod
 12    Neg
 13    Sqr
 14    And
 15    Or
 16    Xor
 17    Not
 18    Equ
 19    Neq
 20    Lt
 21    Gt
 22    Elt
 23    Egt
 24    If
 25    IsEmpty
 26    Head
 27    Tail
 28    Concat
 29    Reverse
 30    Filter
 31    Transform
 32    Foldl
 33    Foldr
 34    Take
 35    Drop
 36    Count
 37    Iterate
 38  ****************************************************************************** */
 39 
 40  #ifndef VL_MPL
 41  #define  VL_MPL
 42 
 43  #include  " ..\Data\VL_Data_String.h "
 44 
 45  namespace  vl
 46  {
 47       namespace  mp
 48      {
 49 
 50  /* ********************************************************************************************************
 51  数值
 52  ******************************************************************************************************** */
 53 
 54          template < char  V >
 55           struct  Char
 56          {
 57               static   const   char  Value = V;
 58              typedef Char < V >  Type;
 59          };
 60 
 61          template < wchar_t V >
 62           struct  WChar
 63          {
 64               static   const  wchar_t Value = V;
 65              typedef WChar < V >  Type;
 66          };
 67 
 68          template < int  V >
 69           struct  Int
 70          {
 71               static   const   int  Value = V;
 72              typedef Int < V >  Type;
 73          };
 74 
 75          template < bool  V >
 76           struct  Bool
 77          {
 78               static   const   bool  Value = V;
 79              typedef Bool < V >  Type;
 80          };
 81 
 82           struct  Empty
 83          {
 84              typedef Empty Type;
 85          };
 86 
 87          template < typename H , typename T >
 88           struct  List
 89          {
 90              typedef List < H,T >  Type;
 91          };
 92 
 93  /* ********************************************************************************************************
 94  函数调用
 95  ******************************************************************************************************** */
 96 
 97          template < typename F , typename A >
 98           struct  Apply
 99          {
100              typedef typename F::Apply < typename A::Type > ::Type Type;
101          };
102 
103          template < typename F , typename A , typename B >
104           struct  Apply2
105          {
106              typedef typename F::Apply2 < typename A::Type,typename B::Type > ::Type Type;
107          };
108 
109          template < typename F , typename A , typename B , typename C >
110           struct  Apply3
111          {
112              typedef typename F::Apply3 < typename A::Type,typename B::Type,typename C::Type > ::Type Type;
113          };
114 
115          template < typename F , typename A , typename B , typename C , typename D >
116           struct  Apply4
117          {
118              typedef typename F::Apply4 < typename A::Type,typename B::Type,typename C::Type,typename D::Type > ::Type Type;
119          };
120 
121          template < typename F , typename A , typename B , typename C , typename D , typename E >
122           struct  Apply5
123          {
124              typedef typename F::Apply5 < typename A::Type,typename B::Type,typename C::Type,typename D::Type,typename E::Type > ::Type Type;
125          };
126 
127  #define  MPL_PACK(NAME)    template<typename A>                                                    struct NAME##_{typedef typename mp::Apply<NAME,A>::Type Type;}
128  #define  MPL_PACK2(NAME)    template<typename A , typename B>                                        struct NAME##_{typedef typename mp::Apply2<NAME,A,B>::Type Type;}
129  #define  MPL_PACK3(NAME)    template<typename A , typename B , typename C>                            struct NAME##_{typedef typename mp::Apply3<NAME,A,B,C>::Type Type;}
130  #define  MPL_PACK4(NAME)    template<typename A , typename B , typename C , typename D>                struct NAME##_{typedef typename mp::Apply4<NAME,A,B,C,D>::Type Type;}
131  #define  MPL_PACK5(NAME)    template<typename A , typename B , typename C , typename D , typename E>struct NAME##_{typedef typename mp::Apply5<NAME,A,B,C,D,E>::Type Type;}
132  #define  MPL_PRINT_TO_ERROR(NAME) do{typedef NAME Type;typedef NAME::WRONG_TYPE WRONG_TYPE;}while(0)
133 
134  /* ********************************************************************************************************
135  绑定器
136  ******************************************************************************************************** */
137 
138          template < typename F , typename P >
139           struct  Bind2
140          {
141              template < typename P1 >
142               struct  Apply
143              {
144                  typedef typename mp::Apply2 < F,P,P1 > ::Type Type;
145              };
146 
147              typedef Bind2 < F,P >  Type;
148          };
149 
150          template < typename F , typename P >
151           struct  Bind3
152          {
153              template < typename P1 , typename P2 >
154               struct  Apply2
155              {
156                  typedef typename mp::Apply3 < F,P,P1,P2 > ::Type Type;
157              };
158 
159              typedef Bind3 < F,P >  Type;
160          };
161 
162          template < typename F , typename P >
163           struct  Bind4
164          {
165              template < typename P1 , typename P2 , typename P3 >
166               struct  Apply3
167              {
168                  typedef typename mp::Apply4 < F,P,P1,P2,P3 > ::Type Type;
169              };
170 
171              typedef Bind4 < F,P >  Type;
172          };
173 
174          template < typename F , typename P >
175           struct  Bind5
176          {
177              template < typename P1 , typename P2 , typename P3 , typename P4 >
178               struct  Apply4
179              {
180                  typedef typename mp::Apply5 < F,P,P1,P2,P3,P4 > ::Type Type;
181              };
182 
183              typedef Bind5 < F,P >  Type;
184          };
185 
186          template < typename F >
187           struct  RevOp
188          {
189              template < typename P1 , typename P2 >
190               struct  Apply2
191              {
192                  typedef typename mp::Apply2 < F,P2,P1 > ::Type Type;
193              };
194 
195              typedef RevOp < F >  Type;
196          };
197 
198  /* ********************************************************************************************************
199  基本函数
200  ******************************************************************************************************** */
201 
202           struct  Plus
203          {
204              template < typename A , typename B >
205               struct  Apply2
206              {
207              };
208 
209              template < int  A ,  int  B >
210               struct  Apply2 < Int < A >  , Int < B >>
211              {
212                  typedef Int < A + B >  Type;
213              };
214 
215              typedef Plus Type;
216          };
217          MPL_PACK2(Plus);
218 
219           struct  Minus
220          {
221              template < typename A , typename B >
222               struct  Apply2
223              {
224              };
225 
226              template < int  A ,  int  B >
227               struct  Apply2 < Int < A >  , Int < B >>
228              {
229                  typedef Int < A - B >  Type;
230              };
231 
232              typedef Minus Type;
233          };
234          MPL_PACK2(Minus);
235 
236           struct  Multiply
237          {
238              template < typename A , typename B >
239               struct  Apply2
240              {
241              };
242 
243              template < int  A ,  int  B >
244               struct  Apply2 < Int < A >  , Int < B >>
245              {
246                  typedef Int < A * B >  Type;
247              };
248 
249              typedef Multiply Type;
250          };
251          MPL_PACK2(Multiply);
252 
253           struct  Divid
254          {
255              template < typename A , typename B >
256               struct  Apply2
257              {
258              };
259 
260              template < int  A ,  int  B >
261               struct  Apply2 < Int < A >  , Int < B >>
262              {
263                  typedef Int < A / B >  Type;
264              };
265 
266              typedef Divid Type;
267          };
268          MPL_PACK2(Divid);
269 
270           struct  Mod
271          {
272              template < typename A , typename B >
273               struct  Apply2
274              {
275              };
276 
277              template < int  A ,  int  B >
278               struct  Apply2 < Int < A >  , Int < B >>
279              {
280                  typedef Int < A % B >  Type;
281              };
282 
283              typedef Mod Type;
284          };
285          MPL_PACK2(Mod);
286 
287           struct  Neg
288          {
289              template < typename A >
290               struct  Apply
291              {
292              };
293 
294              template < int  A >
295               struct  Apply < Int < A >>
296              {
297                  typedef Int <- A >  Type;
298              };
299 
300              typedef Neg Type;
301          };
302          MPL_PACK(Neg);
303 
304           struct  Sqr
305          {
306              template < typename A >
307               struct  Apply
308              {
309              };
310 
311              template < int  A >
312               struct  Apply < Int < A >>
313              {
314                  typedef Int < A * A >  Type;
315              };
316 
317              typedef Sqr Type;
318          };
319          MPL_PACK(Sqr);
320 
321           struct  And
322          {
323              template < typename A , typename B >
324               struct  Apply2
325              {
326              };
327              
328              template < bool  A ,  bool  B >
329               struct  Apply2 < Bool < A >  , Bool < B >>
330              {
331                  typedef Bool < A && B >  Type;
332              };
333 
334              typedef And Type;
335          };
336          MPL_PACK2(And);
337 
338           struct  Or
339          {
340              template < typename A , typename B >
341               struct  Apply2
342              {
343              };
344              
345              template < bool  A ,  bool  B >
346               struct  Apply2 < Bool < A >  , Bool < B >>
347              {
348                  typedef Bool < A || B >  Type;
349              };
350 
351              typedef Or Type;
352          };
353          MPL_PACK2(Or);
354 
355           struct  Xor
356          {
357              template < typename A , typename B >
358               struct  Apply2
359              {
360              };
361              
362              template < bool  A ,  bool  B >
363               struct  Apply2 < Bool < A >  , Bool < B >>
364              {
365                  typedef Bool < A ^ B >  Type;
366              };
367 
368              typedef Xor Type;
369          };
370          MPL_PACK2(Xor);
371 
372           struct  Not
373          {
374              template < typename A >
375               struct  Apply
376              {
377              };
378              
379              template < bool  A >
380               struct  Apply < Bool < A >>
381              {
382                  typedef Bool <! A >  Type;
383              };
384 
385              typedef Not Type;
386          };
387          MPL_PACK(Not);
388 
389           struct  Equ
390          {
391              template < typename A , typename B >
392               struct  Apply2
393              {
394                  typedef Bool < false >  Type;
395              };
396 
397              template < typename A >
398               struct  Apply2 < A , A >
399              {
400                  typedef Bool < true >  Type;
401              };
402 
403              typedef Equ Type;
404          };
405          MPL_PACK2(Equ);
406 
407           struct  Neq
408          {
409              template < typename A , typename B >
410               struct  Apply2
411              {
412                  typedef typename Not_ < Equ_ < A,B >> ::Type Type;
413              };
414 
415              typedef Neq Type;
416          };
417          MPL_PACK2(Neq);
418 
419           struct  Lt
420          {
421              template < typename A , typename B >
422               struct  Apply2
423              {
424              };
425 
426              template < char  A ,  char  B >
427               struct  Apply2 < Char < A >  , Char < B >>
428              {
429                  typedef Bool < (A < B) >  Type;
430              };
431 
432              template < wchar_t A , wchar_t B >
433               struct  Apply2 < WChar < A >  , WChar < B >>
434              {
435                  typedef Bool < (A < B) >  Type;
436              };
437 
438              template < int  A ,  int  B >
439               struct  Apply2 < Int < A >  , Int < B >>
440              {
441                  typedef Bool < (A < B) >  Type;
442              };
443 
444              typedef Lt Type;
445          };
446          MPL_PACK2(Lt);
447 
448           struct  Gt
449          {
450              template < typename A , typename B >
451               struct  Apply2
452              {
453                  typedef typename Not_ < Or_ < Lt_ < A,B > ,Equ_ < A,B >>> ::Type Type;
454              };
455 
456              typedef Gt Type;
457          };
458          MPL_PACK2(Gt);
459 
460           struct  Elt
461          {
462              template < typename A , typename B >
463               struct  Apply2
464              {
465                  typedef typename Not_ < Gt_ < A,B >> ::Type Type;
466              };
467 
468              typedef Elt Type;
469          };
470          MPL_PACK2(Elt);
471 
472           struct  Egt
473          {
474              template < typename A , typename B >
475               struct  Apply2
476              {
477                  typedef typename Not_ < Lt_ < A,B >> ::Type Type;
478              };
479 
480              typedef Egt Type;
481          };
482          MPL_PACK2(Egt);
483 
484           struct  If
485          {
486              template < typename A , typename B , typename C >
487               struct  Apply3
488              {
489              };
490 
491              template < typename A , typename B >
492               struct  Apply3 < Bool < true >  , A , B >
493              {
494                  typedef A Type;
495              };
496 
497              template < typename A , typename B >
498               struct  Apply3 < Bool < false >  , A , B >
499              {
500                  typedef B Type;
501              };
502 
503              typedef If Type;
504          };
505          MPL_PACK3(If);
506 
507  /* ********************************************************************************************************
508  列表操作
509  ******************************************************************************************************** */
510 
511           struct  IsEmpty
512          {
513              template < typename A >
514               struct  Apply
515              {
516              };
517 
518              template <>
519               struct  Apply < Empty >
520              {
521                  typedef Bool < true >  Type;
522              };
523 
524              template < typename H , typename T >
525               struct  Apply < List < H,T >>
526              {
527                  typedef Bool < false >  Type;
528              };
529 
530              typedef IsEmpty Type;
531          };
532          MPL_PACK(Empty);
533 
534           struct  Head
535          {
536              template < typename A >
537               struct  Apply
538              {
539              };
540 
541              template < typename H , typename T >
542               struct  Apply < List < H,T >>
543              {
544                  typedef H Type;
545              };
546 
547              typedef Head Type;
548          };
549          MPL_PACK(Head);
550 
551           struct  Tail
552          {
553              template < typename A >
554               struct  Apply
555              {
556              };
557 
558              template < typename H , typename T >
559               struct  Apply < List < H,T >>
560              {
561                  typedef T Type;
562              };
563 
564              typedef Tail Type;
565          };
566          MPL_PACK(Tail);
567 
568           struct  Concat
569          {
570              template < typename A , typename B >
571               struct  Apply2
572              {
573              };
574 
575              template <>
576               struct  Apply2 < Empty,Empty >
577              {
578                  typedef Empty Type;
579              };
580 
581              template < typename H2 , typename T2 >
582               struct  Apply2 < Empty,List < H2,T2 >>
583              {
584                  typedef List < H2,T2 >  Type;
585              };
586 
587              template < typename H1 , typename T1 >
588               struct  Apply2 < List < H1,T1 > ,Empty >
589              {
590                  typedef List < H1,T1 >  Type;
591              };
592 
593              template < typename H1 , typename T1 , typename H2 , typename T2 >
594               struct  Apply2 < List < H1,T1 > ,List < H2,T2 >>
595              {
596                  typedef List < H1,typename mp::Apply2 < Concat,T1,List < H2,T2 >> ::Type >  Type;
597              };
598 
599              typedef Concat Type;
600          };
601          MPL_PACK2(Concat);
602 
603           struct  Reverse
604          {
605              template < typename A >
606               struct  Apply
607              {
608              };
609 
610              template <>
611               struct  Apply < Empty >
612              {
613                  typedef Empty Type;
614              };
615 
616              template < typename H >
617               struct  Apply < List < H,Empty >>
618              {
619                  typedef List < H,Empty >  Type;
620              };
621 
622              template < typename H , typename T >
623               struct  Apply < List < H,T >>
624              {
625                  typedef typename Concat_ < mp::Apply < Reverse,T > ,List < H,Empty >> ::Type Type;
626              };
627 
628              typedef Reverse Type;
629          };
630          MPL_PACK(Reverse);
631 
632           struct  Filter
633          {
634              template < typename A , typename B >
635               struct  Apply2
636              {
637              };
638 
639              template < typename F >
640               struct  Apply2 < F,Empty >
641              {
642                  typedef Empty Type;
643              };
644 
645              template < typename F , typename H , typename T >
646               struct  Apply2 < F,List < H,T >>
647              {
648                  typedef
649                      typename If_ <
650                          mp::Apply < F,H > ,
651                          List < H,typename mp::Apply2 < Filter,F,T > ::Type > ,
652                          mp::Apply2 < Filter,F,T >
653                       > ::Type Type;
654              };
655 
656              typedef Filter Type;
657          };
658          MPL_PACK2(Filter);
659 
660           struct  Transform
661          {
662              template < typename A , typename B >
663               struct  Apply2
664              {
665              };
666 
667              template < typename F >
668               struct  Apply2 < F,Empty >
669              {
670                  typedef Empty Type;
671              };
672 
673              template < typename F , typename H , typename T >
674               struct  Apply2 < F,List < H,T >>
675              {
676                  typedef List < typename mp::Apply < F,H > ::Type,typename mp::Apply2 < Transform,F,T > ::Type >  Type;
677              };
678 
679              typedef Transform Type;
680          };
681          MPL_PACK2(Transform);
682 
683           struct  Foldl
684          {
685              template < typename A , typename B , typename C >
686               struct  Apply3
687              {
688              };
689 
690              template < typename F , typename I >
691               struct  Apply3 < F,I,Empty >
692              {
693                  typedef I Type;
694              };
695 
696              template < typename F , typename I , typename H , typename T >
697               struct  Apply3 < F,I,List < H,T >>
698              {
699                  typedef typename mp::Apply3 < Foldl,F,mp::Apply2 < F,I,H > ,T > ::Type Type;
700              };
701 
702              typedef Foldl Type;
703          };
704          MPL_PACK3(Foldl);
705 
706           struct  Foldr
707          {
708              template < typename A , typename B , typename C >
709               struct  Apply3
710              {
711              };
712 
713              template < typename F , typename I >
714               struct  Apply3 < F,I,Empty >
715              {
716                  typedef I Type;
717              };
718 
719              template < typename F , typename I , typename H , typename T >
720               struct  Apply3 < F,I,List < H,T >>
721              {
722                  typedef typename mp::Apply2 < F,H,mp::Apply3 < Foldr,F,I,T >> ::Type Type;
723              };
724 
725              typedef Foldr Type;
726          };
727          MPL_PACK3(Foldr);
728 
729           struct  Take
730          {
731              template < typename A , typename B >
732               struct  Apply2
733              {
734              };
735 
736              template <>
737               struct  Apply2 < Empty,Int < 0 >>
738              {
739                  typedef Empty Type;
740              };
741 
742              template < int  I >
743               struct  Apply2 < Empty,Int < I >>
744              {
745                  typedef Empty Type;
746              };
747 
748              template < typename H , typename T >
749               struct  Apply2 < List < H,T > ,Int < 0 >>
750              {
751                  typedef Empty Type;
752              };
753 
754              template < typename H , typename T ,  int  I >
755               struct  Apply2 < List < H,T > ,Int < I >>
756              {
757                  typedef List < H,typename mp::Apply2 < Take,T,Int < I - 1 >> ::Type >  Type;
758              };
759 
760              typedef Take Type;
761          };
762          MPL_PACK2(Take);
763 
764           struct  Drop
765          {
766              template < typename A , typename B >
767               struct  Apply2
768              {
769              };
770 
771              template <>
772               struct  Apply2 < Empty,Int < 0 >>
773              {
774                  typedef Empty Type;
775              };
776 
777              template < int  I >
778               struct  Apply2 < Empty,Int < I >>
779              {
780                  typedef Empty Type;
781              };
782 
783              template < typename H , typename T >
784               struct  Apply2 < List < H,T > ,Int < 0 >>
785              {
786                  typedef List < H,T >  Type;
787              };
788 
789              template < typename H , typename T ,  int  I >
790               struct  Apply2 < List < H,T > ,Int < I >>
791              {
792                  typedef typename mp::Apply2 < Drop,T,Int < I - 1 >> ::Type Type;
793              };
794 
795              typedef Drop Type;
796          };
797          MPL_PACK2(Drop);
798 
799           struct  Count
800          {
801              template < typename A >
802               struct  Apply
803              {
804              };
805 
806              template <>
807               struct  Apply < Empty >
808              {
809                  typedef Int < 0 >  Type;
810              };
811 
812              template < typename H , typename T >
813               struct  Apply < List < H,T >>
814              {
815                  typedef typename Plus_ < Int < 1 > ,mp::Apply < Count,T >> ::Type Type;
816              };
817 
818              typedef Count Type;
819          };
820          MPL_PACK(Count);
821 
822           struct  Iterate
823          {
824               struct  Iterate_Internal
825              {
826                  template < typename A , typename B , typename C , typename D >
827                   struct  Apply4
828                  {
829                  };
830 
831                  template < typename F , typename L , typename V >
832                   struct  Apply4 < F,L,V,Int < 0 >>
833                  {
834                      typedef L Type;
835                  };
836 
837                  template < typename F , typename L , typename V ,  int  I >
838                   struct  Apply4 < F,L,V,Int < I >>
839                  {
840                      typedef typename mp::Apply4 < Iterate_Internal,F,Concat_ < L,List < V,Empty >> ,mp::Apply < F,V > ,Int < I - 1 >> ::Type Type;
841                  };
842              };
843 
844              template < typename F , typename V , typename C >
845               struct  Apply3
846              {
847                  typedef typename mp::Apply4 < Iterate_Internal,F,Empty,V,C > ::Type Type;
848              };
849 
850              typedef Iterate Type;
851          };
852          MPL_PACK3(Iterate);
853 
854  /* ********************************************************************************************************
855  转字符串
856  ******************************************************************************************************** */
857 
858          template < typename T >
859           struct  ToString
860          {
861               static  VUnicodeString Eval()
862              {
863                   return  L "" ;
864              }
865          };
866 
867          template < bool  V >
868           struct  ToString < Bool < V >>
869          {
870               static  VUnicodeString Eval()
871              {
872                   return  V ? L " true " :L " false " ;
873              }
874          };
875 
876          template < char  V >
877           struct  ToString < Char < V >>
878          {
879               static  VUnicodeString Eval()
880              {
881                   return  L " \' " + VUnicodeString(ToUnicode(V)) + L " \' " ;
882              }
883          };
884 
885          template < wchar_t V >
886           struct  ToString < WChar < V >>
887          {
888               static  VUnicodeString Eval()
889              {
890                   return  L " L\' " + VUnicodeString(V) + L " \' " ;
891              }
892          };
893 
894          template < int  V >
895           struct  ToString < Int < V >>
896          {
897               static  VUnicodeString Eval()
898              {
899                   return  V;
900              }
901          };
902 
903          template <>
904           struct  ToString < Empty >
905          {
906               static  VUnicodeString Eval()
907              {
908                   return  L " [] " ;
909              }
910          };
911 
912          template < typename H >
913           struct  ToString < List < H,Empty >>
914          {
915               static  VUnicodeString Eval()
916              {
917                   return  L " [ " + ToString < H > ::Eval() + L " ] " ;
918              }
919          };
920 
921          template < typename H , typename T >
922           struct  ToString < List < H,T >>
923          {
924               static  VUnicodeString Eval()
925              {
926                  VUnicodeString Tail = ToString < T > ::Eval();
927                  Tail.Delete( 0 , 1 );
928                   return  L " [ " + ToString < H > ::Eval() + L "  ,  " + Tail;
929              }
930          };
931      }
932  }
933 
934  #endif