model.hpp

Go to the documentation of this file.

/*
 
    This file is part of Kitlist, a program to maintain a simple list
    of items and assign items to one or more categories.
 
    Copyright (C) 2008-2025 Frank Dean
 
    Kitlist 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.
 
    Kitlist 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 Kitlist.  If not, see <http://www.gnu.org/licenses/>.
 
*/
#ifndef MODEL_HPP
#define MODEL_HPP
 
#include "category.hpp"
#include "item.hpp"
#include <cstdint>
#include <iostream>
#include <map>
#include <memory>
#include <vector>

class Model {

  bool dirty;

  std::vector<std::shared_ptr<Item>> items;

  std::vector<std::shared_ptr<Category>> categories;

  std::map<int32_t, std::shared_ptr<Item>> item_map;

  std::map<int32_t, std::shared_ptr<Category>> category_map;

  int32_t max_item_id;

  int32_t max_category_id;

  int32_t selected_category;

  std::shared_ptr<Item> toggle_item_checked(const int32_t id) {
    auto item = get_item(id);
    if (item) {
      item->checked = !item->checked;
      set_dirty();
    }
    return item;
  }
 
public:

  enum state_filter {
    all,
    checked,
    unchecked
  };

  enum check_action {
    toggle,  
    check,   
    uncheck, 
  };
 
private:
  state_filter filter;
 
protected:
 
  friend class KitParser;

  void add_item(std::shared_ptr<Item> item, std::shared_ptr<Category> category = nullptr);
 
public:

  static const int32_t no_category;

  Model() : dirty(false), items(), categories(), item_map(),
  category_map(), max_item_id(0), max_category_id(0),
  selected_category(no_category), filter(all) {}

  virtual ~Model() {}

  void associate_item_with_category(int32_t item_id, std::shared_ptr<Category> category);

  std::shared_ptr<Category> set_category_name(const int32_t id,
                                              const std::string& name) {
    auto category = get_category(id);
    if (category && category->name != name) {
      category->name = name;
      set_dirty();
    }
    return category;
  }

  std::shared_ptr<Item> set_item_name(const int32_t id,
                                      const std::string& name) {
    auto item = get_item(id);
    if (item && item->name != name) {
      item->name = name;
      set_dirty();
    }
    return item;
  }

  std::shared_ptr<Item> set_item_checked(const int32_t id,
                                         const bool state) {
    auto item = get_item(id);
    if (item && item->checked != state) {
      item->checked = state;
      set_dirty();
    }
    return item;
  }

  bool save(const std::string& filename);

  void set_dirty(bool dirty = true);

  bool is_dirty() const {
    return dirty;
  }

  auto get_item_count() const {
    return items.size();
  }

  std::vector<std::shared_ptr<Item>>::size_type get_current_checked_item_count() const {
    std::vector<std::shared_ptr<Item>>::size_type c = 0;
    const auto cat_items = get_all_items_for_current_selected_category();
    for (const auto& item : cat_items)
      if (item->checked)
        c++;
    return c;
  }

  auto get_category_count() const {
    return categories.size();
  }

  int32_t new_item(const std::string& name, bool checked = false);

  void delete_category(int32_t id);

  void delete_item(int32_t id);

  void remove_items(const std::vector<std::shared_ptr<Item>>& items);

  void remove_item(int32_t id);

  int32_t new_category(const std::string& name);

  void add_category(std::shared_ptr<Category> category);

  const std::shared_ptr<Item> get_item(int32_t id) const;

  const std::shared_ptr<Category> get_category(int32_t id) const;

  std::shared_ptr<Category> get_current_category() {
    return get_category(selected_category);
  }

  const std::shared_ptr<Item> change_checked_state(int32_t id,
                                                   check_action action);

  void change_all_current_items_checked_states(check_action action);

  const std::vector<std::shared_ptr<Item>>
      get_all_items_for_current_selected_category() const;

  const std::vector<std::shared_ptr<Item>>
      filter_items_for_current_selected_category() const;

  auto count_filter_items_for_current_selected_category() const {
    return filter_items_for_current_selected_category().size();
  }

  void remove_all_current_checked_items();

  void delete_all_current_checked_items();

  void copy_items_to_categories(
      std::vector<std::shared_ptr<Item>>& items,
      std::vector<std::shared_ptr<Category>>& categories);

  void copy_checked_items_to_categories(std::vector<int32_t> cids);

  void copy_item_to_categories(int32_t item_id, std::vector<int32_t> cids);

  void select_category(int32_t id) {
    selected_category = id;
  }

  int32_t get_selected_category() const {
    return selected_category;
  }

  const std::vector<std::shared_ptr<Category>> get_categories() const {
    return categories;
  }

  const std::vector<std::shared_ptr<Item>> get_all_items() const {
    return items;
  }

  void set_filter(state_filter state) {
    filter = state;
  }

  state_filter get_filter() const {
    return filter;
  }

  void sort_items();

  void sort_categories();

  void sort_category_items();

  void sort_item_categories();

  void sort();

  void show_model() const;

  void validate() const;

  void renumber_items();

  void renumber_categories();

  void renumber();
 
};
 
#endif // MODEL_HPP