JUnity.hh

Go to the documentation of this file.

#ifndef __JMATH__JUNITY__
#define __JMATH__JUNITY__
 
#include <type_traits>
 
 
/**
 * \file
 *
 * Definition of unity value for any class.
 * \author bjung
 */
namespace JMATH {}
namespace JPP { using namespace JMATH; }
 
namespace JMATH {
 
  /**
   * Auxiliary class for obtaining unity values of a given data type.
   */
  template<class T, bool = std::is_integral<T>::value>
  struct JUnityHelper
  {
    /**
     * Get unity value.
     *
     * The default implementation of this method returns an object which 
     * is created with the default constructor.
     * This class should be specialised if this value does not correspond
     * to the equivalent of a unity result.
     *
     * \return                   unity
     */
    inline static T getUnity() 
    {
      return T();
    }
  };
 
 
  /**
   * Partial template specialisation for integral types.
   */
  template<class T>
  struct JUnityHelper<T, true>
  {
    /**
     * Get unity value.
     *
     * \return                   unity
     */    
    inline static T getUnity()
    {
      return T(1);
    }
  };
 
 
  /**
   * Get unity value for a given data type.
   *
   * The default implementation of this method returns an object which 
   * is created with the default constructor.
   * This method should be specialised if this value does not correspond
   * to the equivalent of a unity result.
   *
   * \return                     unity
   */
  template<class T>
  inline T getUnity() {
    return JUnityHelper<T>::getUnity();
  }
  
 
  /**
   * Get unity value for <tt>bool</tt>.
   *
   * \return                     false
   */
  template<> inline bool getUnity<bool>()
  {
    return true;
  }  
 
 
  /**
   * Get unity value for <tt>float</tt>.
   *
   * \return                     unity
   */
  template<> inline float getUnity<float>()
  { 
    return float(1.0);
  }
 
 
  /**
   * Get unity value for <tt>double</tt>.
   *
   * \return                     unity
   */
  template<>
  inline double getUnity<double>() 
  {
    return double(1.0);
  }
 
 
  /**
   * Get unity value for <tt>long double</tt>.
   *
   * \return                     unity
   */
  template<>
  inline long double getUnity<long double>() 
  {
    return (long double)(1.0);
  }
 
 
  /**
   * Auxiliary class to assign unity value.
   */
  struct JUnity {
    /** 
     * Default constructor.
     */
    JUnity()
    {}
 
 
    /**
     * Type conversion operator.
     *
     * \return                     unity
     */
    template<class T>
    operator T() const
    {
      return getUnity<T>();
    }
  };
 
 
  /**
   * Function object to assign unity value.
   */
  static const JUnity unity;
}
 
#endif