duchainregister.h

Go to the documentation of this file.

/* This file is part of KDevelop
    Copyright 2008 David Nolden <david.nolden.kdevelop@art-master.de>

   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License version 2 as published by the Free Software Foundation.

   This library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Library General Public License for more details.

   You should have received a copy of the GNU Library General Public License
   along with this library; see the file COPYING.LIB.  If not, write to
   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
   Boston, MA 02110-1301, USA.
 */

#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 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();
    }

    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;

    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