/home/amesfoort/DAL/dal/hdf5/types/isderivedfrom.h

/* Copyright 2011-2012  ASTRON, Netherlands Institute for Radio Astronomy
 * This file is part of the Data Access Library (DAL).
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either 
 * version 3 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public 
 * License along with this library.  If not, see <http://www.gnu.org/licenses/>.
 */
#ifndef DAL_ISDERIVEDFROM_H
#define DAL_ISDERIVEDFROM_H

#include "issame.h"

namespace dal {

// Excerpted from the book More Exceptional C++ by Herb Sutter.
// see http://www.gotw.ca/publications/mxc++-item-4.htm

template<typename D, typename B>
class IsDerivedFrom
{
  // 1. Create a system to allow value-checking at compile time using IsDerivedFrom<D,B>::Is

  class No { };
  class Yes { No no[3]; }; // ensure sizeof(Yes) != sizeof(No)

  static Yes Test( B* ); // not defined
  static No Test( ... ); // not defined 

public:
  // A cast to D* steers the code to Test(B*) if B is a base class of D, and to Test(...) otherwise.
  // Because sizeof only evaluates types, no actual code is generated, and thus the Test() routine
  // implementations are not necessary.
  enum { Is = sizeof(Test(static_cast<D*>(0))) == sizeof(Yes) }; 

  // 2. Force derivation if a class inherits from IsDerivedFrom.

  // Note that, like all template functions, the code below will only be evaluated
  // if it is used, allowing safe compilation of the code above.

private:
  // Compiles only if D is-a B.
  static void Constraints(D* p) {
    B* pb = p;
    (void)pb; // suppress warning about an unused variable
  }

public:
  IsDerivedFrom() { void(*p)(D*) = Constraints; (void)p; }
};

// Force it to fail in the case where B is void (unless D is void as well)

template<typename D>
class IsDerivedFrom<D, void>
{
public:
  enum { Is = IsSame<D, void>::Is };

  // Note: C++98 14.6.7 and C++11 14.6.8 say the template specialisation
  //       is ill-formed if it does not compile for any
  //       value of D. This can cause a compiler to bail
  //       even if this specialisation is never used.
  //
  //       clang is an example of such a compiler.
  IsDerivedFrom() { D* p = (void*)0; (void)p; /* error if D != void */ }
};

}

#endif