TemplateVec.h

Go to the documentation of this file.

 
#pragma once
 
#include <algorithm>
#include <cstdlib>
#include <map>
#include <memory>
#include <string>
#include <utility>
#include <vector>
 
#include "BaseLib/Logging.h"
 
#include "BaseLib/Error.h"
 
namespace GeoLib
{
template <class T>
class TemplateVec
{
public:
    using NameIdPair = std::pair<std::string, std::size_t>;
    using NameIdMap = std::map<std::string, std::size_t>;
 
    TemplateVec(std::string const& name, std::vector<T*>&& data_vec,
                NameIdMap&& elem_name_map)
        : _name(name),
          _data_vec(std::move(data_vec)),
          _name_id_map(std::move(elem_name_map))
    {
    }
 
    virtual ~TemplateVec()
    {
        for (std::size_t k(0); k < size(); k++)
        {
            delete _data_vec[k];
        }
    }
 
    void setName(const std::string& n) { _name = n; }
    std::string getName() const { return _name; }
 
    NameIdMap::const_iterator getNameIDMapBegin() const
    {
        return _name_id_map.cbegin();
    }
 
    NameIdMap::const_iterator getNameIDMapEnd() const
    {
        return _name_id_map.cend();
    }
 
    std::size_t size() const { return _data_vec.size(); }
 
    std::vector<T*> const& getVector() const { return _data_vec; }
 
    bool getElementIDByName(const std::string& name, std::size_t& id) const
    {
        auto it(_name_id_map.find(name));
 
        if (it != _name_id_map.end())
        {
            id = it->second;
            return true;
        }
        return false;
    }
 
    const T* getElementByName(const std::string& name) const
    {
        std::size_t id;
        bool ret(getElementIDByName(name, id));
        if (ret)
        {
            return _data_vec[id];
        }
 
        return nullptr;
    }
 
    bool getNameOfElementByID(std::size_t id, std::string& element_name) const
    {
        // search in map for id
        auto it = findFirstElementByID(id);
        if (it == _name_id_map.end())
        {
            return false;
        }
        element_name = it->first;
        return true;
    }
 
    void setNameOfElementByID(std::size_t id, std::string const& element_name)
    {
        _name_id_map[element_name] = id;
    }
 
    bool getNameOfElement(const T* data, std::string& name) const
    {
        for (std::size_t k(0); k < _data_vec.size(); k++)
        {
            if (_data_vec[k] == data)
            {
                return getNameOfElementByID(k, name);
            }
        }
 
        return false;
    }
 
    virtual void push_back(T* data_element,
                           std::string const* const name = nullptr)
    {
        _data_vec.push_back(data_element);
        if (!name || name->empty())
        {
            return;
        }
 
        auto it(_name_id_map.find(*name));
        if (it == _name_id_map.end())
        {
            _name_id_map[*name] = _data_vec.size() - 1;
        }
        else
        {
            WARN(
                "Name '{:s}' exists already. The object will be inserted "
                "without a name",
                *name);
        }
    }
 
    virtual void setNameForElement(std::size_t id, std::string const& name)
    {
        // Erase id if found in map.
        auto it = findFirstElementByID(id);
        if (it != _name_id_map.end())
        {
            _name_id_map.erase(it);
        }
 
        if (!name.empty())
        {
            // insert new or revised name
            _name_id_map[name] = id;
        }
    }
 
private:
    NameIdMap::const_iterator findFirstElementByID(std::size_t const& id) const
    {
        return std::find_if(_name_id_map.begin(), _name_id_map.end(),
                            [id](NameIdPair const& elem)
                            { return elem.second == id; });
    }
 
protected:
    TemplateVec(TemplateVec const&) = delete;
    TemplateVec(TemplateVec&&) = delete;
    TemplateVec& operator=(TemplateVec const& rhs) = delete;
    TemplateVec& operator=(TemplateVec&& rhs) = delete;
 
    std::string _name;
 
    std::vector<T*> _data_vec;
    NameIdMap _name_id_map;
};
}  // end namespace GeoLib