PropertyLinkMap.h

Go to the documentation of this file.

#pragma once
 
#include <Base/Writer.h>
#include <Base/AbstractXMLReader.h>
#include <Base/StringTool.h>
#include <Core/DbgInfo.h>
#include <Core/CoreDocument.h>
#include <Core/PropertyLinkBaseBase.h>
 
 
namespace Core
{
class LX_CORE_EXPORT PropertyType2Link : public Core::PropertyLinkBaseBase
{
    TYPESYSTEM_HEADER();
 
public:
    void setValue(const std::map<Base::Type, Core::DocObject*>& list);
    bool setValueFromVariant(const Core::Variant& v) override;
    [[nodiscard]] Core::Variant getVariant(void) const override { return Core::Variant(_linkMap); }
    [[nodiscard]] const std::map<Base::Type, Core::DocObject*>& getValue() const { return _linkMap; }
    [[nodiscard]] std::vector<Core::DocObject*> getLinks() override;
 
    void copyValue(Core::Property* p) override;
    void deepCopy(Core::Property* p, Core::CoreDocument* dest_doc, DocObjectMap& copyMap) override;
 
    bool hasKey(Base::Type type) const;
    bool hasLink(Core::DocObject* link) const;
    bool addLink(Core::DocObject* link) override;
    bool removeLink(Core::DocObject* link) override;
    [[nodiscard]] Core::DocObject* getLink(Base::Type type) const;
 
    [[nodiscard]] bool isEmpty() const;
    void setEmpty();
    [[nodiscard]] size_t getSize() const;
 
    void save(Base::AbstractWriter& writer, Base::PersistenceVersion& save_version) override;
    inline void restore(Base::AbstractXMLReader& reader, Base::PersistenceVersion& version) override;
 
    bool isEqual(const Property* o) const override;
    const Core::PropertyKind getPropertyKind(void) const override;
 
    std::shared_ptr<Core::DbgInfo> getDbgInfo() const override;
    Core::Property* copy(void) const override;
    void paste(const Core::Property& from) override;
 
protected:
    std::map<Base::Type, Core::DocObject*> _linkMap;
};
 
 
template <typename T>
class PropertyLinkMap : public Core::PropertyLinkBaseBase
{
    TYPESYSTEM_PROPERTY_HEADER(PropertyLinkMap, Core::PropertyLinkBaseBase);
 
public:
    void setValue(const std::map<T, Core::DocObject*>& list);
    bool setValueFromVariant(const Core::Variant&) override;
    [[nodiscard]] Core::Variant getVariant(void) const override;
    [[nodiscard]] const std::map<T, Core::DocObject*>& getValue() const { return _linkMap; }
    [[nodiscard]] std::vector<Core::DocObject*> getLinks() override;
 
    void copyValue(Core::Property* p) override;
    void deepCopy(Core::Property* p, Core::CoreDocument* dest_doc, DocObjectMap& copyMap) override;
 
    bool hasKey(T key) const;
    bool hasLink(Core::DocObject* link) const;
    bool addLink(Core::DocObject* link) override { return false; }
    bool addLink(T key, Core::DocObject* link);
    bool removeLink(Core::DocObject* link) override;
    Core::DocObject* getLink(T key) const;
 
    [[nodiscard]] bool isEmpty() const;
    void setEmpty();
    [[nodiscard]] size_t getSize() const;
 
    void save(Base::AbstractWriter& writer, Base::PersistenceVersion& save_version) override;
    void restore(Base::AbstractXMLReader& reader, Base::PersistenceVersion& version) override;
 
    bool isEqual(const Property* o) const override;
    const Core::PropertyKind getPropertyKind(void) const override;
 
    std::shared_ptr<Core::DbgInfo> getDbgInfo() const override;
    Core::Property* copy(void) const override;
    void paste(const Core::Property& from) override;
 
protected:
    std::map<T, Core::DocObject*> _linkMap;
};
 
 
#ifndef SWIG
 
template <typename T>
struct TypeName2
{
    static const char* Get() { return typeid(T).name(); }
};
 
template <typename T>
Base::Type PropertyLinkMap<T>::classTypeId = Base::Type().createType(Base::Type::badType(), TypeName2<PropertyLinkMap<T>>::Get());
#endif
 
 
template <typename T>
void PropertyLinkMap<T>::setValue(const std::map<T, Core::DocObject*>& map)
{
    aboutToSetValue();
    for (auto pairIt : _linkMap)
    {
        if (pairIt.second)
            pairIt.second->unref();
        onRemoveLink(pairIt.second);
    }
 
    _linkMap = *(const std::map<T, Core::DocObject*>*)(&map);
 
    for (auto pairIt : _linkMap)
    {
        onAddLink(pairIt.second);
        if (pairIt.second)
            pairIt.second->ref();
    }
    hasSetValue();
}
 
template <typename T>
bool PropertyLinkMap<T>::setValueFromVariant(const Core::Variant&)
{
    cWarn("Core::PropertyLinkMap::setValueFromVariant, Variant not implemented.");
    return false;
}
 
template <typename T>
Core::Variant PropertyLinkMap<T>::getVariant() const
{
    cWarn("Core::PropertyLinkMap::setValueFromVariant, Variant not implemented.");
    return Core::Variant();
}
 
template <typename T>
Core::DocObject* PropertyLinkMap<T>::getLink(T key) const
{
    const auto it = _linkMap.find(key);
    if (it != _linkMap.end())
        return it->second;
 
    return nullptr;
}
 
template <typename T>
void PropertyLinkMap<T>::copyValue(Core::Property* p)
{
    assert(p->getTypeId() == getTypeId() && "Wrong property type!");
    if (p->getTypeId() == getTypeId())
    {
        PropertyLinkMap<T>* other = (PropertyLinkMap<T>*)p;
        setValue(other->getValue());
    }
}
 
template <typename T>
void PropertyLinkMap<T>::deepCopy(Core::Property* p, Core::CoreDocument* dest_doc, DocObjectMap& copyMap)
{
    assert(p->getTypeId() == getTypeId() && "Wrong property type!");
    if (p->getTypeId() == getTypeId())
    {
        PropertyLinkMap<T>* source = (PropertyLinkMap<T>*)p;
 
        setEmpty();
        for (auto pairIt : source->getValue())
        {
            auto it = copyMap.find(pairIt.second);
            if (it != copyMap.end())
            {
                addLink(it->second);
            }
            else
            {
                Core::DocObject* dest_obj = dest_doc->copyObject(pairIt.second, copyMap);
                copyMap[pairIt.second] = dest_obj;
                addLink(dest_obj);
            }
        }
    }
}
 
template <typename T>
void PropertyLinkMap<T>::setEmpty()
{
    aboutToSetValue();
    for (auto pairIt : _linkMap)
    {
        if (pairIt.second)
            pairIt.second->unref();
        onRemoveLink(pairIt.second);
    }
 
    _linkMap.clear();
    hasSetValue();
}
 
template <typename T>
bool PropertyLinkMap<T>::hasKey(T key) const
{
    const auto it = _linkMap.find(key);
    return it != _linkMap.end();
}
 
template <typename T>
bool PropertyLinkMap<T>::hasLink(Core::DocObject* link) const
{
    // Traverse the map
    for (const auto& [key, value] : _linkMap)
        if (value == link)
            return true;
 
    return false;
}
 
template <typename T>
bool PropertyLinkMap<T>::addLink(T key, Core::DocObject* link)
{
    if (!link)
        return false;
 
    aboutToSetValue();
    link->ref();
    onAddLink(link);
    _linkMap.emplace(key, link);
    hasSetValue();
 
    return true;
}
 
template <typename T>
bool PropertyLinkMap<T>::removeLink(Core::DocObject* link)
{
    if (!link)
        return false;
 
    // Traverse the map
    for (const auto& [key, value] : _linkMap)
    {
        if (value == link)
        {
            aboutToSetValue();
            link->unref();
            onRemoveLink(link);
 
            _linkMap.erase(key);
            hasSetValue();
 
            return true;
        }
    }
 
    return false;
}
 
template <typename T>
std::vector<Core::DocObject*> PropertyLinkMap<T>::getLinks()
{
    std::vector<Core::DocObject*> links;
 
    for (auto pairIt : _linkMap)
    {
        links.push_back(pairIt.second);
    }
 
    return links;
}
 
template <typename T>
bool PropertyLinkMap<T>::isEmpty() const
{
    return _linkMap.empty();
}
 
template <typename T>
size_t PropertyLinkMap<T>::getSize() const
{
    return _linkMap.size();
}
 
template <typename T>
void PropertyLinkMap<T>::save(Base::AbstractWriter& writer, Base::PersistenceVersion& save_version)
{
    writer << "<Link size=\"" << _linkMap.size() << "\"/>";
 
    for (const auto& [key, value] : _linkMap)
    {
        if (value)
        {
            writer << "<Key value=\"" << key << "\"/>";
            writer << "<Link value=\"" << value->getId() << "\"/>";
        }
    }
}
 
template <typename T>
void PropertyLinkMap<T>::restore(Base::AbstractXMLReader& reader, Base::PersistenceVersion& version)
{
    _linkMap.clear();
    reader.readElement("Link");
    const int size = reader.getAttributeAsInteger(L"size");
 
    for (int i = 0; i < size; i++)
    {
        reader.readElement("Link");
 
        Base::String value = reader.getAttribute(L"value");
        std::string id = Base::StringTool::toQString(value).toUtf8().constData();
        if (id.empty())
        {
            // DG ????
            // onAddLink(0);
            //_linkList.push_back(0);
        }
        else
        {
            Core::DocObject* o = nullptr;
            if (Core::DocObject* container = Base::cast2<Core::DocObject>(getContainer()))
                o = (Core::DocObject*)container->getDocument()->getObjectById(id);
            else if (Core::CoreDocument* doc = Base::cast2<Core::CoreDocument>(getContainer()))
                o = (Core::DocObject*)doc->getObjectById(id);
 
            if (o)
            {
                reader.readElement("Key");
 
                o->ref();
                onAddLink(o);
                if (std::is_same<T, int>::value)
                    _linkMap.emplace(reader.getAttributeAsInteger(L"value"), o);
                else if (std::is_same<T, double>::value)
                    _linkMap.emplace(reader.getAttributeAsDouble(L"value"), o);
                else if (std::is_same<T, std::string>::value)
                    _linkMap.emplace(reader.getAttributeAsDouble(L"value"), o);
            }
            else
            {
                if (Core::DocObject* container = dynamic_cast<Core::DocObject*>(getContainer()))
                    cWarn("Core::PropertyLinkMap::restore (%s) Container (%s) (%s), Object %s not exists!", getName().c_str(),
                          container->getTypeId().getName().c_str(), container->getId().c_str(), id.c_str());
                else
                    cWarn("Core::PropertyLinkMap::restore (%s), Object %s not exists!", getName().c_str(), id.c_str());
            }
        }
    }
}
 
template <typename T>
const Core::PropertyKind PropertyLinkMap<T>::getPropertyKind() const
{
    return Core::P_MODIFY_LINK;
}
 
template <typename T>
bool PropertyLinkMap<T>::isEqual(const Property* o) const
{
    if (const PropertyLinkMap<T>* other = dynamic_cast<const PropertyLinkMap<T>*>(o))
        return _linkMap == other->_linkMap;
 
    return false;
}
 
template <typename T>
std::shared_ptr<Core::DbgInfo> PropertyLinkMap<T>::getDbgInfo() const
{
    QString s = QString("size: %1").arg(_linkMap.size());
 
    Base::String name = Base::StringTool::toString(getName());
    Base::String type = Base::StringTool::toString(getTypeId().getName());
    Base::String value = s.toStdWString();
    auto info = Core::DbgInfo::createDbgInfo<Core::DbgInfo>(name, value, type, nullptr);
    for (const auto& [key, link] : _linkMap)
    {
        s = QString("key: %1, val: %2").arg(key).arg(link ? link->getId().c_str() : "nullptr");
        value = s.toStdWString();
        name = Base::StringTool::toString(link ? link->getTypeId().getName() : "");
        type = Base::StringTool::toString(link ? link->getTypeId().getName() : "");
        auto m0 = Core::DbgInfo::createDbgInfo<Core::DbgInfoLink>(name, value, type, info);
        m0->object = link;
    }
 
    return info;
}
 
template <typename T>
Core::Property* PropertyLinkMap<T>::copy() const
{
    PropertyLinkMap<T>* p = new PropertyLinkMap<T>();
    p->setValue(_linkMap);
    return p;
}
 
template <typename T>
void PropertyLinkMap<T>::paste(const Core::Property& from)
{
    const PropertyLinkMap<T>& FromList = dynamic_cast<const PropertyLinkMap<T>&>(from);
    setValue(FromList._linkMap);
}
 
}  // namespace Core