enable_if.h

Go to the documentation of this file.

/*
  This file is part of MADNESS.

  Copyright (C) 2007,2010 Oak Ridge National Laboratory

  This program is free software; you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation; either version 2 of the License, or
  (at your option) any later version.

  This program 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 General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

  For more information please contact:

  Robert J. Harrison
  Oak Ridge National Laboratory
  One Bethel Valley Road
  P.O. Box 2008, MS-6367

  email: harrisonrj@ornl.gov
  tel:   865-241-3937
  fax:   865-572-0680


  $Id$
*/

#ifndef MADNESS_WORLD_ENABLE_IF_H__INCLUDED
#define MADNESS_WORLD_ENABLE_IF_H__INCLUDED

namespace madness {


    template <bool B, class returnT = void>
    struct enable_if_c {
        typedef returnT type;
    };

    template <class returnT>
    struct enable_if_c<false, returnT> {};


    template <class Cond, class returnT = void>
    struct enable_if : public enable_if_c<Cond::value, returnT> {};


    template <bool B, class returnT = void>
    struct disable_if_c {
        typedef returnT type;
    };

    template <class returnT>
    struct disable_if_c<true, returnT> {};

    template <class Cond, class returnT = void>
    struct disable_if : public disable_if_c<Cond::value, returnT> {};


    template <bool B, class returnT>
    struct lazy_enable_if_c {
      typedef typename returnT::type type;
    };

    template <class returnT>
    struct lazy_enable_if_c<false, returnT> { };


    template <class Cond, class returnT>
    struct lazy_enable_if : public lazy_enable_if_c<Cond::value, returnT> { };


    template <bool B, class returnT>
    struct lazy_disable_if_c {
      typedef typename returnT::type type;
    };

    template <class returnT>
    struct lazy_disable_if_c<true, returnT> {};


    template <class Cond, class returnT>
    struct lazy_disable_if : public lazy_disable_if_c<Cond::value, returnT> {};


//    template <class T, class U, class returnT = void>
//    struct enable_if_same : public enable_if<madness::is_same<T,U>, returnT> {};

        template <bool Cond, typename T1, typename T2>
        struct if_c {
            typedef T1 type;
        };
        
        template <typename T1, typename T2>
        struct if_c<false, T1, T2> {
            typedef T2 type;
        };
        
        template <typename Cond, typename T1, typename T2>
        struct if_ : public if_c<Cond::value, T1, T2> {};



} // namespace madness


/* Macros to make some of this stuff more readable */

#define ENABLE_IF(CONDITION,TYPEIFTRUE)  typename madness::enable_if< CONDITION, TYPEIFTRUE >::type
#define DISABLE_IF(CONDITION,TYPEIFTRUE) typename madness::disable_if< CONDITION, TYPEIFTRUE >::type
#define ENABLE_IF_SAME(A,B,TYPEIFTRUE) typename madness::enable_if<madness::is_same< A , B >, TYPEIFTRUE >::type
#define DISABLE_IF_SAME(A,B,TYPEIFTRUE) typename madness::disable_if<madness::is_same< A , B >, TYPEIFTRUE >::type

#endif // MADNESS_WORLD_ENABLE_IF_H__INCLUDED