SYMBOL INDEX (163 symbols across 2 files)

FILE: CppTemplateTutorial.cpp
  type _0 (line 8) | namespace _0
    class ClassA (line 11) | class ClassA
    class ClassB (line 20) | class ClassB
    function FunctionA (line 28) | void FunctionA(T const& param)
    function T (line 32) | T FunctionB()
  type _1_1 (line 39) | namespace _1_1
    class ClassA (line 42) | class ClassA
  type _1_2 (line 52) | namespace _1_2
  type _1_2_2 (line 64) | namespace _1_2_2
    function T (line 66) | T Add(T a, T b)
    function DstT (line 71) | DstT c_style_cast(SrcT v)
    function foo (line 77) | void foo()
    function foo2 (line 85) | void foo2()
  type _1_3 (line 94) | namespace _1_3
    class A (line 96) | class A
      method foo (line 99) | void foo()
    class B (line 103) | class B {}
    class C (line 104) | class C {}
    class D (line 105) | class D {}
    class E (line 108) | class E {}
    function foo (line 111) | void foo()
    class S (line 125) | class S
    function foo2 (line 129) | void foo2()
    class ClassB (line 136) | class ClassB
    class ClassC (line 142) | class ClassC
    type StructA (line 147) | struct StructA
  type _2_2_2 (line 154) | namespace _2_2_2
    class AddFloatOrMulInt (line 156) | class AddFloatOrMulInt
      method T (line 158) | static T Do(T a, T b)
    class AddFloatOrMulInt<int> (line 167) | class AddFloatOrMulInt<int>
      method Do (line 170) | static int Do(int a, int b)
    class AddFloatOrMulInt<float> (line 177) | class AddFloatOrMulInt<float>
      method Do (line 180) | static float Do(float a, float b)
    function foo (line 186) | void foo()
  type _2_2_3 (line 193) | namespace _2_2_3
    class TypeToID (line 195) | class TypeToID
    class B (line 201) | class B {}
    class TypeToID<void ()> (line 203) | class TypeToID<void ()>
    class TypeToID<int[3]> (line 204) | class TypeToID<int[3]>
    class TypeToID<int (int[3])> (line 205) | class TypeToID<int (int[3])>
    class TypeToID<int (B::*[3])(void*, float[2])> (line 206) | class TypeToID<int (B::*[3])(void*, float[2])>
    class TypeToID<int const * volatile * const volatile> (line 208) | class TypeToID<int const * volatile * const volatile>
  type _2_2_4 (line 211) | namespace _2_2_4
    type X (line 213) | struct X {}
    type Y (line 215) | struct Y
      method foo (line 223) | static void foo()
    function foo (line 232) | void foo()
  type _2_3_3 (line 241) | namespace _2_3_3 {
    type A (line 242) | struct A
    type X (line 244) | struct X
      method foo (line 246) | void foo(T v) {
    type A (line 252) | struct A
    function foo2 (line 257) | int foo2()
  type _1_4 (line 266) | namespace _1_4
    class ClassD (line 269) | class ClassD
    class ClassD<int> (line 275) | class ClassD<int>			// 1. template <>			2. ClassD<int>
    class ClassD<float> (line 280) | class ClassD<float>
    class ClassD<T*> (line 286) | class ClassD<T*>	// 1. template <typename T>	2. ClassD<T*>
    class ClassD<int*> (line 291) | class ClassD<int*>			// 1. template <>			2. ClassD<T*>
    class ClassE (line 306) | class ClassE
    class ClassE<T, U*> (line 311) | class ClassE<T, U*>
    class ClassE<T, int> (line 316) | class ClassE<T, int>
    class ClassE<T, int*> (line 321) | class ClassE<T, int*>
    class ClassE<int, U> (line 326) | class ClassE<int, U>
    class ClassE<int, int> (line 331) | class ClassE<int, int>
    class ClassF (line 346) | class ClassF
    function foo (line 362) | void foo()
  type _2_1 (line 370) | namespace _2_1
    function foo (line 373) | void foo(T const& x) {}
    function foo (line 374) | void foo(T& y) {}
    function foo (line 375) | void foo(int&) {}
    function foo (line 376) | void foo(int) {}
    function foo (line 382) | void foo(T const*) {}
    function UninferableT (line 400) | UninferableT foo3(InferableT const&) { return UninferableT(); }
    function test (line 402) | void test()
  type _2_2 (line 421) | namespace _2_2
    class ClassA (line 424) | class ClassA
    class ClassB (line 430) | class ClassB
    class ClassC (line 436) | class ClassC: public ClassB<T>
    class ClassC (line 444) | class ClassC: public ClassA<ClassC>
    class ClassD (line 449) | class ClassD: public ClassB<ClassD>
  type _3_1 (line 457) | namespace _3_1
    function equal (line 459) | bool equal(int a, int b)
    class Equal (line 476) | class Equal
    class Equal<T, T> (line 483) | class Equal<T, T>
  type _3_2 (line 494) | namespace _3_2
    class ClassA (line 496) | class ClassA
    type Mark (line 500) | struct Mark
    function TestIncrementAdd (line 507) | Mark<1> TestIncrementAdd(T const& v)
    function TestIncrementAdd (line 515) | Mark<2> TestIncrementAdd(T const& v)
    class ClassB (line 524) | class ClassB
    function test (line 530) | void test(typename T::Marker) { }
    function test (line 531) | void test(T) { }
    function DoTest (line 533) | void DoTest()
  type _3_3 (line 541) | namespace _3_3
    class is_same (line 543) | class is_same
    class is_base_of (line 546) | class is_base_of
    class B (line 556) | class B
    class D (line 560) | class D: public B
    class D2 (line 564) | class D2: public D
    class is_class (line 570) | class is_class
    class Convertible (line 586) | class Convertible
    class is_base_of (line 604) | class is_base_of
  type _3_4 (line 626) | namespace _3_4
    function basic_algo (line 629) | int basic_algo(int a, int b)
    function recursive_algo (line 642) | int recursive_algo(int a, int b)
    class MetaSum (line 653) | class MetaSum
    class MetaSum<a, a> (line 660) | class MetaSum<a, a>
  type _3_5 (line 670) | namespace _3_5
    class Fibonacci (line 673) | class Fibonacci
    class Fibonacci<0> (line 680) | class Fibonacci<0>
    class Fibonacci<1> (line 687) | class Fibonacci<1>
  type _4 (line 697) | namespace _4
    class ClassA (line 705) | class ClassA
    class ClassB (line 711) | class ClassB
    class ClassC (line 718) | class ClassC
    class ClassD (line 728) | class ClassD
      class NestedType (line 731) | class NestedType
    class ClassE (line 735) | class ClassE
      class NestedType (line 738) | class NestedType
    class ClassF (line 742) | class ClassF
  type _5_1 (line 756) | namespace _5_1
    class int_ (line 766) | class int_
    function Do (line 776) | void Do(T* obj, int_<2>)
    function Do (line 781) | void Do(T* obj, int_<1>)
    function foo (line 785) | void foo()
    function DoAnotherWay (line 790) | void DoAnotherWay(T* obj)
    class bool_ (line 796) | class bool_
    class add_ (line 815) | class add_
    class add_ (line 825) | class add_
    class add_c (line 833) | class add_c
    class add2_ (line 848) | class add2_: public int_<T::value+U::value>
  type _5_2 (line 857) | namespace _5_2
    class pair_ (line 865) | class pair_
    class Nil (line 871) | class Nil
    class make_vector_ (line 877) | class make_vector_
    class make_vector_<Nil, Nil, Nil, Nil> (line 883) | class make_vector_<Nil, Nil, Nil, Nil>
    class vector_ (line 889) | class vector_: public make_vector_<T0, T1, T2, T3>::type
  function _tmain (line 907) | int _tmain(int argc, _TCHAR* argv[])

FILE: QuickSort.cpp
  type to_int_types (line 9) | struct to_int_types{
  type Less (line 13) | struct Less {
    type Apply (line 14) | struct Apply {
  type GE (line 19) | struct GE {
    type Apply (line 20) | struct Apply {
  type Tuple_PushFront (line 25) | struct Tuple_PushFront {}
  type Tuple_PushFront<x, true, tuple<tupleElems...>> (line 26) | struct Tuple_PushFront<x, true, tuple<tupleElems...>> {
  type Tuple_PushFront<x, false, tuple<tupleElems...>> (line 29) | struct Tuple_PushFront<x, false, tuple<tupleElems...>> {
  type Filter (line 33) | struct Filter
  type Filter< Pred, tuple<> > (line 34) | struct Filter< Pred, tuple<> > {
  type Filter< Pred, tuple<Head, Ts...> > (line 37) | struct Filter< Pred, tuple<Head, Ts...> > {
  type ConcatenateTuple (line 43) | struct ConcatenateTuple {}
  type ConcatenateTuple<Tuple0> (line 44) | struct ConcatenateTuple<Tuple0> {
  type ConcatenateTuple<Tuple0, Tuple1> (line 48) | struct ConcatenateTuple<Tuple0, Tuple1> {
    type ConcatenateImpl (line 49) | struct ConcatenateImpl {}
  type ConcatenateImpl< tuple<TAs...> > (line 50) | struct ConcatenateImpl< tuple<TAs...> > {
    type Apply (line 51) | struct Apply
  type Apply< tuple<TBs...> > (line 52) | struct Apply< tuple<TBs...> > {
  type ConcatenateTuple<FirstTuple, Follows...> (line 58) | struct ConcatenateTuple<FirstTuple, Follows...> {
  type QuickSort (line 64) | struct QuickSort {}
  type QuickSort< tuple<  > > (line 65) | struct QuickSort< tuple<  > > { typedef tuple<  > type; }
  type QuickSort< tuple<T0> > (line 66) | struct QuickSort< tuple<T0> > { typedef tuple<T0> type; }
  type QuickSort< tuple<Head, Ts...> > (line 68) | struct QuickSort< tuple<Head, Ts...> > {
  function StaticTest (line 76) | void StaticTest()