RhodeCode

    int flag;

  };

  namespace _variant_bits {

    template <int _index, typename _List>

    struct Get {

      typedef typename Get<_index - 1, typename _List::Next>::Type Type;

    };

    template <typename _List>

    struct Get<0, _List> {

      typedef typename _List::Type Type;

    };

    struct List {};

    template <typename _Type, typename _List>

    struct Insert {

      typedef _List Next;

      typedef _Type Type;

    };

    template <int _idx, typename _T0, typename _T1, typename _T2,

              typename _T7, typename _T8, typename _T9>

    struct Mapper {

      typedef List L10;

      typedef Insert<_T9, L10> L9;

      typedef Insert<_T8, L9> L8;

      typedef Insert<_T7, L8> L7;

      typedef Insert<_T6, L7> L6;

      typedef Insert<_T5, L6> L5;

      typedef Insert<_T4, L5> L4;

      typedef Insert<_T3, L4> L3;

      typedef Insert<_T2, L3> L2;

      typedef Insert<_T1, L2> L1;

      typedef Insert<_T0, L1> L0;

      typedef typename Get<_idx, L0>::Type Type;

    };

  }

  /// \brief Helper class for Variant

  ///

  /// Helper class to define type mappings for Variant. This class

  /// converts the template parameters to be mappable by integer.

  /// \see Variant

  template <

    typename _T0,

    typename _T1 = void, typename _T2 = void, typename _T3 = void,

    typename _T7 = void, typename _T8 = void, typename _T9 = void>

  struct VariantTypeMap {

    template <int _idx>

    struct Map {

      typedef typename _variant_bits::

      Mapper<_idx, _T0, _T1, _T2, _T3, _T4, _T5, _T6, _T7, _T8, _T9>::Type

      Type;

    };

  };

}

#endif