adapters.hpp

//
// libsemigroups - C++ library for semigroups and monoids
// Copyright (C) 2019-2025 James D. Mitchell
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
//
 
#ifndef LIBSEMIGROUPS_ADAPTERS_HPP_
#define LIBSEMIGROUPS_ADAPTERS_HPP_
 
#include <algorithm>    // for std::sort
#include <array>        // for array
#include <cstddef>      // for size_t
#include <functional>   // for std::equal_to
#include <iterator>     // for pair
#include <memory>       // for shared_ptr
#include <type_traits>  // for hash, is_same
#include <utility>      // for pair, hash
#include <vector>       // for std::vector
 
#include "config.hpp"  // for LIBSEMIGROUPS_SIZEOF_VOID_P
 
namespace libsemigroups {

 
  // This is not technically an adapter but put here for lack of a better place
  struct Noop {
    template <typename... Args>
    constexpr void operator()(Args...) const noexcept {}
  };
 
  struct ReturnFalse {
    template <typename... Args>
    [[nodiscard]] constexpr bool operator()(Args...) const noexcept {
      return false;
    }
  };

  template <typename Element, typename = void>
  struct Complexity;

  template <typename Element, typename = void>
  struct Degree;

  template <typename Element, typename = void>
  struct IncreaseDegree;

  template <typename Element, typename = void>
  struct One;

  template <typename Element, typename = void>
  struct Product;

  template <typename Element, typename = void>
  struct Inverse;

  template <typename Element, typename Point, typename = void>
  struct ImageLeftAction;

  template <typename Element, typename Point, typename = void>
  struct ImageRightAction;

  template <typename Value, typename = void>
  struct EqualTo {
    bool operator()(Value const& x, Value const& y) const {
      return std::equal_to<Value>()(x, y);
    }
  };

  template <typename Value, typename = void>
  struct Hash {
    size_t operator()(Value const& x) const {
      return std::hash<Value>()(x);
    }
  };

  // Hash specializations

  template <typename T>
  struct Hash<std::vector<T>> {
    size_t operator()(std::vector<T> const& vec) const {
      return Hash<std::vector<T>, Hash<T>>()(vec);
    }
  };
 
  // TODO(2) same for array!

  // TODO(later) What uses this?
  template <typename T, typename Hasher>
  struct Hash<std::vector<T>, Hasher> {
    size_t operator()(std::vector<T> const& vec) const {
      size_t val = 0;
      for (T const& x : vec) {
        val ^= Hasher()(x) + 0x9e3779b97f4a7c16 + (val << 6) + (val >> 2);
      }
      return val;
    }
  };

  // TODO(later) What uses this?
  template <typename T, size_t N>
  struct Hash<std::array<T, N>> {
    size_t operator()(std::array<T, N> const& ar) const {
      size_t val = 0;
      for (T const& x : ar) {
        val ^= Hash<T>()(x) + 0x9e3779b97f4a7c16 + (val << 6) + (val >> 2);
      }
      return val;
    }
  };

  // TODO(later) What uses this?
  template <typename S, typename T>
  struct Hash<std::pair<S, T>> {
    size_t operator()(std::pair<S, T> const& x) const noexcept {
      size_t val = 0;
      val ^= Hash<S>()(x.first) + 0x9e3779b97f4a7c16 + (val << 6) + (val >> 2);
      val ^= Hash<T>()(x.second) + 0x9e3779b97f4a7c16 + (val << 6) + (val >> 2);
      return val;
    }
  };

  template <>
  struct Hash<std::pair<size_t, size_t>> {
    size_t operator()(std::pair<size_t, size_t> const& x) const noexcept {
      // TODO(2) this is a very bad hash when the values are larger than the
      // shift width
#if LIBSEMIGROUPS_SIZEOF_VOID_P == 8
      return (x.first << 32) + x.second;
#else
      return (x.first << 16) + x.second;
#endif
    }
  };

  template <typename Value, typename = void>
  struct Less {
    bool operator()(Value const& x, Value const& y) const {
      return std::less<Value>()(x, y);
    }
  };

  template <typename Value, typename = void>
  struct Swap {
    void operator()(Value& x, Value& y) {
      std::swap(x, y);
    }
  };

  template <typename Element,
            typename Point,
            typename Container = std::vector<Point>>
  struct OnTuples {
    static_assert(std::is_same<typename Container::value_type, Point>::value,
                  "the 3rd template parameter is not a container of objects of "
                  "type the 2nd template parameter");
    void operator()(Container&       res,
                    Container const& pt,
                    Element const&   x) const {
      for (size_t i = 0; i < pt.size(); ++i) {
        ImageRightAction<Element, Point>()(res[i], pt[i], x);
      }
    }
  };

  // TODO(2) add a template param for sorting
  template <typename Element,
            typename Point,
            typename Container = std::vector<Point>>
  struct OnSets {
    void operator()(Container&       res,
                    Container const& pt,
                    Element const&   p) const {
      OnTuples<Element, Point, Container>()(res, pt, p);
      std::sort(res.begin(), res.end());
    }
  };

  // KONIECZNY THINGS

  // Note: this has to exist in order to allow different lambda functions based
  // on type.
  template <typename Element, typename = void>
  struct LambdaValue;

  // Note: this has to exist in order to allow different rho functions based
  // on type.
  template <typename Element, typename = void>
  struct RhoValue;

  template <typename Element, typename Point, typename = void>
  struct Lambda;

  template <typename Element, typename Point, typename = void>
  struct Rho;
 
  // TODO(now) does this brief make sense?
  template <typename Element, typename = void>
  class RankState {
   public:
    using type = void;

    RankState() noexcept = default;

    template <typename T>
    RankState(T, T) noexcept {}
 
    // Other constructors are deleted.
    RankState(RankState const&) = default;
    RankState(RankState&&) = delete;
    RankState& operator=(RankState const&) = delete;
    RankState& operator=(RankState&&) = delete;
  };

  template <typename Element,
            typename State = RankState<Element>,
            typename       = void>
  struct Rank;
 
}  // namespace libsemigroups
#endif  // LIBSEMIGROUPS_ADAPTERS_HPP_