More C++17 transition

include/pymol/algorithm.h

@@ -27,30 +27,6 @@ template <class C, class Pred> void erase_if(C& c, Pred pred)
 #endif
 }
 
-/**
- * @brief C++17's version of std::clamp
- */
-template<typename T>
-const T& clamp(const T& value, const T& low, const T& high){
- assert(low <= high);
- return std::max(low, std::min(value, high));
-}
-
-/**
- * @brief C++14's std::equal
- */
-
-template <typename InIter1, typename InIter2>
-bool equal(InIter1 first1, InIter1 last1, InIter2 first2)
-{
- for (; first1 != last1; ++first1, ++first2) {
- if (*first1 != *first2) {
- return false;
- }
- }
- return true;
-}
-
 /**
  * @brief Checks whether two floating point values are nearly equal
  * @param first floating point number
@@ -60,7 +36,7 @@ bool equal(InIter1 first1, InIter1 last1, InIter2 first2)
  * @tparam U second floating point type
  */
 
-template <typename T, typename U, typename CommonT = pymol::common_type_t<T, U>>
+template <typename T, typename U, typename CommonT = std::common_type_t<T, U>>
 bool almost_equal(T a, U b, CommonT epsilon = 1e-6)
 {
  return std::abs(a - b) <= epsilon;
@@ -136,7 +112,7 @@ bool equal(const RangeT1& first, const RangeT2& second)
  if (range1Size != range2Size) {
  return false;
  }
- return pymol::equal(std::begin(first), std::end(first), std::begin(second));
+ return std::equal(std::begin(first), std::end(first), std::begin(second));
 }
 
 /**
@@ -164,7 +140,7 @@ bool equal(const RangeT1& first, const RangeT2& second, Pred p)
  }
  }
  return true;
- //return pymol::equal(std::begin(first), std::end(first), std::begin(second));
+ //return std::equal(std::begin(first), std::end(first), std::begin(second));
 }
 
 /**

include/pymol/memory.h

@@ -6,48 +6,6 @@
 
 namespace pymol
 {
-
-#if __cplusplus >= 201402L
-using std::make_unique;
-#else
-/**
- * @brief C++14's std::make_unique<T>
- * @param args arguments for constructor of Type T
- * @return A std::unique_ptr for type T
- */
-
-template <typename T, typename... Args>
-std::unique_ptr<T> make_unique(Args &&... args) {
- return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
-}
-
-template <typename T, typename = pymol::enable_if_t<std::is_array<T>::value>>
-std::unique_ptr<T> make_unique(std::size_t size){
- return std::unique_ptr<T>(new pymol::remove_extent_t<T>[size]());
-}
-#endif
-
-#if __cplusplus >= 201703L
-using std::destroy_at;
-using std::destroy;
-#else
-/*
- * @brief C++17's std::destroy_at
- */
-template <typename T> void destroy_at(T* p) { p->~T(); }
-
-/*
- * @brief C++17's std::destroy
- */
-
-template <typename T> void destroy(T* iter, T* end)
-{
- for(; iter != end; ++iter) {
- destroy_at(std::addressof(*iter));
- }
-}
-#endif
-
 /**
  * A copyable unique pointer. Will make a copy of the managed object with "new".
  */

include/pymol/type_traits.h

@@ -6,43 +6,16 @@
 namespace pymol
 {
 
-template<typename T>
-using decay_t = typename std::decay<T>::type;
-
-template <bool B, typename T = void>
-using enable_if_t = typename std::enable_if<B, T>::type;
-
-template <typename T>
-using remove_reference_t = typename std::remove_reference<T>::type;
-
-template <typename T>
-using remove_cv_t = typename std::remove_cv<T>::type;
-
-template <typename T>
-using remove_cvref_t = remove_cv_t<remove_reference_t<T>>;
-
-template <typename T>
-using remove_extent_t = typename std::remove_extent<T>::type;
-
-template <typename T, typename U>
-using common_type_t = typename std::common_type<T, U>::type;
-
-template <typename T>
-using result_of_t = typename std::result_of<T>::type;
-
 // Non-STL
-template <typename T, typename U>
-using forward_check_t = pymol::enable_if_t<std::is_same<pymol::remove_reference_t<T>, U>::value>;
-
 //! Casts a pointer of type T to a pointer of type T[N]
-template <size_t N, typename T> remove_reference_t<T (*)[N]> reshape(T* flat)
+template <size_t N, typename T> std::remove_reference_t<T (*)[N]> reshape(T* flat)
 {
  return reinterpret_cast<T(*)[N]>(flat);
 }
 
 //! Casts a pointer of type T[N] to a pointer of type T
-template <typename T> remove_extent_t<T>* flatten(T* shaped)
+template <typename T> std::remove_extent_t<T>* flatten(T* shaped)
 {
- return reinterpret_cast<remove_extent_t<T>*>(shaped);
+ return reinterpret_cast<std::remove_extent_t<T>*>(shaped);
 }
 }

layer0/Bezier.cpp

@@ -88,7 +88,7 @@ void BezierSpline::addBezierPoint()
 
 std::pair<int, float> BezierSpline::getIndexAndLocalT(float globalT) const
 {
- auto t = clamp(globalT, 0.0f, 1.0f);
+ auto t = std::clamp(globalT, 0.0f, 1.0f);
  if (t == 1.0f) {
  assert(bezierPoints.size() >= 2);
  return std::make_pair(static_cast<int>(bezierPoints.size() - 2), t);
@@ -108,7 +108,7 @@ glm::vec3 BezierSpline::GetBezierPoint(
 glm::vec3 BezierSpline::GetBezierPoint(const glm::vec3& p0, const glm::vec3& p1,
  const glm::vec3& p2, const glm::vec3& p3, float t)
 {
- t = clamp(t, 0.0f, 1.0f);
+ t = std::clamp(t, 0.0f, 1.0f);
  float oneMinusT = 1.0f - t;
  return oneMinusT * oneMinusT * oneMinusT * p0 +
  3.0f * oneMinusT * oneMinusT * t * p1 + 3.0f * oneMinusT * t * t * p2 +
@@ -118,7 +118,7 @@ glm::vec3 BezierSpline::GetBezierPoint(const glm::vec3& p0, const glm::vec3& p1,
 glm::vec3 BezierSpline::GetBezierFirstDerivative(const glm::vec3& p0,
  const glm::vec3& p1, const glm::vec3& p2, const glm::vec3& p3, float t)
 {
- t = clamp(t, 0.0f, 1.0f);
+ t = std::clamp(t, 0.0f, 1.0f);
  float oneMinusT = 1.0f - t;
  return 3.0f * oneMinusT * oneMinusT * (p1 - p0) +
  6.0f * oneMinusT * t * (p2 - p1) + 3.0f * t * t * (p3 - p2);

layer0/Event.h

@@ -2,7 +2,6 @@
 
 #include <functional>
 #include <vector>
-#include "pymol/functional.h"
 
 namespace pymol
 {
@@ -19,7 +18,7 @@ template <typename... ParamTs> class Event
  return;
  }
  for (const auto& callback : m_callbacks) {
- pymol::invoke(callback, params...);
+ std::invoke(callback, params...);
  }
  }
 

layer0/Map.cpp

@@ -613,9 +613,9 @@ void MapLocus(const MapType * I, const float *v, int *a, int *b, int *c)
  bt = (int) ((v[1] - I->Min[1]) * invDiv) + MapBorder;
  ct = (int) ((v[2] - I->Min[2]) * invDiv) + MapBorder;
 
- *a = pymol::clamp(at, I->iMin[0], I->iMax[0]);
- *b = pymol::clamp(bt, I->iMin[1], I->iMax[1]);
- *c = pymol::clamp(ct, I->iMin[2], I->iMax[2]);
+ *a = std::clamp(at, I->iMin[0], I->iMax[0]);
+ *b = std::clamp(bt, I->iMin[1], I->iMax[1]);
+ *c = std::clamp(ct, I->iMin[2], I->iMax[2]);
 }
 
 /**

layer0/MyPNG.cpp

@@ -497,7 +497,7 @@ std::unique_ptr<pymol::Image> MyPNGRead(const char *file_name)
  png_read_end(png_ptr, info_ptr);
  }
 
- img = pymol::make_unique<pymol::Image>(width, height);
+ img = std::make_unique<pymol::Image>(width, height);
  if(ok) {
  auto p = img->bits();
  for(row = 0; row < (signed) height; row++) {

layer0/PostProcess.cpp

@@ -58,11 +58,11 @@ const renderTarget_t::shape_type PostProcess::size(std::size_t idx) const
 OIT_PostProcess::OIT_PostProcess(int width, int height, renderBuffer_t* rbo)
 {
  if (TM3_IS_ONEBUF) {
- auto rt0 = pymol::make_unique<renderTarget_t>(width, height);
+ auto rt0 = std::make_unique<renderTarget_t>(width, height);
  rt0->layout({{4, rt_layout_t::FLOAT}}, rbo);
  m_renderTargets.push_back(std::move(rt0));
 
- auto rt1 = pymol::make_unique<renderTarget_t>(width, height);
+ auto rt1 = std::make_unique<renderTarget_t>(width, height);
  rt1->layout({{1, rt_layout_t::FLOAT}}, rt0->rbo());
  m_renderTargets.push_back(std::move(rt1));
  } else {
@@ -74,7 +74,7 @@ OIT_PostProcess::OIT_PostProcess(int width, int height, renderBuffer_t* rbo)
  layouts.emplace_back(2, rt_layout_t::FLOAT);
  }
 
- auto rt0 = pymol::make_unique<renderTarget_t>(width, height);
+ auto rt0 = std::make_unique<renderTarget_t>(width, height);
  rt0->layout(std::move(layouts), rbo);
  m_renderTargets.push_back(std::move(rt0));
  }

layer0/ShaderMgr.cpp

@@ -1742,7 +1742,7 @@ void CShaderMgr::bindOffscreenOIT(int width, int height, int drawbuf) {
  renderTarget_t::shape_type req_size(width, height);
 
  if(!oit_pp || oit_pp->size() != req_size) {
- oit_pp = pymol::make_unique<OIT_PostProcess>(
+ oit_pp = std::make_unique<OIT_PostProcess>(
  width, height, getGPUBuffer<renderTarget_t>(offscreen_rt)->_rbo);
  } else {
  if (!TM3_IS_ONEBUF) {

layer1/CGO.cpp

@@ -4103,7 +4103,7 @@ CGO *CGOOptimizeSpheresToVBONonIndexed(const CGO * I, int est, bool addshaders,
 
 CGO* CGOOptimizeBezier(const CGO* I)
 {
- auto cgo = pymol::make_unique<CGO>(I->G);
+ auto cgo = std::make_unique<CGO>(I->G);
  int num_splines = CGOCountNumberOfOperationsOfType(I, CGO_BEZIER);
  auto vbo = I->G->ShaderMgr->newGPUBuffer<VertexBuffer>();
  std::vector<float> vertData;

layer1/CGOGL.cpp

@@ -2537,7 +2537,7 @@ void CGORenderGLAlpha(CGO* I, RenderInfo* info, bool calcDepth)
  float* const pc = it.data();
  assert(base < pc && pc < I->op + I->c);
  auto i =
- pymol::clamp<int>((pc[4] - I->z_min) * range_factor, 0, i_size);
+ std::clamp<int>((pc[4] - I->z_min) * range_factor, 0, i_size);
  CGO_put_int(pc, start[i]);
  start[i] = (pc - base); /* NOTE: will always be > 0 since we have
  CGO_read_int'd */

layer1/Extrude.cpp

@@ -627,7 +627,7 @@ void ExtrudeShiftToAxis(CExtrude* I, float radius, int sampling)
  float* avg = smoothed.data() + (a - 1) * 3;
 
  for (int j = -w2; j <= w2; ++j) {
- int const k = pymol::clamp(a + j, 0, I->N - 1);
+ int const k = std::clamp(a + j, 0, I->N - 1);
  add3f(I->p + k * 3, avg, avg);
  }
 

layer1/Ortho.cpp

@@ -1319,7 +1319,7 @@ void OrthoBackgroundTextureNeedsUpdate(PyMOLGlobals * G){
 static std::unique_ptr<pymol::Image> makeBgGridImage(PyMOLGlobals* G)
 {
  auto const& grid = G->Scene->grid;
- auto tmpImg = pymol::make_unique<pymol::Image>( //
+ auto tmpImg = std::make_unique<pymol::Image>( //
  grid.n_col > 1 ? grid.n_col : 1, //
  grid.n_row > 1 ? grid.n_row : 1);
 
@@ -1343,7 +1343,7 @@ static std::unique_ptr<pymol::Image> makeBgGradientImage(PyMOLGlobals* G)
 {
  constexpr unsigned height = BACKGROUND_TEXTURE_SIZE;
 
- auto tmpImg = pymol::make_unique<pymol::Image>(1, height);
+ auto tmpImg = std::make_unique<pymol::Image>(1, height);
 
  float top[3], bottom[3], mixed[4]{0, 0, 0, 1};
  copy3f(ColorGet(G, SettingGet_color(G, cSetting_bg_rgb_top)), top);

layer1/SceneRay.cpp

@@ -336,7 +336,7 @@ bool SceneRay(PyMOLGlobals * G,
  switch (mode) {
  case 0: /* mode 0 is built-in */
  {
- auto image = pymol::make_unique<pymol::Image>(ray_width, ray_height);
+ auto image = std::make_unique<pymol::Image>(ray_width, ray_height);
  std::uint32_t background;
 
  RayRender(ray, image->pixels(), timing, angle, antialias, &background);
@@ -346,7 +346,7 @@ bool SceneRay(PyMOLGlobals * G,
  I->Image = std::move(image);
  } else {
  if(!I->Image) { /* alloc on first pass */
- I->Image = pymol::make_unique<pymol::Image>(tot_width, tot_height);
+ I->Image = std::make_unique<pymol::Image>(tot_width, tot_height);
  if(I->Image) {
  unsigned int tot_size = tot_width * tot_height;
  { /* fill with background color */

layer1/ScrollBar.cpp

@@ -48,7 +48,7 @@ void ScrollBar::update()
  m_ValueMax = static_cast<float>(m_ListSize - m_DisplaySize);
  if(m_ValueMax < 1)
  m_ValueMax = 1;
- m_Value = pymol::clamp(m_Value, 0.0f, m_ValueMax);
+ m_Value = std::clamp(m_Value, 0.0f, m_ValueMax);
 }
 
 void ScrollBar::fill(CGO* orthoCGO)

layer1/ScrollBar.h

@@ -61,7 +61,7 @@ class ScrollBar : public Block {
  bool isMaxed() const;
  void fill(CGO *orthoCGO);
  void setValueNoCheck(float _value) { m_Value = _value; }
- void setValue(float _value){ m_Value = pymol::clamp(_value, 0.0f, m_ValueMax); }
+ void setValue(float _value){ m_Value = std::clamp(_value, 0.0f, m_ValueMax); }
  void drawNoFill(CGO *orthoCGO) { drawImpl(false, orthoCGO); }
  int grabbed() { return OrthoGrabbedBy(m_G, this); }
  float getValue() const { return m_Value; }