source: lemon-0.x/src/work/deba/test.cpp @ 1210:f02396423239

#include <iostream>

using namespace std;

#include <lemon/utility.h>

using namespace std;
/*
struct _EmptyList {
  void write() const {}
};

template <typename _Item, typename _Next>
struct _AddNode {
  typedef _Next Next;
  typedef _Item Item;
  
  const Item item;
  const Next& next;
  
  _AddNode(const Item& _item, const Next& _next) 
    : item(_item), next(_next) {}

  void write() const {
    next.write();
    cout << item << ' ';
  }
};

template <typename _List = _EmptyList>
struct _Writer {
  typedef _List List;

  const List list;

  _Writer(const List& _list = List()) : list(_list) {}

  
  template <typename Item> _Writer<_AddNode<Item, List> > add(Item item) const {
    return _Writer<_AddNode<Item, List> >(_AddNode<Item, List>(item, list));
  }

  void write() const {
    list.write();
    cout << endl;
  }
};


typedef _Writer<> Writer;

int main() {
  Writer().add(3).add("alpha").add(4.53).write();
}
*/

class A {
public:
  typedef int X;
};

class C {
};

template <typename A> 
class TRUE {
public:
  static const bool state = true;
};

template <typename _A> 
class B {
public:
  typedef enable_if<A::X, int> state;
};

template <typename _A>
class B<_A, void> {
public:
  static const bool state = true;
};

int main() {
  printf("%s\n", B<A>::state(), true ? "true" : "false");
  printf("%s\n", B<C>::state(), true ? "true" : "false");
  return 0;
}