sortlist_type.h

Go to the documentation of this file.

/*
 * This file is part of OpenTTD.
 * OpenTTD 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, version 2.
 * OpenTTD 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 OpenTTD. If not, see <https://www.gnu.org/licenses/old-licenses/gpl-2.0>.
 */
 
#ifndef SORTLIST_TYPE_H
#define SORTLIST_TYPE_H
 
#include "core/enum_type.hpp"
#include "timer/timer_game_tick.h"
 
enum class SortListFlag : uint8_t {
  Desc, 
  Resort, 
  Rebuild, 
  Filter, 
};
using SortListFlags = EnumBitSet<SortListFlag, uint8_t>;
 
struct Listing {
  bool order;    
  uint8_t criteria; 
};
struct Filtering {
  bool state;    
  uint8_t criteria; 
};
 
template <typename T, typename P = std::nullptr_t, typename F = std::string_view>
class GUIList : public std::vector<T> {
public:
  using SortFunction = std::conditional_t<std::is_same_v<P, std::nullptr_t>, bool (const T&, const T&), bool (const T&, const T&, const P)>; 
  using FilterFunction = bool(const T*, F); 
 
protected:
  std::span<SortFunction * const> sort_func_list;     
  std::span<FilterFunction * const> filter_func_list; 
  SortListFlags flags;                      
  uint8_t sort_type;                          
  uint8_t filter_type;                        
  uint16_t resort_timer;                      
 
  /* If sort parameters are used then params must be a reference, however if not then params cannot be a reference as
   * it will not be able to reference anything. */
  using SortParameterReference = std::conditional_t<std::is_same_v<P, std::nullptr_t>, P, P&>;
  const SortParameterReference params;
 
  bool IsSortable() const
  {
    return std::vector<T>::size() >= 2;
  }
 
  void ResetResortTimer()
  {
    /* Resort every 10 days */
    this->resort_timer = Ticks::DAY_TICKS * 10;
  }
 
public:
  /* If sort parameters are not used then we don't require a reference to the params. */
  template <typename T_ = T, typename P_ = P, typename _F = F, std::enable_if_t<std::is_same_v<P_, std::nullptr_t>>* = nullptr>
  GUIList() :
    sort_func_list({}),
    filter_func_list({}),
    flags({}),
    sort_type(0),
    filter_type(0),
    resort_timer(1),
    params(nullptr)
  {};
 
  /* If sort parameters are used then we require a reference to the params. */
  template <typename T_ = T, typename P_ = P, typename _F = F, std::enable_if_t<!std::is_same_v<P_, std::nullptr_t>>* = nullptr>
  GUIList(const P &params) :
    sort_func_list({}),
    filter_func_list({}),
    flags({}),
    sort_type(0),
    filter_type(0),
    resort_timer(1),
    params(params)
  {};
 
  uint8_t SortType() const
  {
    return this->sort_type;
  }
 
  void SetSortType(uint8_t n_type)
  {
    assert(n_type < std::size(this->sort_func_list));
    if (this->sort_type != n_type) {
      this->flags.Set(SortListFlag::Resort);
      this->sort_type = n_type;
    }
  }
 
  Listing GetListing() const
  {
    Listing l;
    l.order = this->flags.Test(SortListFlag::Desc);
    l.criteria = this->sort_type;
 
    return l;
  }
 
  void SetListing(Listing l)
  {
    if (l.order) {
      this->flags.Set(SortListFlag::Desc);
    } else {
      this->flags.Reset(SortListFlag::Desc);
    }
    this->sort_type = l.criteria;
  }
 
  uint8_t FilterType() const
  {
    return this->filter_type;
  }
 
  void SetFilterType(uint8_t n_type)
  {
    assert(n_type < std::size(this->filter_func_list));
    if (this->filter_type != n_type) {
      this->filter_type = n_type;
    }
  }
 
  Filtering GetFiltering() const
  {
    Filtering f;
    f.state = this->flags.Test(SortListFlag::Filter);
    f.criteria = this->filter_type;
 
    return f;
  }
 
  void SetFiltering(Filtering f)
  {
    if (f.state) {
      this->flags.Set(SortListFlag::Filter);
    } else {
      this->flags.Reset(SortListFlag::Filter);
    }
    this->filter_type = f.criteria;
  }
 
  bool NeedResort()
  {
    if (--this->resort_timer == 0) {
      this->flags.Set(SortListFlag::Resort);
      this->ResetResortTimer();
      return true;
    }
    return false;
  }
 
  void ForceResort()
  {
    this->flags.Set(SortListFlag::Resort);
  }
 
  bool IsDescSortOrder() const
  {
    return this->flags.Test(SortListFlag::Desc);
  }
 
  void ToggleSortOrder()
  {
    this->flags.Flip(SortListFlag::Desc);
 
    if (this->IsSortable()) std::reverse(std::vector<T>::begin(), std::vector<T>::end());
  }
 
  template <typename Comp>
  bool Sort(Comp compare)
  {
    /* Do not sort if the resort bit is not set */
    if (!this->flags.Test(SortListFlag::Resort)) return false;
 
    this->flags.Reset(SortListFlag::Resort);
 
    this->ResetResortTimer();
 
    /* Do not sort when the list is not sortable */
    if (!this->IsSortable()) return false;
 
    const bool desc = this->flags.Test(SortListFlag::Desc);
 
    if constexpr (std::is_same_v<P, std::nullptr_t>) {
      std::sort(std::vector<T>::begin(), std::vector<T>::end(), [&](const T &a, const T &b) { return desc ? compare(b, a) : compare(a, b); });
    } else {
      std::sort(std::vector<T>::begin(), std::vector<T>::end(), [&](const T &a, const T &b) { return desc ? compare(b, a, params) : compare(a, b, params); });
    }
    return true;
  }
 
  void SetSortFuncs(std::span<SortFunction * const> n_funcs)
  {
    this->sort_func_list = n_funcs;
  }
 
  bool Sort()
  {
    if (this->sort_func_list.empty()) return false;
    assert(this->sort_type < this->sort_func_list.size());
    return this->Sort(this->sort_func_list[this->sort_type]);
  }
 
  bool IsFilterEnabled() const
  {
    return this->flags.Test(SortListFlag::Filter);
  }
 
  void SetFilterState(bool state)
  {
    if (state) {
      this->flags.Set(SortListFlag::Filter);
    } else {
      this->flags.Reset(SortListFlag::Filter);
    }
  }
 
  bool Filter(FilterFunction *decide, F filter_data)
  {
    /* Do not filter if the filter bit is not set */
    if (!this->flags.Test(SortListFlag::Filter)) return false;
 
    bool changed = false;
    for (auto it = std::vector<T>::begin(); it != std::vector<T>::end(); /* Nothing */) {
      if (!decide(&*it, filter_data)) {
        it = std::vector<T>::erase(it);
        changed = true;
      } else {
        it++;
      }
    }
 
    return changed;
  }
 
  void SetFilterFuncs(std::span<FilterFunction * const> n_funcs)
  {
    this->filter_func_list = n_funcs;
  }
 
  bool Filter(F filter_data)
  {
    if (this->filter_func_list.empty()) return false;
    assert(this->filter_type < this->filter_func_list.size());
    return this->Filter(this->filter_func_list[this->filter_type], filter_data);
  }
 
  bool NeedRebuild() const
  {
    return this->flags.Test(SortListFlag::Rebuild);
  }
 
  void ForceRebuild()
  {
    this->flags.Set(SortListFlag::Rebuild);
  }
 
  void RebuildDone()
  {
    this->flags.Reset(SortListFlag::Rebuild);
    this->flags.Set(SortListFlag::Resort);
  }
};
 
#endif /* SORTLIST_TYPE_H */