AS_asset_catalog.hh

Go to the documentation of this file.

/* SPDX-FileCopyrightText: 2023 Blender Authors
 *
 * SPDX-License-Identifier: GPL-2.0-or-later */
 
#pragma once
 
#include <memory>
#include <mutex>
#include <set>
#include <string>
 
#include "BLI_function_ref.hh"
#include "BLI_map.hh"
#include "BLI_set.hh"
#include "BLI_uuid.h"
#include "BLI_vector.hh"
 
#include "AS_asset_catalog_path.hh"
 
namespace blender::asset_system {
 
class AssetCatalog;
class AssetCatalogCollection;
class AssetCatalogDefinitionFile;
class AssetCatalogFilter;
class AssetCatalogTree;
 
using CatalogID = bUUID;
using CatalogPathComponent = std::string;
/* Would be nice to be able to use `std::filesystem::path` for this, but it's currently not
 * available on the minimum macOS target version. */
using CatalogFilePath = std::string;
using OwningAssetCatalogMap = Map<CatalogID, std::unique_ptr<AssetCatalog>>;
 
/* Manages the asset catalogs of a single asset library (i.e. of catalogs defined in a single
 * directory hierarchy). */
class AssetCatalogService {
  std::unique_ptr<AssetCatalogCollection> catalog_collection_;
 
  std::unique_ptr<AssetCatalogTree> catalog_tree_;
  std::mutex catalog_tree_mutex_;
 
  Vector<std::unique_ptr<AssetCatalogCollection>> undo_snapshots_;
  Vector<std::unique_ptr<AssetCatalogCollection>> redo_snapshots_;
 
  const CatalogFilePath asset_library_root_;
  const bool is_read_only_ = false;
 
 public:
  static const CatalogFilePath DEFAULT_CATALOG_FILENAME;
 
  struct read_only_tag {};
 
 public:
  explicit AssetCatalogService(const CatalogFilePath &asset_library_root = {});
  explicit AssetCatalogService(read_only_tag);
 
  void tag_has_unsaved_changes(AssetCatalog *edited_catalog);
  bool has_unsaved_changes() const;
 
  bool is_read_only() const;
 
  void load_from_disk();
  void load_from_disk(const CatalogFilePath &file_or_directory_path);
 
  void add_from_existing(const AssetCatalogService &other_service,
                         FunctionRef<void(const AssetCatalog &existing,
                                          const AssetCatalog &to_be_ignored)> on_duplicate_items);
 
  bool write_to_disk(const CatalogFilePath &blend_file_path);
 
  void prepare_to_merge_on_write();
 
  void reload_catalogs();
 
  AssetCatalog *find_catalog(CatalogID catalog_id) const;
 
  AssetCatalog *find_catalog_by_path(const AssetCatalogPath &path) const;
 
  bool is_catalog_known(CatalogID catalog_id) const;
 
  AssetCatalogFilter create_catalog_filter(CatalogID active_catalog_id) const;
 
  AssetCatalog *create_catalog(const AssetCatalogPath &catalog_path);
 
  void prune_catalogs_by_path(const AssetCatalogPath &path);
 
  void prune_catalogs_by_id(CatalogID catalog_id);
 
  void update_catalog_path(CatalogID catalog_id, const AssetCatalogPath &new_catalog_path);
 
  const AssetCatalogTree &catalog_tree();
 
  bool is_empty() const;
 
  void undo_push();
  void undo();
  bool is_undo_possbile() const;
  void redo();
  bool is_redo_possbile() const;
 
 protected:
  void load_directory_recursive(const CatalogFilePath &directory_path);
  void load_single_file(const CatalogFilePath &catalog_definition_file_path);
 
  bool write_to_disk_ex(const CatalogFilePath &blend_file_path);
  void untag_has_unsaved_changes();
  bool is_catalog_known_with_unsaved_changes(CatalogID catalog_id) const;
 
  void purge_catalogs_not_listed(const Set<CatalogID> &catalogs_to_keep);
 
  void delete_catalog_by_id_soft(CatalogID catalog_id);
 
  void delete_catalog_by_id_hard(CatalogID catalog_id);
 
  std::unique_ptr<AssetCatalogDefinitionFile> parse_catalog_file(
      const CatalogFilePath &catalog_definition_file_path);
 
  std::unique_ptr<AssetCatalogDefinitionFile> construct_cdf_in_memory(
      const CatalogFilePath &file_path) const;
 
  static CatalogFilePath find_suitable_cdf_path_for_writing(
      const CatalogFilePath &blend_file_path);
 
  std::unique_ptr<AssetCatalogTree> read_into_tree() const;
  void invalidate_catalog_tree();
 
  void create_missing_catalogs();
 
  void tag_all_catalogs_as_unsaved_changes();
 
  /* For access by subclasses, as those will not be marked as friend by #AssetCatalogCollection. */
  const AssetCatalogDefinitionFile *get_catalog_definition_file() const;
  const OwningAssetCatalogMap &get_catalogs() const;
  const OwningAssetCatalogMap &get_deleted_catalogs() const;
};
 
class AssetCatalog {
 public:
  const CatalogID catalog_id;
  AssetCatalogPath path;
  std::string simple_name;
 
  struct Flags {
    /* Treat this catalog as deleted. Keeping deleted catalogs around is necessary to support
     * merging of on-disk changes with in-memory changes. */
    bool is_deleted = false;
 
    /* Sort this catalog first when there are multiple catalogs with the same catalog path. This
     * ensures that in a situation where missing catalogs were auto-created, and then
     * load-and-merged with a file that also has these catalogs, the first one in that file is
     * always sorted first, regardless of the sort order of its UUID. */
    bool is_first_loaded = false;
 
    /* Merging on-disk changes into memory will not overwrite this catalog.
     * For example, when a catalog was renamed (i.e. changed path) in this Blender session,
     * reloading the catalog definition file should not overwrite that change.
     *
     * Note that this flag is ignored when is_deleted=true; deleted catalogs that are still in
     * memory are considered "unsaved" by definition. */
    bool has_unsaved_changes = false;
  } flags;
 
 public:
  AssetCatalog() = delete;
  AssetCatalog(CatalogID catalog_id, const AssetCatalogPath &path, const std::string &simple_name);
 
  static std::unique_ptr<AssetCatalog> from_path(const AssetCatalogPath &path);
 
  void simple_name_refresh();
 
 protected:
  static std::string sensible_simple_name_for_path(const AssetCatalogPath &path);
};
 
struct AssetCatalogLessThan {
  bool operator()(const AssetCatalog *lhs, const AssetCatalog *rhs) const
  {
    if (lhs->path != rhs->path) {
      return lhs->path < rhs->path;
    }
 
    if (lhs->flags.is_first_loaded != rhs->flags.is_first_loaded) {
      return lhs->flags.is_first_loaded;
    }
 
    return lhs->catalog_id < rhs->catalog_id;
  }
};
 
using AssetCatalogOrderedSet = std::set<const AssetCatalog *, AssetCatalogLessThan>;
using MutableAssetCatalogOrderedSet = std::set<AssetCatalog *, AssetCatalogLessThan>;
 
class AssetCatalogFilter {
  const Set<CatalogID> matching_catalog_ids_;
  const Set<CatalogID> known_catalog_ids_;
 
  friend AssetCatalogService;
 
 public:
  bool contains(CatalogID asset_catalog_id) const;
 
  /* So that all unknown catalogs can be shown under "Unassigned". */
  bool is_known(CatalogID asset_catalog_id) const;
 
 protected:
  explicit AssetCatalogFilter(Set<CatalogID> &&matching_catalog_ids,
                              Set<CatalogID> &&known_catalog_ids);
};
 
}  // namespace blender::asset_system