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 <http://www.gnu.org/licenses/>.
 */

#ifndef SORTLIST_TYPE_H
#define SORTLIST_TYPE_H

#include "core/enum_type.hpp"
#include "core/bitmath_func.hpp"
#include "core/smallvec_type.hpp"
#include "date_type.h"

enum SortListFlags {
  VL_NONE       = 0,      
  VL_DESC       = 1 << 0, 
  VL_RESORT     = 1 << 1, 
  VL_REBUILD    = 1 << 2, 
  VL_FIRST_SORT = 1 << 3, 
  VL_FILTER     = 1 << 4, 
  VL_END        = 1 << 5,
};
DECLARE_ENUM_AS_BIT_SET(SortListFlags)


struct Listing {
  bool order;    
  byte criteria; 
};
struct Filtering {
  bool state;    
  byte criteria; 
};

template <typename T, typename F = const char*>
class GUIList : public std::vector<T> {
public:
  typedef bool SortFunction(const T&, const T&);  
  typedef bool CDECL FilterFunction(const T*, F); 

protected:
  SortFunction * const *sort_func_list;     
  FilterFunction * const *filter_func_list; 
  SortListFlags flags;                      
  uint8 sort_type;                          
  uint8 filter_type;                        
  uint16 resort_timer;                      

  bool IsSortable() const
  {
    return std::vector<T>::size() >= 2;
  }

  void ResetResortTimer()
  {
    /* Resort every 10 days */
    this->resort_timer = DAY_TICKS * 10;
  }

public:
  GUIList() :
    sort_func_list(nullptr),
    filter_func_list(nullptr),
    flags(VL_FIRST_SORT),
    sort_type(0),
    filter_type(0),
    resort_timer(1)
  {};

  uint8 SortType() const
  {
    return this->sort_type;
  }

  void SetSortType(uint8 n_type)
  {
    if (this->sort_type != n_type) {
      SETBITS(this->flags, VL_RESORT | VL_FIRST_SORT);
      this->sort_type = n_type;
    }
  }

  Listing GetListing() const
  {
    Listing l;
    l.order = (this->flags & VL_DESC) != 0;
    l.criteria = this->sort_type;

    return l;
  }

  void SetListing(Listing l)
  {
    if (l.order) {
      SETBITS(this->flags, VL_DESC);
    } else {
      CLRBITS(this->flags, VL_DESC);
    }
    this->sort_type = l.criteria;

    SETBITS(this->flags, VL_FIRST_SORT);
  }

  uint8 FilterType() const
  {
    return this->filter_type;
  }

  void SetFilterType(uint8 n_type)
  {
    if (this->filter_type != n_type) {
      this->filter_type = n_type;
    }
  }

  Filtering GetFiltering() const
  {
    Filtering f;
    f.state = (this->flags & VL_FILTER) != 0;
    f.criteria = this->filter_type;

    return f;
  }

  void SetFiltering(Filtering f)
  {
    if (f.state) {
      SETBITS(this->flags, VL_FILTER);
    } else {
      CLRBITS(this->flags, VL_FILTER);
    }
    this->filter_type = f.criteria;
  }

  bool NeedResort()
  {
    if (--this->resort_timer == 0) {
      SETBITS(this->flags, VL_RESORT);
      this->ResetResortTimer();
      return true;
    }
    return false;
  }

  void ForceResort()
  {
    SETBITS(this->flags, VL_RESORT);
  }

  bool IsDescSortOrder() const
  {
    return (this->flags & VL_DESC) != 0;
  }

  void ToggleSortOrder()
  {
    this->flags ^= VL_DESC;

    if (this->IsSortable()) MemReverseT(std::vector<T>::data(), std::vector<T>::size());
  }

  template <typename Comp>
  bool Sort(Comp compare)
  {
    /* Do not sort if the resort bit is not set */
    if (!(this->flags & VL_RESORT)) return false;

    CLRBITS(this->flags, VL_RESORT);

    this->ResetResortTimer();

    /* Do not sort when the list is not sortable */
    if (!this->IsSortable()) return false;

    const bool desc = (this->flags & VL_DESC) != 0;

    if (this->flags & VL_FIRST_SORT) {
      CLRBITS(this->flags, VL_FIRST_SORT);

      std::sort(std::vector<T>::begin(), std::vector<T>::end(), [&](const T &a, const T &b) { return desc ? compare(b, a) : compare(a, b); });
      return true;
    }

    std::sort(std::vector<T>::begin(), std::vector<T>::end(), [&](const T &a, const T &b) { return desc ? compare(b, a) : compare(a, b); });
    return true;
  }

  void SetSortFuncs(SortFunction * const *n_funcs)
  {
    this->sort_func_list = n_funcs;
  }

  bool Sort()
  {
    assert(this->sort_func_list != nullptr);
    return this->Sort(this->sort_func_list[this->sort_type]);
  }

  bool IsFilterEnabled() const
  {
    return (this->flags & VL_FILTER) != 0;
  }

  void SetFilterState(bool state)
  {
    if (state) {
      SETBITS(this->flags, VL_FILTER);
    } else {
      CLRBITS(this->flags, VL_FILTER);
    }
  }

  bool Filter(FilterFunction *decide, F filter_data)
  {
    /* Do not filter if the filter bit is not set */
    if (!(this->flags & VL_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(FilterFunction * const *n_funcs)
  {
    this->filter_func_list = n_funcs;
  }

  bool Filter(F filter_data)
  {
    if (this->filter_func_list == nullptr) return false;
    return this->Filter(this->filter_func_list[this->filter_type], filter_data);
  }

  bool NeedRebuild() const
  {
    return (this->flags & VL_REBUILD) != 0;
  }

  void ForceRebuild()
  {
    SETBITS(this->flags, VL_REBUILD);
  }

  void RebuildDone()
  {
    CLRBITS(this->flags, VL_REBUILD);
    SETBITS(this->flags, VL_RESORT | VL_FIRST_SORT);
  }
};

#endif /* SORTLIST_TYPE_H */