#include <cmath>
#include <tuple>
#include <functional>
using std::less;
using std::tuple;
template <typename T>
struct AvlNode;
template <typename T>
struct AvlNodeVtl;
struct Stat { };
struct gsl_rng;
struct Aleph {
template <typename T>
using less = std::less<T>;
};
template <template <typename> class NodeType, typename Key, class Compare>
class Gen_Avl_Tree
{
};
#if 0 /* This works */
template <typename Key, class Compare = less<Key>>
struct Avl_Tree : public Gen_Avl_Tree<AvlNode, Key, Compare>
{
using Base = Gen_Avl_Tree<AvlNode, Key, Compare>;
//using Base::Base;
};
template <typename Key, class Compare = less<Key>>
struct Avl_Tree_Vtl : public Gen_Avl_Tree<AvlNodeVtl, Key, Compare>
{
using Base = Gen_Avl_Tree<AvlNodeVtl, Key, Compare>;
//using Base::Base;
};
#else /* This seems to work as well */
template <typename Key, class Compare = less<Key>>
using Avl_Tree = Gen_Avl_Tree<AvlNode, Key, Compare>;
template <typename Key, class Compare = less<Key>>
using Avl_Tree_Vtl = Gen_Avl_Tree<AvlNodeVtl, Key, Compare>;
#endif
template <
template <typename, class> class TreeType,
typename Key,
class Compare = Aleph::less<Key>
>
tuple<Stat, Stat, int, int>
sample_tree(TreeType<Key, Compare> & tree, gsl_rng * r, int n, int k)
{
return tuple<Stat,Stat,int,int>();
}
template < template <typename /* key */, class /* Compare */> class TreeType>
void test(unsigned long n, gsl_rng * r)
{
TreeType<int,int> tree;
int i = 0;
tuple<Stat, Stat, int, int> stats = sample_tree(tree, r, i, log(i)/log(2));
}
int main()
{
unsigned long n = 0;
gsl_rng *r = 0;
test<Avl_Tree>(n, r);
}
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