NamedObjectCont.h

Go to the documentation of this file.

/****************************************************************************/
// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
// Copyright (C) 2002-2024 German Aerospace Center (DLR) and others.
// This program and the accompanying materials are made available under the
// terms of the Eclipse Public License 2.0 which is available at
// https://www.eclipse.org/legal/epl-2.0/
// This Source Code may also be made available under the following Secondary
// Licenses when the conditions for such availability set forth in the Eclipse
// Public License 2.0 are satisfied: GNU General Public License, version 2
// or later which is available at
// https://www.gnu.org/licenses/old-licenses/gpl-2.0-standalone.html
// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
/****************************************************************************/
// A map of named object pointers
/****************************************************************************/
#pragma once
#include <config.h>
#include <map>
#include <string>
#include <vector>
#include <algorithm>
 
 
// ===========================================================================
// class definitions
// ===========================================================================
template<class T>
class NamedObjectCont {
public:
    typedef std::map< std::string, T > IDMap;
 
    NamedObjectCont() {}
 
    virtual ~NamedObjectCont() {
        // iterate over all elements to delete it
        for (auto i : myMap) {
            delete i.second;
        }
    }
 
    bool add(const std::string& id, T item) {
        const auto it = myMap.lower_bound(id);
        if (it == myMap.end() || it->first != id) {
            myMap.emplace_hint(it, id, item);
            return true;
        }
        return false;
    }
 
    bool remove(const std::string& id, const bool del = true) {
        auto it = myMap.find(id);
        if (it == myMap.end()) {
            return false;
        } else {
            if (del) {
                delete it->second;
            }
            myMap.erase(it);
            return true;
        }
    }
 
    T get(const std::string& id) const {
        auto it = myMap.find(id);
        if (it == myMap.end()) {
            return 0;
        } else {
            return it->second;
        }
    }
 
    void clear() {
        for (auto i : myMap) {
            delete i.second;
        }
        myMap.clear();
    }
 
    int size() const {
        return (int) myMap.size();
    }
 
    /* @brief Fills the given vector with the stored objects' ids
     * @param[in] into The container to fill
     */
    void insertIDs(std::vector<std::string>& into) const {
        for (auto i : myMap) {
            into.push_back(i.first);
        }
    }
 
    bool changeID(const std::string& oldId, const std::string& newId) {
        auto i = myMap.find(oldId);
        if (i == myMap.end()) {
            return false;
        } else {
            // save Item, remove it from Map, and insert it again with the new ID
            T item = i->second;
            myMap.erase(i);
            myMap.insert(std::make_pair(newId, item));
            return true;
        }
    }
 
    typename IDMap::const_iterator begin() const {
        return myMap.begin();
    }
 
    typename IDMap::const_iterator end() const {
        return myMap.end();
    }
 
 
private:
    IDMap myMap;
};