How to port for C++11/14

[Wzshun]

I want to port this awesome library for C++11/14 compiler.
It is easy to modify something like that:

    # clipper.engine.h 349
    auto* result = childs_.emplace_back(std::move(p)).get();
    => childs_.emplace_back(std::move(p));
       auto* result = childs_.back().get();

But, if constexpr not easy to modify gracefully for me.
I know there are some solution like std::enable_if or use partial template specializations, but it's not a small change...

[reunanen]

Just removing the constexpr keyword used to work. Did you try to do so?

[reunanen]

Thanks, but why it does work?

While if constexpr is evaluated at compile time, plain old if is evaluated at runtime. The plain old if obviously has been around for quite a while, and there's no reason as such why it would not work.

Yes, there may be similar-looking code around that won't compile if the constexpr keyword is removed. The keyword allows the condition to be evaluated at compile time, e.g. depending on a type. In this kind of a case, one of the branches may not compile as such, for some types, but evaluating the condition at compile time makes it so that the branch can be discarded for such types. However, if a corresponding plain old if is used, it'll be evaluated at runtime, meaning that the branch needs to be compiled.

[Wzshun]

Thanks again. If I understand correctly, old if, it is able to run in your patch because both branches can be compiled for type int or double/float. So, ScalePaths method still need use std::enable_if.

[reunanen]

If I understand correctly, old if, it is able to run in your patch because both branches can be compiled for type int or double/float.

Yes. 👍

So, ScalePaths method still need use std::enable_if.

Not sure about that. How exactly does it not work – what error are you getting? Do you have a minimal reproducible example?

[Wzshun]

Just remove the constexpr keyword, and compile it with msvc 2017 64bit.
For now, I change it like that:

template <typename T1, typename T2>
  inline std::enable_if_t<(std::numeric_limits<T1>::is_integer &&
                     !std::numeric_limits<T2>::is_integer), Paths<T1>>
    ScalePaths(const Paths<T2>& paths,
               double scale_x, double scale_y, int& error_code)
  {
     Paths<T1> result;
     RectD r = GetBounds(paths);
     if ((r.left * scale_x) < min_coord ||
       (r.right * scale_x) > max_coord ||
       (r.top * scale_y) < min_coord ||
       (r.bottom * scale_y) > max_coord)
     {
       error_code |= range_error_i;
       DoError(range_error_i);
       return result; // empty path
     }
    result.reserve(paths.size());
    std::transform(paths.begin(), paths.end(), back_inserter(result),
     [=, &error_code](const auto& path)
     { return ScalePath<T1, T2>(path, scale_x, scale_y, error_code); });
    return result;
  }

    template <typename T1, typename T2>
    inline std::enable_if_t<!(std::numeric_limits<T1>::is_integer &&
              !std::numeric_limits<T2>::is_integer), Paths<T1>>
    ScalePaths(const Paths<T2>& paths,
        double scale_x, double scale_y, int& error_code)
  {
    Paths<T1> result;
    result.reserve(paths.size());
    std::transform(paths.begin(), paths.end(), back_inserter(result),
        [=, &error_code](const auto& path)
        { return ScalePath<T1, T2>(path, scale_x, scale_y, error_code); });
    return result;
  }

[reunanen]

Sorry, I still can't reproduce your problem. For me these changes are enough to make it work, even the latest version.

Perhaps your application is calling some functionality that Clipper's examples or tests are not?

Anyway good if you got it working already.

[cuizhan-rick]

yes, and I was wondering if there is a simple solution to change codes like this:

    inline void Init(const T2 x_ = 0, const T2 y_ = 0)
    {
      if constexpr (std::numeric_limits<T>::is_integer &&
        !std::numeric_limits<T2>::is_integer)
      {
        x = static_cast<T>(std::round(x_));
        y = static_cast<T>(std::round(y_));
      }
      else
      {
        x = static_cast<T>(x_);
        y = static_cast<T>(y_);
      }
    }```

[reunanen]

Just remove the constexpr keyword?

[reunanen]

reunanen@ad32d7b

[cuizhan-rick]

Thanks, maybe it works for that situation, but how about this code:

  inline Rect<T1> ScaleRect(const Rect<T2>& rect, double scale)
  {
    Rect<T1> result;

    if constexpr (std::numeric_limits<T1>::is_integer &&
      !std::numeric_limits<T2>::is_integer)
    {
      result.left = static_cast<T1>(std::round(rect.left * scale));
      result.top = static_cast<T1>(std::round(rect.top * scale));
      result.right = static_cast<T1>(std::round(rect.right * scale));
      result.bottom = static_cast<T1>(std::round(rect.bottom * scale));
    }
    else
    {
      result.left = rect.left * scale;
      result.top = rect.top * scale;
      result.right = rect.right * scale;
      result.bottom = rect.bottom * scale;
    }
    return result;
  }

[reunanen]

reunanen@297f83f ?

[cuizhan-rick]

thanks, I'll try that!

[reunanen]

Note that each of those were already included in the changes I mentioned here.

[cuizhan-rick]

I have compiled successfully. It is done just test if the lib is working correctly. Thank you very much!