typeTraits.hpp

Go to the documentation of this file.

/** \file typeTraits.hpp
  * \brief A collection of type trait evaluations.
  * \ingroup utils_files
  * \author Jared R. Males (jaredmales@gmail.com)
  *
  */
 
//***********************************************************************//
// Copyright 2015, 2016, 2017, 2018 Jared R. Males (jaredmales@gmail.com)
//
// This file is part of mxlib.
//
// mxlib 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 3 of the License, or
// (at your option) any later version.
//
// mxlib 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 mxlib.  If not, see <http://www.gnu.org/licenses/>.
//***********************************************************************//
 
#ifndef typeTraits_hpp
#define typeTraits_hpp
 
namespace mx
{
 
namespace meta
{
   
template <typename... Ts> using void_t = void;
 
template <typename T, typename = void>
struct has_value_type : trueFalseT<false> {};
 
///Test whether a type has a typedef of "value_type"
/** Used for compile-time determination of type.
  * 
  * Example usage:
  * \code
  * bool has_vt = has_value_type<std::vector<float> >; //Evaluates to true
  * bool has_not_vt = has_value_type<float>; //Evaluates to false
  * \endcode
  * 
  * This was taken directly from the example at http://en.wikipedia.org/wiki/Substitution_failure_is_not_an_error
  * 
  * \ingroup meta
  */
template <typename T>
struct has_value_type<T, void_t<typename T::value_type>> : trueFalseT<true> {};
 
 
 
///Check whether a type is std::vector or not.
/** First resolves whether the type as a typedef value_type.  If not, then member value will be false.
  * If it does have a member type value_type, then it uses std::is_same to compare the type to std::vector. 
  * Then value is equal to std::is_same<T, std::vector<typenameT::value_type>>::value.
  * 
  * \tparam T is the type to evaulate for vector-ness.
  * \tparam has_value_type is a boolean type based on has_value_type SFINAE test.
  * 
  * \ingroup meta
  */ 
template <typename T, bool if_value_type = has_value_type<T>::value >
struct is_std_vector; 
 
///Partial specialization for the case with value_type member type in T, invoking std::is_same.
/** \ingroup meta
  */
template <typename T>
struct is_std_vector<T, true> 
{
   static const bool value = std::is_same< T, std::vector< typename T::value_type> >::value;
};
 
///Partial specialization for the case with no value_type member type in T.
/** \ingroup meta
  */
template <typename T>
struct is_std_vector<T,false> 
{
   static const bool value = false;
};
 
} //namespace meta
} //namespace mx
 
 
#endif //typeTraits_hpp