musiclibraryhash.h

Go to the documentation of this file.

 
#pragma once
 
#include <string>
#include <unordered_map>
#include <functional>
 
#include "utility.h"
#include "musiclibrary.h"
 
namespace MusicLibrary {
 
    /*
     *              Supporting functions
     */
 
    inline std::string persistentId (MusicThingie::Type item_type, const std::string &key) {
        const char type_code[2] = {static_cast<char> (item_type), '\0'};
        return type_code + std::to_string (create_key_from_string (key));
    }
 
 
 
    template <class TThing, class TParent>
    ThingieContainer<TThing, TParent>::ThingieContainer (const Allocator &alloc)
    : allocate (alloc) {
    }
 
    template <class TThing, class TParent>
    ThingieContainer<TThing, TParent>::~ThingieContainer() {
#ifndef NDEBUG
        for (auto &item : *this) {
            assert (item.second->getUseCount() == 1);
        }
#endif
        clear();
    }
 
    template <class TThing, class TParent>
    void ThingieContainer<TThing, TParent>::purge (bool pred (const TThing *)) {
        auto it = this->begin();
        while (it != this->end()) {
            auto element = it++;
            if (pred (element->second)) {
                element->second->release();
                this->erase (element);
            }
        }
    }
 
    template <class TThing, class TParent>
    void ThingieContainer<TThing, TParent>::clear() {
        while (this->begin() != this->end()) {
            this->begin()->second->release();
            this->erase (this->begin());
        }
    }
 
    template <class TThing, class TParent>
    TThing *ThingieContainer<TThing, TParent>::getById (const std::string &key) const {
        const auto iterator = this->find (key);
        return (iterator == this->end() ? nullptr : iterator->second);
    }
 
    template <class TThing, class TParent>
    TThing *ThingieContainer<TThing, TParent>::getById (const Parsnip::Data &data, const char *field) {
        return getById (data[field].asString());
    }
 
    template <class TThing, class TParent>
    TThing *ThingieContainer<TThing, TParent>::getByName (const std::string &name, TParent *parent) const {
        for (auto item : *this) {
            if (item.second->parent() == parent && *(item.second) == name) {
                return item.second;
            }
        }
        return nullptr;
    }
 
    template <class TThing, class TParent>
    std::string ThingieContainer<TThing, TParent>::getNewId (MusicThingie::Type item_type) const {
        const char type[2] = {static_cast<char> (item_type), '\0'};
        while (true) {
            long candidate = random();
            std::string newid = type + std::to_string (candidate);
            if (!getById (newid))
                return newid;
        }
    }
 
    template <class TThing, class TParent>
    TThing *ThingieContainer<TThing, TParent>::addItem (const std::string &name, std::string id, TParent *parent) {
        std::string newid (id.empty() ? getNewId (TThing::typetype()) : id);
        TThing *thing = allocate (parent, newid, name);
        assert (this->find (newid) == this->end());
        (*this)[newid] = thing;
        thing->retain();
        return thing;
    }
 
    template <class TThing, class TParent>
    TThing *ThingieContainer<TThing, TParent>::addOrGetItem (const std::string &name, std::string id, TParent *parent) {
        assert (parent);
        TThing *thing;
        if (id.empty()) {
            // Hash the name for a candidate ID
            id = persistentId (TThing::typetype(), name);
            thing = getById (id);
            if (thing && thing->parent() == parent && *thing == name) {
                return thing;
            }
            // If there was no match, leave ID set to the candidate ID.
            if (thing)
                id = "";
            thing = getByName (name, parent);
        } else {
            thing = getById (id);
        }
        if (thing)
            return thing;
        return addItem (name, id, parent);
    }
 
    template <class TThing, class TParent>
    TThing *ThingieContainer<TThing, TParent>::addOrGetItem (const Parsnip::Data &data,
                                                             TParent *parent,
                                                             const std::string &namefield,
                                                             const std::string &idfield) {
        const std::string &name = data[namefield].asString();
        const std::string &id = data[idfield].asString();
        TThing *item = addOrGetItem (name, id, parent);
        assert (item);
        item->restore (data);
        return item;
    }
 
}  // namespace MusicLibrary