conversion traits class

From: jsiek_at_[hidden]
Date: 2000-06-23 13:57:37

Here's a suggestion for an addition to type traits (or wherever is
appropriate).

Last night I was browsing lambda library code and found this little
gem. It is a traits class that tells you whether type A is convertible
to another type B.

conversion<A,B>::exists

This is quite important for things like seeing if an iterator category
tag derives from another tag, allowing class specialization (which
can't be done with the usual function-argument based external
polymorphism trick).

The reason this shouldn't stay in the lambda library is that it is
really more generally applicable... and I'd like to see it
incorporated into boost sooner.

One thing that needs to be looked into is how portable this is.  It
has only been tested with g++ and KCC (as far as I know). I'll do
this.

Cheers,

Jeremy

// -- conversion class --
// by Andrei Alexandrescu 
// (slightly modified)

// usage, for example: conversion<A*, B*>::exists = true if A inherits B

template<class T> T dummy_create();

template <class From, class To>
class conversion
{
  typedef char (&no)[1];
  typedef char (&yes)[2];
  static no check(...);
  static yes check(To);
public:
  void foo();
#if __KCC
  static From from;
  enum { exists = sizeof( check(from) ) == sizeof(yes) };
  enum { exists_twoway = conversion<From, To>::exists && conversion<To, From>::exists };
  enum { same_type = false };
#else
  static const bool exists;
  static const bool exists_twoway;
  static const bool same_type = false;
#endif
};

#ifndef __KCC
template<class From, class To>
const bool conversion<From,To>::exists = sizeof( check(dummy_create<From>()) ) == sizeof(yes);

template<class From, class To>
const bool conversion<From,To>::exists_twoway = conversion<From, To>::exists && conversion<To, From>::exists;
#endif

template <class T>
class conversion<T, T>
{
public:
 static const bool exists = true;
 static const bool exists_twoway = true;
 static const bool same_type = true;
};

template <class From>
class conversion<From, void>
{
public:
 static const bool exists = false;
 static const bool exists_twoway = false;
 static const bool same_type = false;
};

template <class To>
class conversion<void, To>
{
public:
 static const bool exists = false;
 static const bool exists_twoway = false;
 static const bool same_type = false;
};

template <>
class conversion<void, void>
{
public:
 static const bool exists = true;
 static const bool exists_twoway = true;
 static const bool same_type = true;
};