NameIndex.hpp

Go to the documentation of this file.

 
#ifndef OPENSWMM_ENGINE_NAME_INDEX_HPP
#define OPENSWMM_ENGINE_NAME_INDEX_HPP
 
#include <string>
#include <string_view>
#include <unordered_map>
#include <vector>
#include <stdexcept>
#include <optional>
 
namespace openswmm {
 
class NameIndex {
public:
    NameIndex() = default;
 
    // -----------------------------------------------------------------------
    // Insertion
    // -----------------------------------------------------------------------
 
    int add(const std::string& name) {
        auto [it, inserted] = map_.emplace(name, static_cast<int>(names_.size()));
        if (!inserted) {
            throw std::invalid_argument("NameIndex: duplicate name '" + name + "'");
        }
        names_.push_back(name);
        return it->second;
    }
 
    // -----------------------------------------------------------------------
    // Lookup
    // -----------------------------------------------------------------------
 
    int find(std::string_view name) const noexcept {
        auto it = map_.find(std::string(name));
        if (it == map_.end()) return -1;
        return it->second;
    }
 
    std::optional<int> try_find(std::string_view name) const noexcept {
        auto it = map_.find(std::string(name));
        if (it == map_.end()) return std::nullopt;
        return it->second;
    }
 
    const std::string& name_of(int idx) const {
        return names_.at(static_cast<std::size_t>(idx));
    }
 
    // -----------------------------------------------------------------------
    // Capacity
    // -----------------------------------------------------------------------
 
    int size() const noexcept { return static_cast<int>(names_.size()); }
 
    bool empty() const noexcept { return names_.empty(); }
 
    void reserve(std::size_t n) {
        map_.reserve(n);
        names_.reserve(n);
    }
 
    void clear() noexcept {
        map_.clear();
        names_.clear();
    }
 
    void pop_back() noexcept {
        if (names_.empty()) return;
        const std::string tail = names_.back();
        map_.erase(tail);
        names_.pop_back();
    }
 
    bool rename(int idx, const std::string& newName) noexcept {
        if (idx < 0 || idx >= static_cast<int>(names_.size())) return false;
        if (map_.count(newName)) return false; // would create a duplicate
        map_.erase(names_[static_cast<std::size_t>(idx)]);
        names_[static_cast<std::size_t>(idx)] = newName;
        map_[newName] = idx;
        return true;
    }
 
    void remove_at(int idx) noexcept {
        if (idx < 0 || idx >= static_cast<int>(names_.size())) return;
        names_.erase(names_.begin() + idx);
        map_.clear();
        map_.reserve(names_.size());
        for (int i = 0; i < static_cast<int>(names_.size()); ++i)
            map_[names_[i]] = i;
    }
 
    // -----------------------------------------------------------------------
    // Iteration
    // -----------------------------------------------------------------------
 
    const std::vector<std::string>& names() const noexcept { return names_; }
 
private:
    std::unordered_map<std::string, int> map_;   
    std::vector<std::string>             names_;  
};
 
} /* namespace openswmm */
 
#endif /* OPENSWMM_ENGINE_NAME_INDEX_HPP */