36 #ifndef VIGRA_TYPE_LISTS_HXX 
   37 #define VIGRA_TYPE_LISTS_HXX 
   43 #include "metaprogramming.hxx" 
   44 #include "bit_array.hxx" 
   51 #pragma warning( push ) 
   52 #pragma warning( disable : 4503 ) 
   55 namespace type_lists {
 
   63     template <
class A, 
class B = nil> 
struct cons
 
   69     template <
class X, 
class A, 
class B> 
struct if_nil
 
   73     template <
class A, 
class B> 
struct if_nil <nil, A, B>
 
   80     template <
class X, 
class L, 
class NIL = nil> 
struct truncate
 
   82         typedef cons<
typename L::first,
 
   83                      typename truncate<X, typename L::rest, NIL>::type> type;
 
   85     template <
class L, 
class NIL> 
struct truncate<typename L::first, L, NIL>
 
   89     template <
class X, 
class NIL> 
struct truncate<X, NIL, NIL>
 
   94     template <
class NIL, 
class A = NIL, 
class B = NIL, 
class C = NIL,
 
   95                          class D = NIL, 
class E = NIL, 
class F = NIL,
 
   96                          class G = NIL, 
class H = NIL, 
class I = NIL,
 
   97                          class J = NIL, 
class K = NIL, 
class L = NIL,
 
   98                          class M = NIL, 
class N = NIL, 
class O = NIL,
 
   99                          class P = NIL, 
class Q = NIL, 
class R = NIL,
 
  100                          class S = NIL, 
class T = NIL, 
class U = NIL,
 
  101                          class V = NIL, 
class W = NIL, 
class X = NIL,
 
  102                          class Y = NIL, 
class Z = NIL>
 
  103     struct make_list_nil {
 
  104         typedef typename truncate<NIL, cons<A, cons<B, cons<C, cons<D, cons<E,
 
  105                                        cons<F, cons<G, cons<H, cons<I, cons<J,
 
  106                                        cons<K, cons<L, cons<M, cons<N, cons<O,
 
  107                                        cons<P, cons<Q, cons<R, cons<S, cons<T,
 
  108                                        cons<U, cons<V, cons<W, cons<X, cons<Y,
 
  109                                        cons<Z, NIL> > > > > > > > > > > > > > >
 
  110                                        > > > > > > > > > > >, NIL>::type type;
 
  113     template <
class A = nil, 
class B = nil, 
class C = nil, 
class D = nil,
 
  114               class E = nil, 
class F = nil, 
class G = nil, 
class H = nil,
 
  115               class I = nil, 
class J = nil, 
class K = nil, 
class L = nil,
 
  116               class M = nil, 
class N = nil, 
class O = nil, 
class P = nil,
 
  117               class Q = nil, 
class R = nil, 
class S = nil, 
class T = nil,
 
  118               class U = nil, 
class V = nil, 
class W = nil, 
class X = nil,
 
  119               class Y = nil, 
class Z = nil>
 
  122         typedef typename make_list_nil<nil, A, B, C, D, E, F, G, H, I,
 
  123                                             J, K, L, M, N, O, P, Q, R,
 
  124                                             S, T, U, V, W, X, Y, Z
 
  128     template <
class T_, 
template<
class> 
class A = nil_t,
 
  129                         template<
class> 
class B = nil_t,
 
  130                         template<
class> 
class C = nil_t,
 
  131                         template<
class> 
class D = nil_t,
 
  132                         template<
class> 
class E = nil_t,
 
  133                         template<
class> 
class F = nil_t,
 
  134                         template<
class> 
class G = nil_t,
 
  135                         template<
class> 
class H = nil_t,
 
  136                         template<
class> 
class I = nil_t,
 
  137                         template<
class> 
class J = nil_t,
 
  138                         template<
class> 
class K = nil_t,
 
  139                         template<
class> 
class L = nil_t,
 
  140                         template<
class> 
class M = nil_t,
 
  141                         template<
class> 
class N = nil_t,
 
  142                         template<
class> 
class O = nil_t,
 
  143                         template<
class> 
class P = nil_t,
 
  144                         template<
class> 
class Q = nil_t,
 
  145                         template<
class> 
class R = nil_t,
 
  146                         template<
class> 
class S = nil_t,
 
  147                         template<
class> 
class T = nil_t,
 
  148                         template<
class> 
class U = nil_t,
 
  149                         template<
class> 
class V = nil_t,
 
  150                         template<
class> 
class W = nil_t,
 
  151                         template<
class> 
class X = nil_t,
 
  152                         template<
class> 
class Y = nil_t,
 
  153                         template<
class> 
class Z = nil_t>
 
  154     struct make_list_template {
 
  155         typedef typename make_list_nil<nil_t<T_>,
 
  156                                        A<T_>, B<T_>, C<T_>, D<T_>, E<T_>,
 
  157                                        F<T_>, G<T_>, H<T_>, I<T_>, J<T_>,
 
  158                                        K<T_>, L<T_>, M<T_>, N<T_>, O<T_>,
 
  159                                        P<T_>, Q<T_>, R<T_>, S<T_>, T<T_>,
 
  160                                        U<T_>, V<T_>, W<T_>, X<T_>, Y<T_>,
 
  165     template <
template<
class, 
class> 
class BASE, 
class T_,
 
  166                                                 template<
class> 
class A = nil_t,
 
  167                                                 template<
class> 
class B = nil_t,
 
  168                                                 template<
class> 
class C = nil_t,
 
  169                                                 template<
class> 
class D = nil_t,
 
  170                                                 template<
class> 
class E = nil_t,
 
  171                                                 template<
class> 
class F = nil_t,
 
  172                                                 template<
class> 
class G = nil_t,
 
  173                                                 template<
class> 
class H = nil_t,
 
  174                                                 template<
class> 
class I = nil_t,
 
  175                                                 template<
class> 
class J = nil_t,
 
  176                                                 template<
class> 
class K = nil_t,
 
  177                                                 template<
class> 
class L = nil_t,
 
  178                                                 template<
class> 
class M = nil_t,
 
  179                                                 template<
class> 
class N = nil_t,
 
  180                                                 template<
class> 
class O = nil_t,
 
  181                                                 template<
class> 
class P = nil_t,
 
  182                                                 template<
class> 
class Q = nil_t,
 
  183                                                 template<
class> 
class R = nil_t,
 
  184                                                 template<
class> 
class S = nil_t,
 
  185                                                 template<
class> 
class T = nil_t,
 
  186                                                 template<
class> 
class U = nil_t,
 
  187                                                 template<
class> 
class V = nil_t,
 
  188                                                 template<
class> 
class W = nil_t,
 
  189                                                 template<
class> 
class X = nil_t,
 
  190                                                 template<
class> 
class Y = nil_t,
 
  191                                                 template<
class> 
class Z = nil_t>
 
  192     struct use_template_list
 
  193         : 
public BASE<T_, typename make_list_template<T_, A, B, C, D, E, F, G,
 
  196                                                           V, W, X, Y, Z>::type>
 
  201     struct has_first_rest : 
public sfinae_test<T, has_first_rest>
 
  204         has_first_rest(U*, 
typename U::first* = 0, 
typename U::rest* = 0);
 
  206     template <
bool P, 
class A>
 
  207     struct cond_cons_rest;
 
  209     struct cond_cons_rest<false, A>
 
  214     struct cond_cons_rest<true, A>
 
  216         typedef typename A::rest type;
 
  219     template <
class A> 
struct is_list
 
  221         static const bool value = is_list<
typename 
  222                       cond_cons_rest<has_first_rest<A>::value, A>::type>::value;
 
  224     template <> 
struct is_list<nil>
 
  226         static const bool value = 
true;
 
  228     template <> 
struct is_list<void*>
 
  230         static const bool value = 
false;
 
  233     template <
class A> 
struct list_guard
 
  235         typedef typename IfBool<is_list<A>::value, A, nil>::type type;
 
  238     template <
class A> 
struct size
 
  240         static const unsigned of = size<typename A::rest>::of + 1;
 
  242     template <> 
struct size<nil>
 
  244         static const unsigned of = 0;
 
  247     template <
class X, 
class L> 
struct append
 
  249         typedef cons<
typename L::first,
 
  250                      typename append<X, typename L::rest>::type> type;
 
  252     template <
class X> 
struct append<X, nil>
 
  254         typedef cons<X, nil> type;
 
  256     template <> 
struct append<nil, nil>
 
  261     template <
class L, 
class R = nil> 
struct reverse
 
  263         typedef typename reverse<
typename L::rest,
 
  264                                  cons<typename L::first, R> >::type type;
 
  266     template <
class R> 
struct reverse<nil, R>
 
  271     template <
template<
class> 
class P, 
class Q, 
class L>
 
  274         static const bool is_nil = 
false;
 
  275         static const Q first_value = P<typename L::first>::value;
 
  276         typedef max_value<P, Q, typename L::rest> rest_type;
 
  277         static const Q rest_value = rest_type::value;
 
  278         static const bool gt = first_value > rest_value || rest_type::is_nil;
 
  279         static const Q value = gt * first_value + !gt * rest_value;
 
  281     template <
template<
class> 
class P, 
class Q>
 
  282     struct max_value<P, Q, nil>
 
  284         static const Q value = 0;
 
  285         static const bool is_nil = 
true;
 
  289     template <
class X, 
class L> 
struct remove 
 
  291         typedef cons<
typename L::first,
 
  292                      typename remove<X, typename L::rest>::type> type;
 
  294     template <
class L> 
struct remove<typename L::first, L> 
 
  296         typedef typename remove<typename L::first, typename L::rest>::type type;
 
  298     template <
class X> 
struct remove<X, nil> 
 
  304     template <
template<
class> 
class P, 
class L, 
bool value = 
true>
 
  309                 value == P<typename L::first>::value, 
typename 
  310                 remove_if<P, typename L::rest, value>::type,
 
  313                     remove_if<P, typename L::rest, value>::type
 
  317     template <
template<
class> 
class P, 
bool value>
 
  318     struct remove_if<P, nil, value>
 
  323     template <
template<
class> 
class P, 
class L>
 
  326         typedef typename remove_if<P, L, false>::type type;
 
  329     template <
class X, 
class L> 
struct contains
 
  331         static const bool value = contains<X, typename L::rest>::value;
 
  333     template <
class L> 
struct contains<typename L::first, L>
 
  335         static const bool value = 
true;
 
  337     template <
class X> 
struct contains<X, nil>
 
  339         static const bool value = 
false;
 
  343     template <
class X, 
class L> 
struct merge
 
  345         typedef typename L::first first;
 
  348                     typename IfBool<contains<first, X>::value,
 
  355     template <
class X> 
struct merge<X, nil>
 
  361     template <
class L> 
struct unique
 
  363         typedef typename merge<nil, L>::type type;
 
  366     template <
class T_, 
template<
class> 
class A = nil_t,
 
  367                         template<
class> 
class B = nil_t,
 
  368                         template<
class> 
class C = nil_t,
 
  369                         template<
class> 
class D = nil_t,
 
  370                         template<
class> 
class E = nil_t,
 
  371                         template<
class> 
class F = nil_t,
 
  372                         template<
class> 
class G = nil_t,
 
  373                         template<
class> 
class H = nil_t,
 
  374                         template<
class> 
class I = nil_t,
 
  375                         template<
class> 
class J = nil_t,
 
  376                         template<
class> 
class K = nil_t,
 
  377                         template<
class> 
class L = nil_t,
 
  378                         template<
class> 
class M = nil_t,
 
  379                         template<
class> 
class N = nil_t,
 
  380                         template<
class> 
class O = nil_t,
 
  381                         template<
class> 
class P = nil_t,
 
  382                         template<
class> 
class Q = nil_t,
 
  383                         template<
class> 
class R = nil_t,
 
  384                         template<
class> 
class S = nil_t,
 
  385                         template<
class> 
class T = nil_t,
 
  386                         template<
class> 
class U = nil_t,
 
  387                         template<
class> 
class V = nil_t,
 
  388                         template<
class> 
class W = nil_t,
 
  389                         template<
class> 
class X = nil_t,
 
  390                         template<
class> 
class Y = nil_t,
 
  391                         template<
class> 
class Z = nil_t>
 
  392     struct implies_template
 
  394         typedef typename make_list_template<T_, A, B, C, D, E, F, G, H, I, J, K,
 
  395                                                 L, M, N, O, P, Q, R, S, T, U, V,
 
  396                                                 W, X, Y, Z>::type implies_types;
 
  399     template <
class T_, 
template<
class> 
class A = nil_t,
 
  400                         template<
class> 
class B = nil_t,
 
  401                         template<
class> 
class C = nil_t,
 
  402                         template<
class> 
class D = nil_t,
 
  403                         template<
class> 
class E = nil_t,
 
  404                         template<
class> 
class F = nil_t,
 
  405                         template<
class> 
class G = nil_t,
 
  406                         template<
class> 
class H = nil_t,
 
  407                         template<
class> 
class I = nil_t,
 
  408                         template<
class> 
class J = nil_t,
 
  409                         template<
class> 
class K = nil_t,
 
  410                         template<
class> 
class L = nil_t,
 
  411                         template<
class> 
class M = nil_t,
 
  412                         template<
class> 
class N = nil_t,
 
  413                         template<
class> 
class O = nil_t,
 
  414                         template<
class> 
class P = nil_t,
 
  415                         template<
class> 
class Q = nil_t,
 
  416                         template<
class> 
class R = nil_t,
 
  417                         template<
class> 
class S = nil_t,
 
  418                         template<
class> 
class T = nil_t,
 
  419                         template<
class> 
class U = nil_t,
 
  420                         template<
class> 
class V = nil_t,
 
  421                         template<
class> 
class W = nil_t,
 
  422                         template<
class> 
class X = nil_t,
 
  423                         template<
class> 
class Y = nil_t,
 
  424                         template<
class> 
class Z = nil_t>
 
  425     struct follows_template
 
  427         typedef typename make_list_template<T_, A, B, C, D, E, F, G, H, I, J, K,
 
  428                                                 L, M, N, O, P, Q, R, S, T, U, V,
 
  429                                                 W, X, Y, Z>::type follows_types;
 
  432     template <
class T_, 
template<
class> 
class A = nil_t,
 
  433                         template<
class> 
class B = nil_t,
 
  434                         template<
class> 
class C = nil_t,
 
  435                         template<
class> 
class D = nil_t,
 
  436                         template<
class> 
class E = nil_t,
 
  437                         template<
class> 
class F = nil_t,
 
  438                         template<
class> 
class G = nil_t,
 
  439                         template<
class> 
class H = nil_t,
 
  440                         template<
class> 
class I = nil_t,
 
  441                         template<
class> 
class J = nil_t,
 
  442                         template<
class> 
class K = nil_t,
 
  443                         template<
class> 
class L = nil_t,
 
  444                         template<
class> 
class M = nil_t,
 
  445                         template<
class> 
class N = nil_t,
 
  446                         template<
class> 
class O = nil_t,
 
  447                         template<
class> 
class P = nil_t,
 
  448                         template<
class> 
class Q = nil_t,
 
  449                         template<
class> 
class R = nil_t,
 
  450                         template<
class> 
class S = nil_t,
 
  451                         template<
class> 
class T = nil_t,
 
  452                         template<
class> 
class U = nil_t,
 
  453                         template<
class> 
class V = nil_t,
 
  454                         template<
class> 
class W = nil_t,
 
  455                         template<
class> 
class X = nil_t,
 
  456                         template<
class> 
class Y = nil_t,
 
  457                         template<
class> 
class Z = nil_t>
 
  458     struct depends_on_template
 
  460         typedef typename make_list_template<T_, A, B, C, D, E, F, G, H, I, J, K,
 
  461                                                 L, M, N, O, P, Q, R, S, T, U, V,
 
  462                                                 W, X, Y, Z>::type depends_on;
 
  465     template <
class T_u, 
template<
class> 
class A = nil_t,
 
  466                          template<
class> 
class B = nil_t,
 
  467                          template<
class> 
class C = nil_t,
 
  468                          template<
class> 
class D = nil_t,
 
  469                          template<
class> 
class E = nil_t,
 
  470                          template<
class> 
class F = nil_t,
 
  471                          template<
class> 
class G = nil_t,
 
  472                          template<
class> 
class H = nil_t,
 
  473                          template<
class> 
class I = nil_t,
 
  474                          template<
class> 
class J = nil_t,
 
  475                          template<
class> 
class K = nil_t,
 
  476                          template<
class> 
class L = nil_t,
 
  477                          template<
class> 
class M = nil_t,
 
  478                          template<
class> 
class N = nil_t,
 
  479                          template<
class> 
class O = nil_t,
 
  480                          template<
class> 
class P = nil_t,
 
  481                          template<
class> 
class Q = nil_t,
 
  482                          template<
class> 
class R = nil_t,
 
  483                          template<
class> 
class S = nil_t,
 
  484                          template<
class> 
class T = nil_t,
 
  485                          template<
class> 
class U = nil_t,
 
  486                          template<
class> 
class V = nil_t,
 
  487                          template<
class> 
class W = nil_t,
 
  488                          template<
class> 
class X = nil_t,
 
  489                          template<
class> 
class Y = nil_t,
 
  490                          template<
class> 
class Z = nil_t>
 
  492         : 
public implies_template<T_u, A, B, C, D, E, F, G, H, I, J, K, L, M,
 
  493                                        N, O, P, Q, R, S, T, U, V, W, X, Y, Z>,
 
  494           public depends_on_template<T_u, A, B, C, D, E, F, G, H, I, J, K, L, M,
 
  495                                        N, O, P, Q, R, S, T, U, V, W, X, Y, Z>
 
  497         template <
template<
class> 
class A_ = nil_t,
 
  498                   template<
class> 
class B_ = nil_t,
 
  499                   template<
class> 
class C_ = nil_t,
 
  500                   template<
class> 
class D_ = nil_t,
 
  501                   template<
class> 
class E_ = nil_t,
 
  502                   template<
class> 
class F_ = nil_t,
 
  503                   template<
class> 
class G_ = nil_t,
 
  504                   template<
class> 
class H_ = nil_t,
 
  505                   template<
class> 
class I_ = nil_t,
 
  506                   template<
class> 
class J_ = nil_t,
 
  507                   template<
class> 
class K_ = nil_t,
 
  508                   template<
class> 
class L_ = nil_t,
 
  509                   template<
class> 
class M_ = nil_t,
 
  510                   template<
class> 
class N_ = nil_t,
 
  511                   template<
class> 
class O_ = nil_t,
 
  512                   template<
class> 
class P_ = nil_t,
 
  513                   template<
class> 
class Q_ = nil_t,
 
  514                   template<
class> 
class R_ = nil_t,
 
  515                   template<
class> 
class S_ = nil_t,
 
  516                   template<
class> 
class T_ = nil_t,
 
  517                   template<
class> 
class U_ = nil_t,
 
  518                   template<
class> 
class V_ = nil_t,
 
  519                   template<
class> 
class W_ = nil_t,
 
  520                   template<
class> 
class X_ = nil_t,
 
  521                   template<
class> 
class Y_ = nil_t,
 
  522                   template<
class> 
class Z_ = nil_t>
 
  524             : 
public uses_template
 
  525             , 
public follows_template<T_u, A_, B_, C_, D_, E_, F_, G_, H_, I_,
 
  526                                            J_, K_, L_, M_, N_, O_, P_, Q_, R_,
 
  527                                            S_, T_, U_, V_, W_, X_, Y_, Z_> {};
 
  529         template <
template<
class> 
class A_ = nil_t,
 
  530                   template<
class> 
class B_ = nil_t,
 
  531                   template<
class> 
class C_ = nil_t,
 
  532                   template<
class> 
class D_ = nil_t,
 
  533                   template<
class> 
class E_ = nil_t,
 
  534                   template<
class> 
class F_ = nil_t,
 
  535                   template<
class> 
class G_ = nil_t,
 
  536                   template<
class> 
class H_ = nil_t,
 
  537                   template<
class> 
class I_ = nil_t,
 
  538                   template<
class> 
class J_ = nil_t,
 
  539                   template<
class> 
class K_ = nil_t,
 
  540                   template<
class> 
class L_ = nil_t,
 
  541                   template<
class> 
class M_ = nil_t,
 
  542                   template<
class> 
class N_ = nil_t,
 
  543                   template<
class> 
class O_ = nil_t,
 
  544                   template<
class> 
class P_ = nil_t,
 
  545                   template<
class> 
class Q_ = nil_t,
 
  546                   template<
class> 
class R_ = nil_t,
 
  547                   template<
class> 
class S_ = nil_t,
 
  548                   template<
class> 
class T_ = nil_t,
 
  549                   template<
class> 
class U_ = nil_t,
 
  550                   template<
class> 
class V_ = nil_t,
 
  551                   template<
class> 
class W_ = nil_t,
 
  552                   template<
class> 
class X_ = nil_t,
 
  553                   template<
class> 
class Y_ = nil_t,
 
  554                   template<
class> 
class Z_ = nil_t>
 
  556             : 
public uses_template
 
  560                     uses_template::implies_types, 
typename 
  561                     implies_template<T_u, A_, B_, C_, D_, E_, F_, G_, H_, I_,
 
  562                                           J_, K_, L_, M_, N_, O_, P_, Q_, R_,
 
  563                                           S_, T_, U_, V_, W_, X_, Y_, Z_>
 
  571     template <
template<
class> 
class EXEC, 
class L> 
struct for_exec
 
  574         static void all(TX & tx)
 
  576             EXEC<typename L::first>::exec(tx);
 
  577             for_exec<EXEC, typename L::rest>::all(tx);
 
  580     template <
template<
class> 
class EXEC> 
struct for_exec<EXEC, nil>
 
  582         template <
class TX> 
static void all(TX &) {}
 
  587     template <
class L, 
template<
class> 
class EXEC, 
class TX>
 
  588     inline void for_all(TX & tx)
 
  590         for_exec<EXEC, L>::all(tx);
 
  594     struct has_depends_on : 
public sfinae_test<T, has_depends_on>
 
  596         template <
class U> has_depends_on(U*, 
typename U::depends_on* = 0);
 
  599     struct has_implies : 
public sfinae_test<T, has_implies>
 
  601         template <
class U> has_implies(U*, 
typename U::implies_types* = 0);
 
  604     struct has_follows : 
public sfinae_test<T, has_follows>
 
  606         template <
class U> has_follows(U*, 
typename U::follows_types* = 0);
 
  610     template <
bool P, 
class T>
 
  611     struct depends_on_guard;
 
  613     struct depends_on_guard<false, T>
 
  618     struct depends_on_guard<true, T>
 
  620         typedef typename list_guard<typename T::depends_on>::type type;
 
  623     struct get_pure_depends_on
 
  625         typedef typename depends_on_guard<has_depends_on<T>::value, T>::type
 
  629     template <
bool P, 
class T>
 
  630     struct follows_guard;
 
  632     struct follows_guard<false, T>
 
  637     struct follows_guard<true, T>
 
  639         typedef typename list_guard<typename T::follows_types>::type type;
 
  644         typedef typename follows_guard<has_follows<T>::value, T>::type
 
  649     struct get_depends_on
 
  651         typedef typename merge<typename get_pure_depends_on<T>::type,
 
  652                                typename get_follows<T>::type       >::type type;
 
  655     template <
bool P, 
class T>
 
  656     struct implies_guard;
 
  658     struct implies_guard<false, T>
 
  663     struct implies_guard<true, T>
 
  665         typedef typename list_guard<typename T::implies_types>::type type;
 
  670         typedef typename implies_guard<has_implies<T>::value, T>::type
 
  674     template <
class L> 
struct implies_expand
 
  676         typedef typename L::first first;
 
  677         typedef typename L::rest  rest;
 
  681                               implies_expand<rest>::type, 
typename 
  682                               implies_expand<
typename 
  684         ::type>::type>::type> type;
 
  686     template <> 
struct implies_expand<nil>
 
  692     template <
class T, 
template<
class> 
class EXEC, 
class TX>
 
  693     inline void for_all_used(TX & tx)
 
  695         for_all<typename get_pure_depends_on<T>::type, EXEC>(tx);
 
  698     template <
class X, 
class T>
 
  699     struct contains_dependent
 
  701         static const bool value
 
  702             = contains<X, typename get_depends_on<T>::type>::value;
 
  705     template <
class X, 
class XL> 
struct is_independent_on
 
  707         static const bool value
 
  708             = ChooseBool<contains_dependent<X, typename XL::first>,
 
  710                             is_independent_on<X, typename XL::rest>
 
  713     template <
class X> 
struct is_independent_on<X, nil>
 
  715         static const bool value = 
true;
 
  718     template <
class XL, 
class YL = XL> 
struct get_independent
 
  720         typedef typename YL::first YL_first;
 
  722         IfBool<is_independent_on<YL_first, XL>::value,
 
  724                           typename get_independent<XL, typename YL::rest>::type
 
  727     template <
class XL> 
struct get_independent<XL, nil>
 
  734     template <
class L> 
struct topo_sort
 
  736         typedef typename get_independent<L>::type indep;
 
  741                       typename topo_sort<typename remove<indep, L>::type>::type
 
  745     template <> 
struct topo_sort<nil>
 
  761     template <
class L> 
struct topological_sort
 
  768         ::type>::type>::type>::type type;
 
  771     template <
class L> 
struct topological_sort_expanded
 
  774             topological_sort<
typename 
  779     template <
class V, 
unsigned pos = 0>
 
  780     class cond_val : 
public V
 
  786         cond_val() : is_set_(false) {}
 
  787         const V & val()
 const { 
return *
this; }
 
  788               V & val()       { 
return *
this; }
 
  790         template <
class TUPLE>
 
  791         bool is_set(
const TUPLE &)
 const 
  796         template <
class TUPLE>
 
  801         template <
class TUPLE>
 
  802         void set(
const V & v, TUPLE & tuple)
 
  807         friend std::ostream & operator<<(std::ostream & os, 
const cond_val & x)
 
  817     template <
class V, 
unsigned pos>
 
  818     class bit_cond_val : 
public V
 
  822         const V & val()
 const { 
return *
this; }
 
  823               V & val()       { 
return *
this; }
 
  825         template <
class TUPLE>
 
  826         bool is_set(
const TUPLE & tuple)
 const 
  828             return tuple.template is_bit_set<pos>();
 
  831         template <
class TUPLE>
 
  832         void set(TUPLE & tuple)
 
  834             tuple.template set_bit<pos>();
 
  836         template <
class TUPLE>
 
  837         void set(
const V & v, TUPLE & tuple)
 
  856     struct simple_member_dispatch
 
  858         template <
class ACX, 
class T>
 
  859         struct member_base_type
 
  861             virtual void operator()() {}
 
  862             virtual void operator()(ACX &, 
const T &) {}
 
  863             virtual void operator()(
const ACX &, 
const ACX &, 
const ACX &) {}
 
  864             virtual void call(ACX &, 
const T &, 
unsigned) {}
 
  865             virtual ~member_base_type() {}
 
  867         template <
class ACX, 
class T, 
class V>
 
  868         struct load_type : 
public member_base_type<ACX, T>, 
public V
 
  871             load_type(
const V & v) : V(v) {}
 
  876             void operator()(ACX & x, 
const T & v)
 
  880             void operator()(
const ACX & z, 
const ACX & x, 
const ACX & y)
 
  882                 V::operator()(z, x, y);
 
  884             void call(ACX & x, 
const T & v, 
unsigned n)
 
  892     template <
class ACX, 
class T,  
class Z, 
class V>
 
  895         typedef typename Z::template load_type<ACX, T, V> load_type;
 
  896         typedef load_type*                                ptr_type;
 
  902         tuple_entry() : p(0) {}
 
  903         template <
class TUPLE>
 
  904         bool is_set(
const TUPLE &)
 const { 
return p != 0; }
 
  912         void assign(
const V & v)
 
  914             ptr_type tmp = 
new load_type(v);
 
  918         void check_pointer()
 const 
  921                 vigra_fail(
"tuple_entry::operator V &: unused tuple entry " 
  922                            "type V = [" + std::string(
typeid(V).name()) + 
"], " 
  923                            "use set() to create an entry.");
 
  926         operator const V & () 
const 
  937         template <
class TUPLE> 
 
  938         void set(TUPLE & tuple)
 
  942         template <
class TUPLE>
 
  943         void set(
const V & v, TUPLE & tuple)
 
  949         tuple_entry & operator=(tuple_entry 
const & e)
 
  951             ptr_type tmp = 
new load_type(*e.p);
 
  956         tuple_entry(tuple_entry 
const & e)
 
  960                 p = 
new load_type(*e.p);
 
  966         friend std::ostream & operator<<(std::ostream & os,
 
  967                                                           const tuple_entry & x)
 
  978     template <
class ACX, 
class T, 
class Z, 
class V, 
unsigned pos>
 
  979     struct cond_tuple_entry : 
public tuple_entry<ACX, T, Z, V>
 
  981         template <
class TUPLE> 
 
  982         void set(TUPLE & tuple)
 
  985             tuple.template add<V>(this->p, pos);
 
  987         template <
class TUPLE>
 
  988         void reassign(TUPLE & tuple)
 
  991                 tuple.reassign(this->p, pos);
 
  993         template <
class TUPLE>
 
  994         void set(
const V & v, TUPLE & tuple)
 
 1003     template <
unsigned pos, 
class X>
 
 1006         typedef at_finder<pos - 1, 
typename X::rest_type> next_type;
 
 1007         typedef typename next_type::type type;
 
 1011             return next_type::at(x.rest);
 
 1015     struct at_finder<0, X>
 
 1017         typedef typename X::first_type type;
 
 1024     template <
class T, 
class X>
 
 1027         typedef typename X::rest_type rest_type;
 
 1028         typedef sub_finder<T, rest_type>
 
 1030         typedef typename next_type::type type;
 
 1031         static type & object(X & x)
 
 1033             return next_type::object(x.rest);
 
 1035         static const type & const_object(
const X & x)
 
 1037             return next_type::const_object(x.rest);
 
 1041     struct sub_finder<typename X::finder_type, X>
 
 1044         static type & object(X & x)
 
 1048         static const type & const_object(
const X & x)
 
 1054     template <
class T, 
class X>
 
 1057         typedef          sub_finder<T, X>         finder;
 
 1058         typedef typename finder::type::first_type type;
 
 1062             return finder::object(x).first;
 
 1065         const type & ref(
const X & x)
 
 1067             return finder::const_object(x).first;
 
 1074         void operator()(F & first)
 
 1079         void call(F & first)
 
 1088         binder_1(A v_) : v(v_) {}
 
 1090         void operator()(F & first)
 
 1095         void call(F & first)
 
 1100     template <
class A, 
class B>
 
 1105         binder_2(A v_, B w_) : v(v_), w(w_) {}
 
 1107         void operator()(F & first)
 
 1112         void call(F & first)
 
 1117     template <
class A, 
class B, 
class C>
 
 1123         binder_3(A v_, B w_, C x_) : v(v_), w(w_), x(x_) {}
 
 1125         void operator()(F & first)
 
 1130         void call(F & first)
 
 1132             first.call(v, w, x);
 
 1137     template <
template <
class> 
class TEST>
 
 1138     struct exec_op_plain
 
 1140         template <
class TUPLE, 
class B, 
class TBASE>
 
 1141         static void exec(TUPLE & tuple, B & binder, 
const TBASE & z)
 
 1143             binder(tuple.first);
 
 1144             tuple.rest.exec_bound_op(binder, z);
 
 1146         template <
class TUPLE, 
class B, 
class TBASE>
 
 1147         static void call(TUPLE & tuple, B & binder, 
const TBASE & z)
 
 1149             typedef typename TUPLE::ref_finder_type ref_finder_type;
 
 1150             if (TEST<ref_finder_type>::value)
 
 1151                 binder.call(static_cast<ref_finder_type &> (tuple.first));
 
 1152             tuple.rest.call_bound_op(binder, z);
 
 1157     struct plain_global_data
 
 1162     struct plain_chooser 
 
 1164         template <
class V, 
unsigned pos = 0>
 
 1170         template <
class, 
template <
class> 
class TEST>
 
 1171         struct exec_op : 
public exec_op_plain<TEST> {};
 
 1174         template <
template<
class, 
class, 
template<
class> 
class M, 
unsigned>
 
 1175                   class, 
class, 
template<
class> 
class S, unsigned>
 
 1176         struct global_data : 
public plain_global_data
 
 1178             typedef global_data global_data_type;
 
 1180         template <
class QV, 
class TUPLE>
 
 1181         static bool is_set(
const QV &, 
const TUPLE &) { 
return true; }
 
 1182         template <
class QV, 
class TUPLE>
 
 1183         static void set(QV &, TUPLE &) {}
 
 1190     struct cond_chooser_plain : 
public plain_chooser
 
 1192         template <
class V, 
unsigned pos = 0>
 
 1195             typedef cond_val<V, pos> type;
 
 1198         template <
class, 
template <
class> 
class TEST>
 
 1201             template <
class TUPLE, 
class B, 
class TBASE>
 
 1202             static void exec(TUPLE & tuple, B & binder, 
const TBASE & z)
 
 1204                 typedef typename TUPLE::ref_finder_type ref_finder_type;
 
 1205                 if (tuple.first.is_set(z))
 
 1206                     binder(static_cast<ref_finder_type &>(tuple.first));
 
 1207                 tuple.rest.exec_bound_op(binder, z);
 
 1209             template <
class TUPLE, 
class B, 
class TBASE>
 
 1210             static void call(TUPLE & tuple, B & binder, 
const TBASE & z)
 
 1212                 typedef typename TUPLE::ref_finder_type ref_finder_type;
 
 1213                 if (TEST<ref_finder_type>::value)
 
 1214                     if (tuple.first.is_set(z))
 
 1215                         binder.call(static_cast<ref_finder_type &>
 
 1217                 tuple.rest.call_bound_op(binder, z);
 
 1221         template <
class QV, 
class TUPLE>
 
 1222         static bool is_set(
const QV & qv, 
const TUPLE & t)
 
 1224             return qv.is_set(t);
 
 1226         template <
class QV, 
class TUPLE>
 
 1227         static void set(QV & qv, TUPLE & t)
 
 1235     template <class X, class T, class L = typename get_pure_depends_on<T>::type>
 
 1236     struct depends_on_deep
 
 1238         static const bool value =
 
 1239             depends_on_deep<X, T, typename L::rest>::value   
 
 1240             || depends_on_deep<X, typename L::first>::value; 
 
 1242     template <
class T, 
class L>
 
 1243     struct depends_on_deep<typename L::first, T, L>
 
 1245         static const bool value = 
true;
 
 1247     template <
class X, 
class T>
 
 1248     struct depends_on_deep<X, T, nil>
 
 1250         static const bool value = 
false;
 
 1253     template <
class T, 
class R>
 
 1254     struct first_depends_on
 
 1256         static const bool value
 
 1257             =  depends_on_deep<typename R::first, T>::value;
 
 1260     struct first_depends_on<T, nil>
 
 1262         static const bool value = 
false;
 
 1265     template <
class RRL, 
class R>
 
 1266     struct first_depends_on_all_of
 
 1268         static const bool value
 
 1270                   first_depends_on<
typename 
 1274                   first_depends_on_all_of<typename RRL::rest, R>,
 
 1279     struct first_depends_on_all_of<nil, R>
 
 1281         static const bool value = 
true;
 
 1283     template <
class RRL> 
 
 1284     struct first_depends_on_all_of<RRL, nil>
 
 1286         static const bool value = 
false;
 
 1289     struct first_depends_on_all_of<nil, nil>
 
 1291         static const bool value = 
false;
 
 1297         template <
class TUPLE, 
class B, 
class TBASE>
 
 1298         static void exec(TUPLE &, B &, 
const TBASE &) {}
 
 1299         template <
class TUPLE, 
class B, 
class TBASE>
 
 1300         static void call(TUPLE &, B &, 
const TBASE &) {}
 
 1301         typedef nil iter_leftover_type;
 
 1303     template <
bool cond, 
class EX>
 
 1306         template <
class TUPLE, 
class B, 
class TBASE>
 
 1307         static void exec(TUPLE & t, B & b, 
const TBASE & z)
 
 1309             IfBool<cond, EX, null_exec>::type::exec(t, b, z);
 
 1311         template <
class TUPLE, 
class B, 
class TBASE>
 
 1312         static void call(TUPLE & t, B & b, 
const TBASE & z)
 
 1314             IfBool<cond, EX, null_exec>::type::call(t, b, z);
 
 1317     template <
class ZL, 
template <
class> 
class TEST, 
class RRL>
 
 1318     struct cond_op_inner;
 
 1320     template <
class ZL, 
template <
class> 
class TEST, 
class RRL = nil>
 
 1323         typedef typename ZL::first             first_type;
 
 1324         typedef typename ZL::rest              rest_type;
 
 1325         typedef          cons<first_type, RRL> next_rr_list;
 
 1327         static const bool recurse_deep
 
 1328             = first_depends_on<first_type, rest_type>::value;
 
 1329         typedef cond_op<rest_type, TEST, next_rr_list>
 
 1332         typedef typename IfBool<recurse_deep, 
typename 
 1333                                 deep_type::iter_leftover_type,
 
 1338         static const bool iterate
 
 1339             = first_depends_on_all_of<RRL, deep_leftover_type>::value;
 
 1341         typedef cond_op_inner<deep_leftover_type, TEST, RRL>
 
 1347         typedef typename IfBool<iterate, 
typename 
 1348                                 iter_type::iter_leftover_type,
 
 1354         template <
class TUPLE, 
class B, 
class TBASE>
 
 1355         static void exec(TUPLE & tuple, B & binder, 
const TBASE & z)
 
 1357             if (tuple.first.is_set(z))
 
 1359                 binder(tuple.first);
 
 1360                 if_then<recurse_deep, deep_type>::exec(tuple.rest, binder, z);
 
 1362             if_then<iterate, iter_type>::exec(tuple, binder, z);
 
 1364         template <
class TUPLE, 
class B, 
class TBASE>
 
 1365         static void call(TUPLE & tuple, B & binder, 
const TBASE & z)
 
 1367             if (tuple.first.is_set(z))
 
 1369                 typedef typename TUPLE::ref_finder_type ref_finder_type;
 
 1370                 if (TEST<ref_finder_type>::value)
 
 1371                     binder.call(static_cast<ref_finder_type &> (tuple.first));
 
 1373                 if_then<recurse_deep, deep_type>::call(tuple.rest, binder, z);
 
 1375             if_then<iterate, iter_type>::call(tuple, binder, z);
 
 1378     template <
template <
class> 
class TEST, 
class RRL> 
 
 1379     struct cond_op<nil, TEST, RRL> : 
public null_exec {};
 
 1381     template <
template <
class> 
class TEST, 
class RRL> 
 
 1382     struct cond_op_inner<nil, TEST, RRL> : 
public null_exec {};
 
 1384     template <
class ZL, 
template <
class> 
class TEST, 
class RRL>
 
 1385     struct cond_op_inner
 
 1387         typedef cond_op<ZL, TEST, RRL> exec_type;
 
 1388         typedef typename exec_type::iter_leftover_type iter_leftover_type;
 
 1390         template <
class TUPLE, 
class B, 
class TBASE>
 
 1391         static void exec(TUPLE & tuple, B & binder, 
const TBASE & z)
 
 1394                 exec(sub_finder<typename ZL::first, TUPLE>::object(tuple),
 
 1398         template <
class TUPLE, 
class B, 
class TBASE>
 
 1399         static void call(TUPLE & tuple, B & binder, 
const TBASE & z)
 
 1402                 call(sub_finder<typename ZL::first, TUPLE>::object(tuple),
 
 1408     struct cond_chooser : 
public cond_chooser_plain
 
 1410         template <
class ZL, 
template <
class> 
class TEST>
 
 1411         struct exec_op : 
public cond_op<ZL, TEST> {};
 
 1414     struct bit_cond_chooser : 
public cond_chooser
 
 1416         template <
class V, 
unsigned pos>
 
 1419             typedef bit_cond_val<V, pos> type;
 
 1423         template <
template<
class, 
class, 
template<
class> 
class M, 
unsigned>
 
 1424                   class, 
class, 
template<
class> 
class S, unsigned>
 
 1425         struct global_data : 
public plain_global_data
 
 1427             typedef global_data global_data_type;
 
 1429         template <
template<
class, 
class, 
template<
class> 
class M, 
unsigned>
 
 1430                   class TBASE, class ITL, template<class> class TEST>
 
 1431         struct global_data<TBASE, ITL, TEST, 0> : 
public plain_global_data
 
 1434             typedef global_data global_data_type;
 
 1436             BitArray<size<ITL>::of> bit_set;
 
 1438             void clear() { bit_set.clear(); }
 
 1439             template <
unsigned pos>
 
 1440             void set_bit() { bit_set.template set<pos>(); }
 
 1441             template <
unsigned pos>
 
 1442             bool is_bit_set()
 const { 
return bit_set.template test<pos>(); }
 
 1446     template <
class ACX, 
class T, 
class Z>
 
 1447     struct virtual_chooser: 
public cond_chooser_plain
 
 1449         template <
class V, 
unsigned pos = 0>
 
 1452             typedef tuple_entry<ACX, T, Z, V> type;
 
 1456     template <
class T> 
struct set_exec
 
 1458         template <
class ACX>
 
 1459         static void exec(ACX & x)
 
 1461             x.template set<T>();
 
 1465     template <
class ACX, 
class T, 
class Z>
 
 1466     struct cond_virtual_chooser: 
public cond_chooser_plain
 
 1468         template <
class V, 
unsigned pos = 0>
 
 1471             typedef cond_tuple_entry<ACX, T, Z, V, pos> type;
 
 1474         template <
class, 
template <
class> 
class TEST>
 
 1477             template <
class TUPLE, 
class B, 
class TBASE>
 
 1478             static void exec(TUPLE & tuple, B & binder, 
const TBASE &)
 
 1480                 for (
unsigned i = 0; i != tuple.execs.size; ++i)
 
 1481                     binder(*tuple.execs.pointers[i]);
 
 1483             template <
class TUPLE, 
class B, 
class TBASE>
 
 1484             static void call(TUPLE & tuple, B & binder, 
const TBASE &)
 
 1486                 for (
unsigned i = 0; i != tuple.callers.size; ++i)
 
 1487                     binder.call(*tuple.callers.pointers[i]);
 
 1491         template <
template<
class, 
class, 
template<
class> 
class M, 
unsigned>
 
 1492                   class, 
class, 
template<
class> 
class S, unsigned>
 
 1493         struct global_data : 
public plain_global_data
 
 1495             typedef global_data global_data_type;
 
 1498         template <
class ITL>
 
 1499         struct global_data_pointers 
 
 1501             typedef typename Z::template member_base_type<ACX, T>* pointer_type;
 
 1502             static const unsigned array_len = size<ITL>::of;
 
 1504             unsigned     orders  [array_len]; 
 
 1506             pointer_type pointers[array_len];
 
 1512             global_data_pointers()
 
 1516             unsigned* end(
unsigned* = 0)
 
 1518                 return orders + size;
 
 1520             pointer_type* end(pointer_type*)
 
 1522                 return pointers + size;
 
 1525             void make_room(E* i)
 
 1527                 std::copy_backward(i, end(i), end(i) + 1);
 
 1529             typedef std::pair<unsigned*, pointer_type*> finder;
 
 1530             bool find(
unsigned pos, finder & found)
 
 1532                 found.first  = std::lower_bound(orders, end(), pos);
 
 1533                 found.second = pointers + (found.first - orders);
 
 1534                 return found.first != end() && *found.first == pos;
 
 1536             void add(pointer_type p, 
unsigned pos)
 
 1540                 if (find(pos, found))
 
 1542                 make_room(found.first);
 
 1543                 make_room(found.second);
 
 1548             void reassign(pointer_type p, 
unsigned pos)
 
 1553                 if (find(pos, found))
 
 1557         template <
template<
class, 
class, 
template<
class> 
class M, 
unsigned>
 
 1558                   class TBASE, class ITL, template<class> class TEST>
 
 1559         struct global_data<TBASE, ITL, TEST, 0>
 
 1562             typedef global_data global_data_type;
 
 1564             typedef TBASE<ITL, cond_virtual_chooser, TEST, 0> crtp_type;
 
 1566             typedef global_data_pointers<ITL>        ptrs_type;
 
 1567             typedef typename ptrs_type::pointer_type pointer_type;
 
 1572             void add(pointer_type p, 
unsigned pos)
 
 1576                     callers.add(p, pos);
 
 1578             void reassign(pointer_type p, 
unsigned pos)
 
 1580                 execs.  reassign(p, pos);
 
 1581                 callers.reassign(p, pos);
 
 1587                 static void exec(crtp_type & tuple)
 
 1589                     tuple.template ref<V>().reassign(tuple);
 
 1595                 for_all<ITL, reassign_op>(
static_cast<crtp_type &
>(*this));
 
 1601     template <
class ITL, 
class Q = plain_chooser,
 
 1602               template<
class> 
class TEST = true_test, 
unsigned index = 0>
 
 1604         : 
public Q::template global_data<tuple_base, ITL, TEST, index>
 
 1606         typedef typename tuple_base::global_data_type global_data_base_type;
 
 1607         typedef nil derived_type; 
 
 1608         typedef tuple_base tuple_type;
 
 1609         typedef ITL        list_type;
 
 1612         typedef typename ITL::first                            finder_type;
 
 1613         typedef typename ITL::rest                             rest_list_type;
 
 1615         typedef tuple_base<rest_list_type, Q, TEST, index + 1> rest_type;
 
 1620         typedef typename ITL::first                            ref_finder_type;
 
 1621         typedef typename Q::template use<ref_finder_type,
 
 1622                                          index>::type          first_type;
 
 1629             static const bool value = contains<T, ITL>::value;
 
 1632         template <
unsigned pos>
 
 1633         typename at_finder<pos, tuple_base>::type & at()
 
 1635             return at_finder<pos, tuple_base>::at(*
this);
 
 1641             typedef ref_finder<T, tuple_base>     finder;
 
 1642             typedef typename finder::type         ref_finder_type;
 
 1643             typedef       ref_finder_type &       type;
 
 1644             typedef const ref_finder_type & const_type;
 
 1647         typename ref_returns<T>::type
 
 1650             return ref_returns<T>::finder::ref(*
this);
 
 1653         typename ref_returns<T>::const_type
 
 1656             return ref_returns<T>::finder::ref(*
this);
 
 1662             return Q::template is_set(this->
template ref<V>(), *
this);
 
 1665         void set_if_not(RV & rv)
 
 1667             if (! Q::template is_set(rv, *
this))
 
 1668                 Q::template set(rv, *
this);
 
 1675             set_if_not(this->
template ref<V>());
 
 1676             for_all_used<V, set_exec>(*this);
 
 1680         template <
class ITL2, 
class Q2, 
template<
class> 
class TEST2>
 
 1681         void transfer_set_to(tuple_base<ITL2, Q2, TEST2> & t2)
 const 
 1683             if (is_set<ref_finder_type>())
 
 1684                 t2.template set<ref_finder_type>();
 
 1685             rest.transfer_set_to(t2);
 
 1689         template <
class B, 
class TBASE>
 
 1690         void exec_bound_op(B & binder, 
const TBASE & z)
 
 1692             Q::template exec_op<list_type, true_test>::exec(*
this, binder, z);
 
 1695         void exec_bound(B & binder)
 
 1697             exec_bound_op(binder, *
this);
 
 1707         void operator()(
const A & v)
 
 1709             binder_1<const A &> binder(v);
 
 1713         void operator()(A & v)
 
 1715             binder_1<A &> binder(v);
 
 1719         void operator()(A & v)
 const 
 1721             binder_1<A &> binder(v);
 
 1725         template <
class A, 
class B>
 
 1726         void operator()(
const A & v, 
const B & w)
 
 1728             binder_2<const A &, const B &> binder(v, w);
 
 1731         template <
class A, 
class B>
 
 1732         void operator()(A & v, 
const B & w)
 
 1734             binder_2<A &, const B &> binder(v, w);
 
 1737         template <
class A, 
class B>
 
 1738         void operator()(A & v, 
const B & w)
 const 
 1740             binder_2<A &, const B &> binder(v, w);
 
 1744         template <
class A, 
class B, 
class C>
 
 1745         void operator()(
const A & v, 
const B & w, 
const C & x)
 
 1747             binder_3<const A &, const B &, const C &> binder(v, w, x);
 
 1750         template <
class A, 
class B, 
class C>
 
 1751         void operator()(A & v, 
const B & w, 
const C & x)
 
 1753             binder_3<A &, const B &, const C &> binder(v, w, x);
 
 1756         template <
class A, 
class B, 
class C>
 
 1757         void operator()(A & v, 
const B & w, 
const C & x)
 const 
 1759             binder_3<A &, const B &, const C &> binder(v, w, x);
 
 1764         template <
class B, 
class TBASE>
 
 1765         void call_bound_op(B & binder, 
const TBASE & z)
 
 1767             Q::template exec_op<list_type, TEST>::call(*
this, binder, z);
 
 1770         void call_bound(B & binder)
 
 1772             call_bound_op(binder, *
this);
 
 1775         template <
class A, 
class B>
 
 1776         void call(
const A & v, 
const B & w)
 
 1778             binder_2<const A &, const B &> binder(v, w);
 
 1781         template <
class A, 
class B>
 
 1782         void call(A & v, 
const B & w)
 
 1784             binder_2<A &, const B &> binder(v, w);
 
 1787         template <
class A, 
class B>
 
 1788         void call(A & v, 
const B & w)
 const 
 1790             binder_2<A &, const B &> binder(v, w);
 
 1794         template <
class A, 
class B, 
class C>
 
 1795         void call(
const A & v, 
const B & w, 
const C & x)
 
 1797             binder_3<const A &, const B &, const C &> binder(v, w, x);
 
 1800         template <
class A, 
class B, 
class C>
 
 1801         void call(A & v, 
const B & w, 
const C & x)
 
 1803             binder_3<A &, const B &, const C &> binder(v, w, x);
 
 1806         template <
class A, 
class B, 
class C>
 
 1807         void call(A & v, 
const B & w, 
const C & x)
 const 
 1809             binder_3<A &, const B &, const C &> binder(v, w, x);
 
 1815         tuple_base(
const tuple_base & x)
 
 1816             : global_data_base_type(x), first(x.first), rest(x.rest)
 
 1820         tuple_base & operator=(
const tuple_base & x)
 
 1822             global_data_base_type::operator=(x);
 
 1829     template <
class Q, 
template <
class> 
class TEST, 
unsigned index>
 
 1830     struct tuple_base<nil, Q, TEST, index>
 
 1835             static const bool value = 
false;
 
 1837         template <
class B, 
class TBASE>
 
 1838         void exec_bound_op(B &, 
const TBASE &) {}
 
 1839         template <
class B, 
class TBASE>
 
 1840         void call_bound_op(B &, 
const TBASE &) {}
 
 1841         template <
class ITL2, 
class Q2, 
template<
class> 
class TEST2>
 
 1842         void transfer_set_to(tuple_base<ITL2, Q2, TEST2> &)
 const {}
 
 1845     template <
class V, 
class L, 
class A, 
class B>
 
 1848         static const bool value = contains<V, L>::value;
 
 1849         typedef typename IfBool<value, A, B>::type type;
 
 1850         static type & at(A & a, B & b)
 
 1852             return choose_type<value>::at(a, b);
 
 1854         static const type & at(
const A & a, 
const B & b)
 
 1856             return choose_type<value>::at(a, b);
 
 1859         typedef typename type::template ref_returns<V>::      type
 
 1861         typedef typename type::template ref_returns<V>::const_type
 
 1865         static ref(A & a, B & b)
 
 1867             return at(a, b).template ref<V>();
 
 1870         static ref(
const A & a, 
const B & b)
 
 1872             return at(a, b).template ref<V>();
 
 1876     template <
class ITL, 
template<
class> 
class TEST = true_test>
 
 1877     struct tuple : 
public tuple_base<ITL, plain_chooser, TEST> {};
 
 1879     template <
class ITL, 
template<
class> 
class TEST = true_test>
 
 1880     struct cond_tuple_plain
 
 1881         : 
public tuple_base<ITL, cond_chooser_plain, TEST> {};
 
 1883     template <
class ITL, 
template<
class> 
class TEST = true_test>
 
 1884     struct cond_tuple : 
public tuple_base<ITL, cond_chooser, TEST> {};
 
 1886     template <
class ITL, 
template<
class> 
class TEST = true_test>
 
 1887     struct bit_cond_tuple : 
public tuple_base<ITL, bit_cond_chooser, TEST> {};
 
 1889     template <
class ITL, 
class ACX, 
class T, 
class Z,
 
 1890               template<
class> 
class TEST = true_test>
 
 1891     struct virtual_tuple_base
 
 1892         : 
public tuple_base<ITL, virtual_chooser<ACX, T, Z>, TEST> {};
 
 1894     template <
template <
class, 
class> 
class ACXTT, 
class T,
 
 1895               class Z = simple_member_dispatch>
 
 1896     struct virtual_tuple
 
 1898         template <
class ITL, 
template<
class> 
class TEST = true_test>
 
 1900             : 
public virtual_tuple_base<ITL, ACXTT<T, ITL>, T, Z, TEST> {};
 
 1903     template <
class ITL, 
class ACX, 
class T, 
class Z,
 
 1904               template<
class> 
class TEST = true_test>
 
 1905     struct cond_virtual_tuple_base
 
 1906         : 
public tuple_base<ITL, cond_virtual_chooser<ACX, T, Z>, TEST>
 
 1908         typedef ACX derived_type;
 
 1911     template <
template <
class, 
class> 
class ACXTT, 
class T,
 
 1912               class Z = simple_member_dispatch>
 
 1913     struct cond_virtual_tuple
 
 1915         template <
class ITL, 
template<
class> 
class TEST = true_test>
 
 1917             : 
public cond_virtual_tuple_base<ITL, ACXTT<T, ITL>, T, Z, TEST> {};
 
 1923 #if defined(_MSC_VER) 
 1924 #pragma warning( pop ) 
 1929 #endif // VIGRA_TYPE_LISTS_HXX 
void add(FixedPoint< IntBits1, FracBits1 > l, FixedPoint< IntBits2, FracBits2 > r, FixedPoint< IntBits3, FracBits3 > &result)
addition with enforced result type. 
Definition: fixedpoint.hxx:561