cvrMetaProgrammingTools.h

Go to the documentation of this file.

/*
 * Copyright (C) 2005
 * Peter Doerfler
 *
 *
 * This file is part of the Computer Vision and Robotics Library (CVR-Lib)
 *
 * The CVR-Lib is free software; you can redistribute it and/or
 * modify it under the terms of the BSD License.
 *
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 *    this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 *    this list of conditions and the following disclaimer in the documentation
 *    and/or other materials provided with the distribution.
 *
 * 3. Neither the name of the authors nor the names of its contributors may be
 *    used to endorse or promote products derived from this software without
 *    specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */



/**
 * \file   cvrMetaProgrammingTools.h
 *         Contains some useful meta programming tools such as if_t, switch_t
 * \author Peter Doerfler
 * \date   23.09.2005
 *
 * $Id: cvrMetaProgrammingTools.h,v 1.4 2007/09/15 18:29:28 alvarado Exp $
 */

#ifndef _CVR_META_PROGRAMMING_TOOLS_H_
#define _CVR_META_PROGRAMMING_TOOLS_H_

namespace cvr {

  /**
   * Namespace containing material intended for the internal use within the
   * CVR-Lib, but is not supposed to be used outside the library.
   */
  namespace internal {

    /**
     * are_same<T, U>::value is \a true if \c T \c == \c U and \a false
     * otherwise.
     */
    template <typename T, typename U>
    struct are_same {
      enum {value = false};
    };

    template <typename T>
    struct are_same<T, T> {
      enum {value = true};
    };

    /**
     * enable_if<T, bool b>::type is T if b is true and empty otherwise
     */
    template <typename T, bool b>
    struct enable_if {
    };

    template <typename T>
    struct enable_if<T, true> {
      typedef T type;
    };


    /**
     * Defines the if_t<B,THEN,ELSE>::type as THEN if B==true and as
     * ELSE if B==false.
     *
     * The following example is not from the real world but shows the idea:
     * \code
     * struct container<bool readOnly> {
     *   typedef typename internal::if_t<readOnly, const_iterator, iterator> iterator_type;
     *   iterator_type begin();
     * \endcode
     *
     */
    template <bool B, class THEN, class ELSE = void>
    struct if_t {
      typedef THEN type;
    };

    // specialization
    template <class THEN, class ELSE>
    struct if_t<false, THEN, ELSE> {
      typedef ELSE type;
    };

    // e.g if_t<false, T>::type no definitely creates a compilation error.
//     template <class THEN>
//     struct if_t<false, THEN, void> {
//     };

    /**
     * Helper type for the cvr::internal::switch_t struct. Used as 'default'
     * when no default_t is given.
     */
    struct no_type {
      template <int>
      struct impl {
        typedef void type;
      };
    };

    /**
     * A "case" in a cvr::internal::switch_t. If the value used for switching
     * is equal to \p Y the switch_t returns \p T, otherwise it goes on with
     * the next \p CASE. Default for case is \p cvr::internal::no_type which
     * should be avoided.
     *
     * See cvr::internal::switch_t for a more detailed documentation.
     */
    template <int Y, class T, class CASE=no_type>
    struct case_t {

      template <int X>
      struct impl {
        typedef typename if_t<
          X==Y,
          T, typename CASE::template impl<X>::type
        >::type type;
      };
    };

    /**
     * Specifies the default type \p T in an cvr::internal::switch_t. See
     * there for further information.
     */
    template <class T>
    struct default_t {
      template <int>
      struct impl {
        typedef T type;
      };
    };

    /**
     * A compile time switch statement.
     *
     * It is recommended to use enum values or static const int
     * members for specifying \p X as well as the case parameters.
     *
     * The following examples clarify the syntax. They all use the
     * following setup, that defines a type foo<X>::type that is
     * dependent on the value of X:
     *
     * \code
     * enum VAL{One, Two, Three};
     * template <VAL X>
     * struct foo {
     *   typedef typename internal::switch_t<X, .....>::type type;
     * }
     * \endcode
     *
     * The most simple case is just a default type:
     * \code
     * typedef typename internal::switch_t<X,
     *   internal::default_t<int> >::type type;
     * \endcode
     *
     * Just one case could have been done using if_t as well, but like
     * this it is more easily extended. Here, if \c X == \c One then
     * \c type is \c float otherwise \c type is \c int.
     *
     * \code
     * typedef typename internal::switch_t<X,
     *   internal::case_t<One, float,
     *   internal::default_t<int> > >::type type;
     * \endcode
     *
     * Finally, and recommended, include all possible values as cases
     * in the enum and supply a default that will lead to a
     * notification of some sort. \b Note that it is considered bad style
     * not to provide a default.
     *
     * \code
     * typedef typename internal::switch_t<X,
     *   internal::case_t<One, int,
     *   internal::case_t<Two, float,
     *   internal::case_t<Three, std::complex<float>,
     *   internal::default_t<void> > > > >::type type;
     * \endcode
     */
    template <int X, class CASE>
    struct switch_t {

      typedef typename CASE::template impl<X>::type type;
    };


  } // namespace internal
} // namespace cvr

#endif