mlContainerHelpers.h

Go to the documentation of this file.

/*************************************************************************************
**
** Copyright 2021, MeVis Medical Solutions AG
**
** The user may use this file in accordance with the license agreement provided with
** the Software or, alternatively, in accordance with the terms contained in a
** written agreement between the user and MeVis Medical Solutions AG.
**
** For further information use the contact form at https://www.mevislab.de/contact
**
**************************************************************************************/
 
#pragma once
 
#include "mlUtilsSystem.h"
#include <algorithm>
#include <iterator>
 
ML_UTILS_START_NAMESPACE
  template <class T>
  struct Is
  {
    T d_;
    template <typename U>
    constexpr bool in(U a) {
      return a == d_;
    }
 
    template <class Arg, class... Args>
    constexpr bool in(Arg a, Args... args) {
      return in(a) || in(args...);
    }
  };
 
  template <class T>
  constexpr Is<T> is(T d) {
    return Is<T>{d};
  }
 
 
  template <class T, class R, typename I, I (T::*Count)() const, R *(T::*Access)(I) const>
  class ContainerProxy
  {
    const T* _object;
 
  public:
    using value_type = R *;
 
    explicit ContainerProxy(const T &object)
      : _object(&object)
    {
    }
 
    ContainerProxy(const ContainerProxy &) = default;
    ContainerProxy &operator=(const ContainerProxy &) = default;
    ContainerProxy(ContainerProxy &&) = default;
    ContainerProxy &operator=(ContainerProxy &&) = default;
 
    class iterator
    {
    public:
      using iterator_category = std::bidirectional_iterator_tag;
      using value_type = typename ContainerProxy::value_type;
      using difference_type = ptrdiff_t;
      using pointer = value_type;
      using const_pointer = const pointer;
      using reference = value_type;
      using const_reference = const reference;
 
      iterator(const ContainerProxy &proxy, I index)
        : _index{index}
        , _proxy{&proxy}
      {
      }
 
      iterator(const iterator &) = default;
      iterator &operator=(const iterator &) = default;
      iterator(iterator &&) = default;
      iterator &operator=(iterator &&) = default;
 
      I index() const { return _index; }
 
      reference operator*() const
      {
        return (_proxy->_object->*Access)(_index);
      }
 
      pointer operator->() const
      {
        return operator*();
      }
 
      iterator &operator++()
      {
        _index += 1;
        return *this;
      }
 
      iterator operator++(int)
      {
        iterator tmp = *this;
        ++*this;
        return tmp;
      }
 
      iterator &operator--()
      {
        _index -= 1;
        return *this;
      }
 
      iterator operator--(int)
      {
        iterator tmp = *this;
        --*this;
        return tmp;
      }
 
      friend bool operator==(const iterator &x, const iterator &y)
      {
        return x._proxy == y._proxy && x._index == y._index;
      }
 
      friend bool operator!=(const iterator &x, const iterator &y)
      {
        return !(x == y);
      }
 
 
    private:
      I _index;
      const ContainerProxy *_proxy;
    };
 
    using const_iterator = const iterator;
 
    iterator begin() const
    {
      return iterator(*this, 0);
    }
 
    iterator end() const
    {
      return iterator(*this, (_object->*Count)());
    }
 
    const_iterator cbegin() const
    {
      return begin();
    }
 
    const_iterator cend() const
    {
      return end();
    }
  };
 
/*
 * Checks if the provided second range is a rotation of the first range. Hereby it uses the predicate
 * p for comparision the values from the two ranges
 * If it is a rotation then it returns the rotation point of the second range
 * If it is not a rotation or both ranges are empty then it returns the end of the second range
 * \range1 The first range
 * \range2 The second range
 * \p The predicate that is used to compare two values
 */
  template <typename Range1, typename Range2, typename BinaryPredicate>
  constexpr typename Range2::const_iterator is_rotated(const Range1 &range1, const Range2 &range2,
                                                       BinaryPredicate p)
  {
    if (std::size(range1) != std::size(range2))
    {
      return std::end(range2);
    }
    if (std::size(range1) == 0)
    {
      return std::end(range2);
    }
    const auto itFind2 = std::find_if(std::begin(range2), std::end(range2),
                                      [p, &range1](const auto &v) { return p(*begin(range1), v); });
 
    if (itFind2 == std::end(range2))
    {
      return std::end(range2);
    }
    auto resultIts =
        std::mismatch(itFind2, std::end(range2), std::begin(range1), std::end(range1), p);
    if (resultIts.first != std::end(range2))
    {
      return std::end(range2);
    }
    resultIts = std::mismatch(std::begin(range2), itFind2, resultIts.second, std::end(range1), p);
    if (resultIts.first != itFind2)
    {
      return std::end(range2);
    }
    return itFind2;
  }
 
  /*
   * Checks if the provided second range is a rotation of the first range
   * If it is a rotation then it returns the rotation point of the second range
   * If it is not a rotation or both ranges are empty then it returns the end of the second range
   * \range1 The first range
   * \range2 The second range
   */
  template <typename Range1, typename Range2>
  constexpr typename Range2::const_iterator is_rotated(const Range1 &range1, const Range2 &range2)
  {
    if (std::size(range1) != std::size(range2))
    {
      return std::end(range2);
    }
    if (std::size(range1) == 0)
    {
      return std::end(range2);
    }
    const auto itFind2 = std::find(std::begin(range2), std::end(range2), *begin(range1));
 
    if (itFind2 == std::end(range2))
    {
      return std::end(range2);
    }
    auto resultIts = std::mismatch(itFind2, std::end(range2), std::begin(range1), std::end(range1));
    if (resultIts.first != std::end(range2))
    {
      return std::end(range2);
    }
    resultIts = std::mismatch(std::begin(range2), itFind2, resultIts.second, std::end(range1));
    if (resultIts.first != itFind2)
    {
      return std::end(range2);
    }
    return itFind2;
  }
 
 
ML_UTILS_END_NAMESPACE