category.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 CATEGORY_HPP
#define CATEGORY_HPP
 
#include "item.hpp"
#include <algorithm>
#include <cassert>
#include <cstdint>
// #include <iostream>
#include <map>
#include <memory>
#include <string>
#include <vector>

class Category {
  friend class KitParser;
  friend class Model;
  friend class XmlWriter;

  int32_t id;
 
public:
  Category() : id(), name(), items(), item_map() {
  }

  std::string name;

  int32_t get_id() const {
    return id;
  }

  const std::string get_name() const {
    return name;
  }

  void sort_items() {
    std::sort(items.begin(), items.end(),
              [](std::shared_ptr<Item> a, std::shared_ptr<Item> b) {
                return *a < *b;
              });
  }

  inline friend bool operator< (const Category& lhs, const Category& rhs) {
    return lhs.name == rhs.name ? lhs.id < rhs.id : lhs.name < rhs.name;
  }

  inline friend bool operator< (std::shared_ptr<Category> lhs, std::shared_ptr<Category> rhs) {
    return *lhs < *rhs;
  }

  inline friend bool operator< (std::weak_ptr<Category> lhs, std::weak_ptr<Category> rhs) {
    assert(!lhs.expired());
    assert(!rhs.expired());
    if (lhs.expired() || rhs.expired())
      return true;
    return *(lhs.lock()) < *(rhs.lock());
  }
 
protected:

  Category(int32_t id,
           std::string name) : id(id), name(name), items(), item_map() {
  }

  void set_name(const std::string& name) {
    this->name = name;
  }
 
private:
  std::vector<std::shared_ptr<Item>> items;

  std::map<int32_t, std::shared_ptr<Item>> item_map;
 
};
 
#endif // CATEGORY_HPP