model.cpp

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/>.
 
*/
#include "model.hpp"
#include "kitlist_base_app.hpp"
#include "xml_writer.hpp"
#include <algorithm>
#include <cassert>
#include <cstdint>
#include <iostream>
#include <vector>
 
const int32_t Model::no_category = -1;
using namespace std;
 
void Model::set_dirty(bool dirty)
{
  if (this->dirty != dirty)
    this->dirty = dirty;
}
 
void Model::add_item(std::shared_ptr<Item> i, std::shared_ptr<Category> c)
{
  assert((item_map.find(i->id) == item_map.end() && "Item already exists in model"));
  max_item_id = max(max_item_id, i->id);
  items.push_back(i);
  item_map.insert(make_pair(i->id, i));
  if (c) {
    assert(i->category_map.find(c->id) == i->category_map.end());
    assert(c->item_map.find(i->id) == c->item_map.end());
    max_category_id = max(max_category_id, c->id);
    i->categories.push_back(c);
    i->category_map.insert(make_pair(c->id, c));
    c->items.push_back(i);
    c->item_map.insert(make_pair(i->id, i));
    assert(c->items.size() == c->item_map.size());
    assert(i->categories.size() == i->category_map.size());
  }
  set_dirty();
  assert(items.size() == item_map.size());
  assert(categories.size() == category_map.size());
}
 
void Model::associate_item_with_category(int32_t item_id,
                                         std::shared_ptr<Category> c)
{
  auto item_iter = item_map.find(item_id);
  #ifndef NDEBUG
  if (item_iter == item_map.end())
    cerr << "Item " << item_id << " not found in item list" << endl;
  #endif
  assert(item_iter != item_map.end());
  if (item_iter != item_map.end()) {
    assert(category_map.find(c->id) != category_map.end());
    auto cat_item_iter = c->item_map.find(item_id);
    #ifndef NDEBUG
    if (cat_item_iter != c->item_map.end())
      cerr << "Item " << item_id << ", \"" << cat_item_iter->second->name
           << "\" already belongs to category "
           << c->id << ", \"" << c->name << '"' << endl;
    #endif
    assert(cat_item_iter == c->item_map.end());
    if (cat_item_iter == c->item_map.end()) {
      shared_ptr<Item> item = item_iter->second;
      assert(item->category_map.find(c->id) == item->category_map.end());
      max_category_id = max(max_category_id, c->id);
      c->items.push_back(item);
      c->item_map.insert(make_pair(item_iter->first, item));
      item->categories.push_back(c);
      item->category_map.insert(make_pair(c->id, c));
    }
  }
  set_dirty();
  validate();
}
 
bool Model::save(const std::string& filename)
{
  XmlWriter w;
  bool success = w.save_file(filename, *this);
  if (success)
    set_dirty(false);
  return success;
}
 
int32_t Model::new_item(const std::string& name, bool checked)
{
  shared_ptr<Item> i(new Item(++max_item_id, name, checked));
  items.push_back(i);
  item_map.insert(std::make_pair(i->id, i));
  if (selected_category >= 0) {
    auto c = get_category(selected_category);
    if (c) {
      i->categories.push_back(c);
      i->category_map.insert(make_pair(c->id, c));
      c->items.push_back(i);
      c->item_map.insert(make_pair(i->id, i));
      c->sort_items();
    }
    sort_categories();
  }
  set_dirty();
  sort_items();
  return i->id;
}
 
void Model::delete_category(int32_t id)
{
  auto map_iter = category_map.find(id);
  if (map_iter == category_map.end())
    return;
  shared_ptr<Category> category = map_iter->second;
  for (auto& item : category->items) {
    item->categories.erase(
        remove_if(
            item->categories.begin(), item->categories.end(),
            [=](const auto& c) {
              return (!c.expired() && c.lock()->id == id);
            }),
        item->categories.end());
  }
  erase(categories, category);
  category_map.erase(id);
  if (id == selected_category)
    select_category(no_category);
  set_dirty();
  validate();
}
 
void Model::delete_item(int32_t id)
{
  for (const auto& c : categories) {
    c->items.erase(remove_if(c->items.begin(), c->items.end(),
                             [=](const auto& n) { return (n->id == id); }),
                   c->items.end());
    c->item_map.erase(id);
  }
  items.erase(remove_if(items.begin(), items.end(),
                        [=](const auto& n) { return (n->id == id); }),
              items.end());
  item_map.erase(id);
  set_dirty();
  validate();
}
 
void Model::remove_items(const vector<shared_ptr<Item>>& items)
{
  const auto pos = category_map.find(selected_category);
  if (pos == category_map.end())
    return;
 
  auto category = pos->second;
  for (const auto& item : items) {
    erase_if(item->categories,
             [=] (const auto& cat) { return cat.expired() || cat.lock()->id == category->id; });
    item->category_map.erase(category->id);
    category->item_map.erase(item->id);
    erase_if(category->items,
             [=] (const auto& i) { return item->id == i->id; });
  }
  set_dirty();
  validate();
}
 
void Model::remove_item(int32_t id)
{
  assert(selected_category >= 0);
  auto c = get_category(selected_category);
  c->items.erase(remove_if(c->items.begin(), c->items.end(),
                           [=](const auto& item) { return item->id == id; }),
                 c->items.end());
  c->item_map.erase(id);
  set_dirty();
  validate();
}
 
int32_t Model::new_category(const std::string& name)
{
  shared_ptr<Category> c(new Category(++max_category_id, name));
  categories.push_back(c);
  category_map.insert(make_pair(c->id, c));
  sort_categories();
  select_category(c->id);
  set_dirty();
  sort_categories();
  return c->id;
}
 
void Model::add_category(std::shared_ptr<Category> c)
{
  assert((category_map.find(c->id) == category_map.end() && "Category already exists in model"));
  max_category_id = max(max_category_id, c->id);
  category_map.insert(make_pair(c->id, c));
  categories.push_back(c);
  assert(categories.size() == category_map.size());
  set_dirty();
  validate();
}
 
const std::shared_ptr<Item> Model::get_item(int32_t id) const
{
  auto i = item_map.find(id);
  if (i != item_map.end())
    return i->second;
  return nullptr;
}
 
const std::shared_ptr<Category> Model::get_category(int32_t id) const
{
  auto c = category_map.find(id);
  if (c !=  category_map.end())
    return c->second;
  return nullptr;
}
 
const std::shared_ptr<Item> Model::change_checked_state(
    int32_t id,
    check_action action)
{
  std::shared_ptr<Item> item;
  switch (action) {
    case Model::toggle:
      item = toggle_item_checked(id);
      break;
    case Model::check:
    case Model::uncheck:
      item = set_item_checked(id, action == Model::check);
      break;
  }
  return item;
}
 
void Model::change_all_current_items_checked_states(check_action action)
{
  vector<shared_ptr<Item>> items = get_all_items_for_current_selected_category();
  for (const auto& i : items) {
    switch (action) {
      case check:
        i->checked = true;
        break;
      case uncheck:
        i->checked = false;
        break;
      case toggle:
        i->checked = !i->checked;
        break;
    }
  }
  set_dirty();
}
 
const vector<shared_ptr<Item>> Model::get_all_items_for_current_selected_category() const
{
  vector<shared_ptr<Item>> r;
  if (selected_category == no_category) {
    r = items;
  } else {
    auto c = category_map.find(selected_category);
    if (c != category_map.end())
      r = c->second->items;
  }
  return r;
}
 
const vector<shared_ptr<Item>> Model::filter_items_for_current_selected_category() const
{
  vector<shared_ptr<Item>> r = get_all_items_for_current_selected_category();
  if (filter == all)
    return r;
 
  vector<shared_ptr<Item>> f;
  for (const auto& i : r) {
    switch (filter) {
      case all:
        f.push_back(i);
        break;
      case checked:
        if (i->checked)
          f.push_back(i);
        break;
      case unchecked:
        if (!i->checked)
          f.push_back(i);
        break;
    }
  }
  return f;
}
 
void Model::remove_all_current_checked_items()
{
  assert(selected_category != no_category);
  if (selected_category == no_category)
    return;
  // Iterate across all items in the current category and remove them from the
  // category if they match the state
  auto category = get_current_category();
  assert(category);
  if (!category)
    return;
  category->items.erase(
      remove_if(category->items.begin(), category->items.end(),
                [=](const auto& i) {
                  return (i->checked);
                }),
      category->items.end());
  auto iter = category->item_map.begin();
  auto end_iter = category->item_map.end();
  for (; iter != end_iter; ) {
    if (iter->second->checked == true) {
      // Remove the category from the target item
      auto item = iter->second;
      item->category_map.erase(category->id);
      item->categories.erase(
          remove_if(item->categories.begin(), item->categories.end(),
                    [=](const auto& c) {
                      return !c.expired() && c.lock()->id == category->id;
                    }),
          item->categories.end());
      iter = category->item_map.erase(iter);
    } else {
      ++iter;
    }
  }
  set_dirty();
  validate();
}
 
void Model::delete_all_current_checked_items()
{
  assert(selected_category == no_category);
  if (selected_category != no_category)
    return;
 
  // For each category, remove any references to checked items
  for (const auto& category : categories) {
    category->items.erase(
        remove_if(category->items.begin(), category->items.end(),
                  [=](const auto& i) {
                    return (i->checked);
                  }),
        category->items.end());
 
    auto iter = category->item_map.begin();
    auto end_iter = category->item_map.end();
    for (; iter != end_iter; ) {
      if (iter->second->checked == true) {
        iter = category->item_map.erase(iter);
      } else {
        ++iter;
      }
    }
  }
  auto iter = item_map.begin();
  for (; iter != item_map.end(); ) {
    if (iter->second->checked) {
      iter = item_map.erase(iter);
    } else {
      ++iter;
    }
  }
  // Remove the checked items
  items.erase(
      remove_if(items.begin(), items.end(),
                [=](const auto& i) {
                  return i->checked;
                }),
      items.end());
  set_dirty();
  validate();
}
 
void Model::copy_items_to_categories(vector<shared_ptr<Item>>& items,
                                     vector<shared_ptr<Category>>& categories) {
  bool modified = false;
  for (const auto& c : categories) {
    bool category_modified = false;
    for (const auto& i : items) {
      const auto r = c->item_map.insert(make_pair(i->id, i));
      if (r.second) {
        modified = true;
        category_modified = true;
        c->items.push_back(i);
        const auto r2 = i->category_map.insert(make_pair(c->id, c));
        if (r2.second)
          i->categories.push_back(c);
      }
    }
    if (category_modified)
      c->sort_items();
  }
  if (modified)
    set_dirty();
  validate();
}
 
void Model::copy_checked_items_to_categories(std::vector<int32_t> cids)
{
  const auto items = get_all_items_for_current_selected_category();
  std::vector<shared_ptr<Item>> source_items{};
  for (const auto& i : items) {
    if (i->is_checked())
      source_items.push_back(i);
  }
  std::vector<shared_ptr<Category>> target_categories{};
  for (auto cid : cids) {
    auto category = get_category(cid);
    if (category)
      target_categories.push_back(category);
  }
  copy_items_to_categories(source_items, target_categories);
}
 
void Model::copy_item_to_categories(int32_t item_id, std::vector<int32_t> cids)
{
  auto item = get_item(item_id);
  std::vector<shared_ptr<Item>> source_items{item};
  std::vector<shared_ptr<Category>> target_categories{};
  for (auto cid : cids) {
    auto category = get_category(cid);
    if (category)
      target_categories.push_back(category);
  }
  copy_items_to_categories(source_items, target_categories);
}
 
void Model::sort_items()
{
  std::sort(items.begin(), items.end(),
            [](shared_ptr<Item> a, shared_ptr<Item> b) {
              return *a < *b;
            });
}
 
void Model::sort_categories()
{
  std::sort(categories.begin(), categories.end(),
            [](shared_ptr<Category> a, shared_ptr<Category>b) {
              return *a < *b;
            });
}
 
void Model::sort_category_items()
{
  for (auto c : categories)
    std::sort(c->items.begin(), c->items.end(),
              [](shared_ptr<Item> a, shared_ptr<Item> b) {
                return *a < *b;
              });
}
 
void Model::sort_item_categories()
{
  for (auto i : items)
    std::sort(i->categories.begin(), i->categories.end(),
              [](weak_ptr<Category> a, weak_ptr<Category> b) {
                return a < b;
              });
}
 
void Model::sort()
{
  sort_items();
  sort_categories();
  sort_category_items();
  sort_item_categories();
}
 
void Model::show_model() const
{
  cout << "There are " << get_item_count()
       << " items and " << get_category_count()
       << " categories." << endl;
  cout << "Categories:\n";
  for (const shared_ptr<Category>& c : categories) {
    cout << c->id << '\t' << c->name << '\n';
    for (const shared_ptr<Item>& i : c->items) {
      cout << '\t' << i->id << '\t' << i->name << '\n';
    }
  }
  cout << "Items:\n";
  for (const shared_ptr<Item>& i : items) {
    cout << i->id << '\t' << i->name << '\n';
    for (const weak_ptr<Category>& cat : i->categories) {
      assert(!cat.expired());
      shared_ptr c = cat.lock();
    }
  }
}
 
void Model::validate() const
{
  #ifndef NDEBUG
  assert(categories.size() == category_map.size());
  assert(items.size() == item_map.size());
  // All categories must be in category map
  for (auto c : categories) {
    assert(category_map.find(c->id) != category_map.end());
    // All the category's items must be in the category's item map
    for (auto ci : c->items) {
      assert(c->item_map.find(ci->id) != c->item_map.end());
      // All this category's items must contain a link to this category
      assert(ci->category_map.find(c->id) != ci->category_map.end());
    }
  }
  // All items must be in the item map
  for (auto i : items) {
    assert(item_map.find(i->id) != item_map.end());
    // all the item's categories must be in the item's category map
    for (auto ic : i->categories) {
      assert(!ic.expired());
      assert(i->category_map.find(ic.lock()->id) != i->category_map.end());
    }
  }
  #endif
}
 
void Model::renumber_items()
{
  sort_items();
  item_map.clear();
  max_item_id = 0;
  for (auto i : items) {
    i->id = ++max_item_id;
    item_map.insert(make_pair(i->id, i));
  }
  // Rebuild the item map for each of the categories
  for (auto c : categories) {
    c->item_map.clear();
    for (auto i : c->items) {
      c->item_map.insert(make_pair(i->id, i));
    }
  }
  set_dirty();
}
 
void Model::renumber_categories()
{
  sort_categories();
  category_map.clear();
  max_category_id = 0;
  for (auto c : categories) {
    c->id = ++max_category_id;
    category_map.insert(make_pair(c->id, c));
    // Rebuild the category map for each of the items
    for (auto i : items) {
      i->category_map.clear();
      for (auto c : categories) {
        i->category_map.insert(make_pair(c->id, c));
      }
    }
  }
  set_dirty();
}
 
void Model::renumber()
{
  renumber_items();
  renumber_categories();
}