PropertyBackLink.h

Go to the documentation of this file.

#pragma once

#include <Core/Property.h>
#include <Core/Variant.h>
#include <Core/core_defines2.h>

#include <list>

namespace Core
{
template <typename T>
struct TypeNameBack
{
    static const char* Get() { return typeid(T).name(); }
};

//----------------------------------------------------------------------------
// PropertyBackLinkBase
//----------------------------------------------------------------------------

class CORE_EXPORT PropertyBackLinkBase : public Core::Property
{
    TYPESYSTEM_HEADER();

public:
    PropertyBackLinkBase(void);
    virtual ~PropertyBackLinkBase(void);

    void setValue(Core::DocObject* o);
    bool setValueFromVariant(const Core::Variant& value) override;
    void copyValue(Core::Property* p) override;

    Core::DocObject* getValue() const;
    Core::Variant getVariant(void) const;

    void save(Base::AbstractWriter& writer, Base::PersistanceVersion& save_version) override;
    inline void restore(Base::AbstractXMLReader& reader, Base::PersistanceVersion& version) override;
    bool isEqual(const Property*) const override;
    std::shared_ptr<Core::DbgInfo> getDbgInfo() const override;
    virtual const Core::PropertyKind getPropertyKind(void) const override;

protected:
    Core::DocObject* _link;
};

//----------------------------------------------------------------------------
// PropertyBackLink<T>
//----------------------------------------------------------------------------

template <typename T>
class PropertyBackLink : public PropertyBackLinkBase
{
    TYPESYSTEM_PROPERTY_HEADER(PropertyBackLink, Core::PropertyBackLinkBase);
    typedef PropertyBackLinkBase inherited;

public:
    void setValue(T o) { inherited::setValue(o); }
    T getValue() const { return static_cast<T>(inherited::getValue()); }
};

#ifndef SWIG
template <typename T>
Base::Type PropertyBackLink<T>::classTypeId = Base::Type().createType(Base::Type::badType(), TypeNameBack<PropertyBackLink<T>>::Get());
#endif

//----------------------------------------------------------------------------
// PropertyBackLinkSetBase
//----------------------------------------------------------------------------

class CORE_EXPORT PropertyBackLinkSetBase : public Core::Property
{
    TYPESYSTEM_HEADER();

public:
    PropertyBackLinkSetBase();
    ~PropertyBackLinkSetBase();

    void setValue(const boost::unordered_set<Core::DocObject*>& linkset);
    bool setValueFromVariant(const Core::Variant& value);
    void copyValue(Core::Property* p);
    const boost::unordered_set<Core::DocObject*>& getValue() const;

    bool addLink(Core::DocObject* o);
    void addLinks(const boost::unordered_set<Core::DocObject*>& linkset);
    bool removeLink(Core::DocObject* o);
    void setEmpty();
    bool hasLink(Core::DocObject* o) const;
    bool isEmpty() const;
    size_t getSize() const;

    Core::Variant getVariant(void) const;

    void save(Base::AbstractWriter& writer, Base::PersistanceVersion& save_version) override;
    inline void restore(Base::AbstractXMLReader& reader, Base::PersistanceVersion& version) override;
    bool isEqual(const Property*) const override;
    std::shared_ptr<Core::DbgInfo> getDbgInfo() const override;
    virtual const Core::PropertyKind getPropertyKind(void) const override;

protected:
    boost::unordered_set<Core::DocObject*> _linkSet;
};

//----------------------------------------------------------------------------
// PropertyBackLinkSet<T>
//----------------------------------------------------------------------------

template <typename T>
class PropertyBackLinkSet : public PropertyBackLinkSetBase
{
    TYPESYSTEM_PROPERTY_HEADER(PropertyBackLinkSet, Core::PropertyBackLinkSetBase);
    typedef PropertyBackLinkSetBase inherited;

public:
    void setValue(const boost::unordered_set<T>& linkset) { inherited::setValue(*(const boost::unordered_set<Core::DocObject*>*)(&linkset)); };
    const boost::unordered_set<T>& getValue() const { return *(const boost::unordered_set<T>*)(&_linkSet); }

    bool addLink(T link) { return inherited::addLink(link); }
    bool removeLink(T link) { return inherited::removeLink(link); };

    void addLinks(const boost::unordered_set<T>& linkset) { inherited::addLinks(*(const boost::unordered_set<Core::DocObject*>*)(&linkset)); }
};

#ifndef SWIG
template <typename T>
Base::Type PropertyBackLinkSet<T>::classTypeId = Base::Type().createType(Base::Type::badType(), TypeNameBack<PropertyBackLinkSet<T>>::Get());
#endif

DECLARE_PROPERTY_FACTORY(PropertyBackLinkBase_Factory, Core::PropertyBackLinkBase);
DECLARE_PROPERTY_FACTORY(PropertyBackLinkSetBase_Factory, Core::PropertyBackLinkSetBase);

}  // namespace Core