duchainregister.h

Go to the documentation of this file.

/*
    SPDX-FileCopyrightText: 2008 David Nolden <[email protected]>
 
    SPDX-License-Identifier: LGPL-2.0-only
*/
 
#ifndef KDEVPLATFORM_DUCHAINREGISTER_H
#define KDEVPLATFORM_DUCHAINREGISTER_H
 
#include "duchainbase.h"
 
namespace KDevelop {
class DUChainBase;
class DUChainBaseData;
 
class KDEVPLATFORMLANGUAGE_EXPORT DUChainBaseFactory
{
public:
    virtual DUChainBase* create(DUChainBaseData* data) const = 0;
    virtual void callDestructor(DUChainBaseData* data) const = 0;
    virtual void freeDynamicData(DUChainBaseData* data) const = 0;
    virtual void deleteDynamicData(DUChainBaseData* data) const = 0;
    virtual void copy(const DUChainBaseData& from, DUChainBaseData& to, bool constant) const = 0;
    virtual DUChainBaseData* cloneData(const DUChainBaseData& data) const = 0;
    virtual uint dynamicSize(const DUChainBaseData& data) const = 0;
 
    virtual ~DUChainBaseFactory()
    {
    }
};
 
template <class T, class Data>
class DUChainItemFactory
    : public DUChainBaseFactory
{
public:
    DUChainBase* create(DUChainBaseData* data) const override
    {
        return new T(*static_cast<Data*>(data));
    }
 
    void copy(const DUChainBaseData& from, DUChainBaseData& to, bool constant) const override
    {
        Q_ASSERT(from.classId == T::Identity);
 
        bool& isConstant = DUChainBaseData::shouldCreateConstantData();
        const bool previousConstant = isConstant;
        if (previousConstant != constant) {
            isConstant = constant;
        }
 
        new (&to) Data(static_cast<const Data&>(from)); //Call the copy constructor to initialize the target
 
        if (previousConstant != constant) {
            isConstant = previousConstant;
        }
    }
 
    void callDestructor(DUChainBaseData* data) const override
    {
        Q_ASSERT(data->classId == T::Identity);
        static_cast<Data*>(data)->~Data();
    }
 
    void freeDynamicData(DUChainBaseData* data) const override
    {
        Q_ASSERT(data->classId == T::Identity);
        static_cast<Data*>(data)->freeDynamicData();
    }
 
    void deleteDynamicData(DUChainBaseData* data) const override
    {
        Q_ASSERT(data->classId == T::Identity);
        delete static_cast<Data*>(data);
    }
 
    uint dynamicSize(const DUChainBaseData& data) const override
    {
        Q_ASSERT(data.classId == T::Identity);
        return static_cast<const Data&>(data).dynamicSize();
    }
 
    DUChainBaseData* cloneData(const DUChainBaseData& data) const override
    {
        Q_ASSERT(data.classId == T::Identity);
        return new Data(static_cast<const Data&>(data));
    }
};
 
class KDEVPLATFORMLANGUAGE_EXPORT DUChainItemSystem
{
public:
    template <class T, class Data>
    void registerTypeClass()
    {
        if (m_factories.size() <= T::Identity) {
            m_factories.resize(T::Identity + 1);
            m_dataClassSizes.resize(T::Identity + 1);
        }
 
        Q_ASSERT_X(!m_factories[T::Identity], Q_FUNC_INFO, "This identity is already registered");
        m_factories[T::Identity] = new DUChainItemFactory<T, Data>();
        m_dataClassSizes[T::Identity] = sizeof(Data);
    }
 
    template <class T, class Data>
    void unregisterTypeClass()
    {
        Q_ASSERT(m_factories.size() > T::Identity);
        Q_ASSERT(m_factories[T::Identity]);
        delete m_factories[T::Identity];
        m_factories[T::Identity] = nullptr;
        m_dataClassSizes[T::Identity] = 0;
    }
 
    DUChainBase* create(DUChainBaseData* data) const;
 
    DUChainBaseData* cloneData(const DUChainBaseData& data) const;
 
    void copy(const DUChainBaseData& from, DUChainBaseData& to, bool constant) const;
 
    uint dynamicSize(const DUChainBaseData& data) const;
 
    uint dataClassSize(const DUChainBaseData& data) const;
 
    void callDestructor(DUChainBaseData* data) const;
 
    void freeDynamicData(DUChainBaseData* data) const;
 
    void deleteDynamicData(DUChainBaseData* data) const;
 
    static DUChainItemSystem& self();
 
private:
    Q_DISABLE_COPY(DUChainItemSystem)
    DUChainItemSystem() = default;
    ~DUChainItemSystem();
 
    QVector<DUChainBaseFactory*> m_factories;
    QVector<uint> m_dataClassSizes;
};
 
template <typename T>
struct DUChainType {};
 
#define DUCHAIN_DECLARE_TYPE(Type) \
    namespace KDevelop { \
    template <> struct DUChainType<Type> { \
        static void registerType(); \
        static void unregisterType(); \
    }; \
    }
#define DUCHAIN_DEFINE_TYPE_WITH_DATA(Type, Data) \
    void KDevelop::DUChainType<Type>::registerType() { DUChainItemSystem::self().registerTypeClass<Type, Data>(); } \
    void KDevelop::DUChainType<Type>::unregisterType() { DUChainItemSystem::self().unregisterTypeClass<Type, Data>(); }
#define DUCHAIN_DEFINE_TYPE(Type) \
    DUCHAIN_DEFINE_TYPE_WITH_DATA(Type, Type ## Data)
 
template <typename T>
void duchainRegisterType() { DUChainType<T>::registerType(); }
template <typename T>
void duchainUnregisterType() { DUChainType<T>::unregisterType(); }
 
template <class T, class Data>
struct DUChainItemRegistrator
{
    DUChainItemRegistrator()
    {
        DUChainItemSystem::self().registerTypeClass<T, Data>();
    }
    ~DUChainItemRegistrator()
    {
        DUChainItemSystem::self().unregisterTypeClass<T, Data>();
    }
private:
    Q_DISABLE_COPY(DUChainItemRegistrator)
};
 
#define REGISTER_DUCHAIN_ITEM(Class) KDevelop::DUChainItemRegistrator<Class, Class ## Data> register ## Class
#define REGISTER_DUCHAIN_ITEM_WITH_DATA(Class, Data) KDevelop::DUChainItemRegistrator<Class, Data> register ## Class
}
 
#endif