NameIndex.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: Apache-2.0
//
// Copyright 2026 Caleb Buahin
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

 
#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>
 
#include "../core/StringCase.hpp"
 
namespace openswmm {

class NameIndex {
public:
    NameIndex() = default;
 
    // -----------------------------------------------------------------------
    // Insertion
    // -----------------------------------------------------------------------

    int add(const std::string& name) {
        const int idx = try_add(name);
        if (idx < 0) {
            throw std::invalid_argument("NameIndex: duplicate name '" + name + "'");
        }
        return idx;
    }

    int try_add(const std::string& name) {
        auto [it, inserted] = map_.emplace(name, static_cast<int>(names_.size()));
        if (!inserted)
            return -1;
        names_.push_back(name);
        return it->second;
    }
 
    // -----------------------------------------------------------------------
    // Lookup
    // -----------------------------------------------------------------------

    int find(std::string_view name) const noexcept {
        auto it = map_.find(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(name);
        if (it == map_.end())
            return std::nullopt;
        return it->second;
    }

    const std::string* canonical(std::string_view name) const noexcept {
        auto it = map_.find(name);
        if (it == map_.end())
            return nullptr;
        return &names_[static_cast<std::size_t>(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;
        auto it = map_.find(newName);
        if (it != map_.end() && it->second != idx)
            return false; // 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);
        if (bulk_depth_ > 0)
            return; // map rebuilt once in end_bulk_remove()
        rebuild_map_();
    }

    void begin_bulk_remove() noexcept { ++bulk_depth_; }

    void end_bulk_remove() {
        if (bulk_depth_ == 0 || --bulk_depth_ > 0)
            return;
        rebuild_map_();
    }
 
    // -----------------------------------------------------------------------
    // Iteration
    // -----------------------------------------------------------------------

    const std::vector<std::string>& names() const noexcept { return names_; }
 
private:
    void rebuild_map_() {
        map_.clear();
        map_.reserve(names_.size());
        for (int i = 0; i < static_cast<int>(names_.size()); ++i)
            map_[names_[static_cast<std::size_t>(i)]] = i;
    }

    std::unordered_map<std::string, int, CiHash, CiEqual> map_;
    std::vector<std::string> names_; 
    int bulk_depth_ = 0;             
};
 
} /* namespace openswmm */
 
#endif /* OPENSWMM_ENGINE_NAME_INDEX_HPP */