CollMgr.H

Go to the documentation of this file.

#ifndef COLLMGR_H
#define COLLMGR_H
 
#include <string>
#include <memory>
#include <unordered_map>
#include "AMReX_Vector.H"
 
namespace amr_wind {

template <typename Collection, typename Type, bool allow_duplicates = false>
class CollMgr
{
public:
    using TypePtr = std::unique_ptr<Type>;
    using TypeVector = amrex::Vector<TypePtr>;
 
private:
    CollMgr() = default;
 
public:
    ~CollMgr() = default;
 
    CollMgr(const CollMgr&) = delete;
    CollMgr& operator=(const CollMgr&) = delete;

    template <class... Args>
    Type& create(const std::string& key, Args&&... args)
    {
        if (!allow_duplicates && contains(key)) {
            return operator()(key);
        }
 
        m_obj_vec.emplace_back(Type::create(key, std::forward<Args>(args)...));
        m_obj_map[key] = m_obj_vec.size() - 1;
 
        return *m_obj_vec.back();
    }

    TypeVector& objects() { return m_obj_vec; }
    [[nodiscard]] const TypeVector& objects() const { return m_obj_vec; }

    [[nodiscard]] bool contains(const std::string& key) const
    {
        auto it = m_obj_map.find(key);
        return (it != m_obj_map.end());
    }

    Type& operator()(const std::string& key)
    {
        return *m_obj_vec[m_obj_map.at(key)];
    }
 
    const Type& operator()(const std::string& key) const
    {
        return *m_obj_vec[m_obj_map.at(key)];
    }

    template <typename T>
    T& operator()(const std::string& key)
    {
        return dynamic_cast<T&>(operator()(key));
    }
 
protected:
    TypeVector m_obj_vec;

    std::unordered_map<std::string, int> m_obj_map;
    friend Collection;
};
 
} // namespace amr_wind
 
#endif /* COLLMGR_H */