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
{
protected:
    using NameIdPair = std::pair<std::string, std::size_t>;
    using NameIdMap = std::map<std::string, std::size_t>;
 
public:
    TemplateVec(std::string name, std::unique_ptr<std::vector<T*>> data_vec,
                std::unique_ptr<NameIdMap> elem_name_map = nullptr)
        : _name(std::move(name)),
          _data_vec(std::move(data_vec)),
          _name_id_map(std::move(elem_name_map))
    {
        if (_data_vec == nullptr)
        {
            OGS_FATAL("Constructor TemplateVec: vector of data elements is a nullptr.");
        }
 
        if (!_name_id_map)
        {
            _name_id_map = std::make_unique<NameIdMap>();
        }
    }
 
    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(); }
 
    const std::vector<T*>* getVector () const { return _data_vec.get(); }
 
    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->insert(NameIdPair(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;
        }
 
        std::map<std::string, std::size_t>::const_iterator it(
            _name_id_map->find(*name)
        );
        if (it == _name_id_map->end()) {
            _name_id_map->insert(NameIdPair(*name, _data_vec->size() - 1));
        } else {
            WARN(
                "Name '{:s}' exists already. The object will be inserted "
                "without a name",
                name->c_str());
        }
    }
 
    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->insert(NameIdPair(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:
    // compiler does not create a (possible unwanted) copy constructor
    TemplateVec (const TemplateVec &);
    // this way the compiler does not create a (possible unwanted) assignment operator
    TemplateVec& operator= (const TemplateVec& rhs);
 
    std::string _name;
 
    std::unique_ptr<std::vector <T*>> _data_vec;
    std::unique_ptr<NameIdMap> _name_id_map;
};
} // end namespace GeoLib