AssetsCollection.h

Go to the documentation of this file.

/*
 * Crossfire -- cooperative multi-player graphical RPG and adventure game
 *
 * Copyright (c) 2020 the Crossfire Development Team
 *
 * Crossfire is free software and comes with ABSOLUTELY NO WARRANTY. You are
 * welcome to redistribute it under certain conditions. For details, please
 * see COPYING and LICENSE.
 *
 * The authors can be reached via e-mail at <crossfire@metalforge.org>.
 */
 
#ifndef ASSETSCOLLECTION_H
#define ASSETSCOLLECTION_H
 
#include <string>
#include <unordered_map>
#include <set>
#include <vector>
#include <algorithm>
#include <functional>
 
template<class T>
extern void asset_destroy(T *asset);
 
template <class T, class Key>
extern T *asset_create(const Key &key);
 
template<class T, class Key = std::string>
class AssetsCollection {
 
    public:
 
        virtual ~AssetsCollection() {
            clear();
        }
 
        void clear() {
            for (auto asset : m_assets) {
                asset_destroy(asset.second);
            }
            m_assets.clear();
        }
 
        size_t count() const {
            return m_assets.size();
        }
 
        T *get(const Key& name) {
            auto asset = m_assets.find(name);
            if (asset != m_assets.end()) {
                return asset->second;
            }
 
            T *add = asset_create<T>(name);
            m_assets[name] = add;
            m_undefined.insert(name);
            added(add);
            return add;
        }
 
        T *find(const Key& name) {
            auto asset = m_assets.find(name);
            return asset != m_assets.end() ? asset->second : nullptr;
        }
 
        T *define(const Key& name, T *asset) {
            m_undefined.erase(name);
            auto existing = m_assets.find(name);
            if (existing != m_assets.end()) {
                replace(existing->second, asset);
                return existing->second;
            }
 
            m_assets[name] = asset;
            added(asset);
            return asset;
        }
 
        T *next(T *current) {
            if (m_assets.empty()) {
                return nullptr;
            }
            if (current == nullptr) {
                return m_assets.begin()->second;
            }
 
            auto c = std::find_if(m_assets.begin(), m_assets.end(), [&current](auto& item) { return item.second == current; });
            if (c == m_assets.end() || (++c) == m_assets.end()) {
                return nullptr;
            }
            return c->second;
        }
 
        void each(std::function<void(T *)> op) {
            std::for_each(m_assets.begin(), m_assets.end(), [&op] (auto item) { op(item.second); });
        }
 
        T *first(std::function<bool(const T *)> op) {
            auto found = std::find_if(m_assets.begin(), m_assets.end(), [&op] (auto item) { return op(item.second); });
            return found == m_assets.end() ? nullptr : found->second;
        }
 
        const std::set<Key>& undefined() const { return m_undefined; }
 
        std::vector<Key> keys() const {
            std::vector<Key> k;
            std::for_each(m_assets.cbegin(), m_assets.cend(), [&k] (const auto &asset) { k.push_back(asset.first); });
            return k;
        }
 
    protected:
        std::unordered_map<Key, T*> m_assets; 
        std::set<Key> m_undefined;  
        virtual void replace(T *existing, T *update) = 0;
 
        virtual void added(T *) { }
};
 
#endif /* ASSETSCOLLECTION_H */