conversion_impl.hpp

Go to the documentation of this file.

/*********************************************************************
* Software License Agreement (BSD License)
*
*  Copyright 2016-2017 Davide Faconti
*  All rights reserved.
*
*  Redistribution and use in source and binary forms, with or without
*  modification, are permitted provided that the following conditions
*  are met:
*
*   * Redistributions of source code must retain the above copyright
*     notice, this list of conditions and the following disclaimer.
*   * 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.
*   * Neither the name of Willow Garage, Inc. 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.
* *******************************************************************/

#ifndef VARIANT_IMPL_H
#define VARIANT_IMPL_H

#include <type_traits>
#include <limits>
#include <iostream>
#include "ros_type_introspection/builtin_types.hpp"
#include "ros_type_introspection/details/exceptions.hpp"

namespace RosIntrospection
{

namespace details{

template <typename T>
using Invoke = typename T::type;


template <typename BoolCondition>
using EnableIf = Invoke<std::enable_if<BoolCondition::value> >;


template <typename T>
struct is_integer : std::integral_constant<bool, std::is_integral<T>::value
        && !std::is_same<T, bool>::value
        && !std::is_same<T, char>::value>
{};

template <typename From, typename To>
struct is_same_real : std::integral_constant<bool,
    std::is_same<From, To>::value
    && std::is_floating_point<To>::value >
{};


template <typename From, typename To>
struct is_safe_integer_conversion
        : std::integral_constant<bool, is_integer<From>::value
        && is_integer<To>::value
        && sizeof(From) <= sizeof(To)
        && std::is_signed<From>::value == std::is_signed<To>::value>
{};

template <typename From, typename To>
struct float_conversion
        : std::integral_constant<bool, std::is_floating_point<From>::value
        && std::is_floating_point<To>::value 
        && !std::is_same<From,To>::value >
{};

template <typename From, typename To>
struct unsigned_to_smaller_conversion
        : std::integral_constant<bool, is_integer<From>::value
        && is_integer<To>::value
        && (sizeof(From) > sizeof(To))
        && !std::is_signed<From>::value
        && !std::is_signed<To>::value >
{};

template <typename From, typename To>
struct signed_to_smaller_conversion
        : std::integral_constant<bool, is_integer<From>::value
        && is_integer<To>::value
        && (sizeof(From) > sizeof(To))
&& std::is_signed<From>::value
&& std::is_signed<To>::value >
{};

//---------------------------
template <typename From, typename To>
struct signed_to_smaller_unsigned_conversion
        : std::integral_constant<bool, is_integer<From>::value
        && is_integer<To>::value
        && sizeof(From) >= sizeof(To)
        && std::is_signed<From>::value
        && !std::is_signed<To>::value >
{};

template <typename From, typename To>
struct signed_to_larger_unsigned_conversion
        : std::integral_constant<bool, is_integer<From>::value
        && is_integer<To>::value
        && sizeof(From) < sizeof(To)
        && std::is_signed<From>::value
        && !std::is_signed<To>::value >
{};

template <typename From, typename To>
struct unsigned_to_smaller_signed_conversion
        : std::integral_constant<bool, is_integer<From>::value
        && is_integer<To>::value
        && (sizeof(From) >= sizeof(To))
        && !std::is_signed<From>::value
        && std::is_signed<To>::value >
{};

template <typename From, typename To>
struct unsigned_to_larger_signed_conversion
        : std::integral_constant<bool, is_integer<From>::value
        && is_integer<To>::value
        && sizeof(From) < sizeof(To)
        && !std::is_signed<From>::value
        && std::is_signed<To>::value >
{};

template <typename From, typename To>
struct floating_to_signed_conversion
        : std::integral_constant<bool, std::is_floating_point<From>::value
        && is_integer<To>::value
        && std::is_signed<To>::value >
{};

template <typename From, typename To>
struct floating_to_unsigned_conversion
        : std::integral_constant<bool, std::is_floating_point<From>::value
        && is_integer<To>::value
        && !std::is_signed<To>::value >
{};

template <typename From, typename To>
struct integer_to_floating_conversion
        : std::integral_constant<bool, is_integer<From>::value
        && std::is_floating_point<To>::value >
{};

template <typename From, typename To>
inline void checkUpperLimit(const From& from)
{
    if ((sizeof(To) < sizeof(From)) &&
        (from > static_cast<From>(std::numeric_limits<To>::max()))) {
        throw RangeException("Value too large.");
    }
    else if (static_cast<To>(from) > std::numeric_limits<To>::max()) {
        throw RangeException("Value too large.");
    }
}

template <typename From, typename To>
inline void checkUpperLimitFloat(const From& from)
{
  if (from > std::numeric_limits<To>::max()){
    throw RangeException("Value too large.");
  }
}

template <typename From, typename To>
inline void checkLowerLimitFloat(const From& from)
{
    if (from < -std::numeric_limits<To>::max()){
        throw RangeException("Value too small.");
    }
}

template <typename From, typename To>
inline void checkLowerLimit(const From& from)
{
  if (from < std::numeric_limits<To>::min()){
    throw RangeException("Value too small.");
  }
}

template <typename From, typename To>
inline void checkTruncation(const From& from)
{
  if( from != static_cast<From>(static_cast<To>( from))){
    throw RangeException("Floating point truncated");
  }
}


//----------------------- Implementation ----------------------------------------------

template<typename SRC,typename DST,
         typename details::EnableIf< details::is_same_real<SRC, DST>>* = nullptr >
inline void convert_impl( const SRC& from, DST& target )
{
    target = from;
}


template<typename SRC,typename DST,
         typename details::EnableIf< details::is_safe_integer_conversion<SRC, DST>>* = nullptr >
inline void convert_impl( const SRC& from, DST& target )
{
    target = static_cast<DST>( from);
}

template<typename SRC,typename DST,
         typename details::EnableIf< details::float_conversion<SRC, DST>>* = nullptr >
inline void convert_impl( const SRC& from, DST& target )
{
    if( std::isnan(from) ){
      target = std::numeric_limits<DST>::quiet_NaN();
    }
    else if( std::isinf(from) ){
      target = std::numeric_limits<DST>::infinity();
    }
    else{
      checkTruncation<SRC,DST>(from);
      target = static_cast<DST>( from );
    }
}


template<typename SRC,typename DST,
         typename details::EnableIf< details::unsigned_to_smaller_conversion<SRC, DST>>* = nullptr  >
inline void convert_impl( const SRC& from, DST& target )
{
    //std::cout << "unsigned_to_smaller_conversion" << std::endl;

    checkUpperLimit<SRC,DST>(from);
    target = static_cast<DST>( from);
}

template<typename SRC,typename DST,
         typename details::EnableIf< details::signed_to_smaller_conversion<SRC, DST>>* = nullptr  >
inline void convert_impl( const SRC& from, DST& target )
{
    //std::cout << "signed_to_smaller_conversion" << std::endl;
    checkLowerLimit<SRC,DST>(from);
    checkUpperLimit<SRC,DST>(from);
    target = static_cast<DST>( from);
}


template<typename SRC,typename DST,
         typename details::EnableIf< details::signed_to_smaller_unsigned_conversion<SRC, DST>>* = nullptr  >
inline void convert_impl( const SRC& from, DST& target )
{
    //std::cout << "signed_to_smaller_unsigned_conversion" << std::endl;
    if (from < 0 )
        throw RangeException("Value is negative and can't be converted to signed");

    checkUpperLimit<SRC,DST>(from);

    target = static_cast<DST>( from);
}


template<typename SRC,typename DST,
         typename details::EnableIf< details::signed_to_larger_unsigned_conversion<SRC, DST>>* = nullptr   >
inline void convert_impl( const SRC& from, DST& target )
{
    //std::cout << "signed_to_larger_unsigned_conversion" << std::endl;

    if ( from < 0 )
        throw RangeException("Value is negative and can't be converted to signed");

    target = static_cast<DST>( from);
}

template<typename SRC,typename DST,
         typename details::EnableIf< details::unsigned_to_larger_signed_conversion<SRC, DST>>* = nullptr   >
inline void convert_impl( const SRC& from, DST& target )
{
    //std::cout << "unsigned_to_larger_signed_conversion" << std::endl;
    target = static_cast<DST>( from);
}

template<typename SRC,typename DST,
         typename details::EnableIf< details::unsigned_to_smaller_signed_conversion<SRC, DST>>* = nullptr   >
inline void convert_impl( const SRC& from, DST& target )
{
    checkUpperLimit<SRC,DST>(from);
    target = static_cast<DST>( from);
}

template<typename SRC,typename DST,
         typename details::EnableIf< details::floating_to_signed_conversion<SRC, DST>>* = nullptr   >
inline void convert_impl( const SRC& from, DST& target )
{
    checkLowerLimitFloat<SRC,DST>(from);
    checkLowerLimitFloat<SRC,DST>(from);

    if( from != static_cast<SRC>(static_cast<DST>( from))){
      throw RangeException("Floating point truncated");
    }

    target = static_cast<DST>( from);
}

template<typename SRC,typename DST,
         typename details::EnableIf< details::floating_to_unsigned_conversion<SRC, DST>>* = nullptr   >
inline void convert_impl( const SRC& from, DST& target )
{
    if ( from < 0 ){
      throw RangeException("Value is negative and can't be converted to signed");
    }

    checkLowerLimitFloat<SRC,DST>(from);

    if( from != static_cast<SRC>(static_cast<DST>( from)))
        throw RangeException("Floating point truncated");

    target = static_cast<DST>( from);
}

template<typename SRC,typename DST,
         typename details::EnableIf< details::integer_to_floating_conversion<SRC, DST>>* = nullptr >
inline void convert_impl( const SRC& from, DST& target )
{
    checkTruncation<SRC,DST>(from);
    target = static_cast<DST>( from);
}

} //end namespace details

} //end namespace

#endif // VARIANT_H