File indexing completed on 2024-06-23 04:34:45

 /*
     SPDX-FileCopyrightText: 2008 David Nolden <david.nolden.kdevelop@art-master.de>
 
     SPDX-License-Identifier: LGPL-2.0-only
 */
 
 #ifndef KDEVPLATFORM_TYPEREGISTER_H
 #define KDEVPLATFORM_TYPEREGISTER_H
 
 #include <QHash>
 
 #include "abstracttype.h"
 #include "typesystemdata.h"
 
 namespace KDevelop {
 /**
  * \short A factory class for type data.
  *
  * This class provides an interface for creating private data
  * structures for classes.
  */
 class KDEVPLATFORMLANGUAGE_EXPORT AbstractTypeFactory
 {
 public:
     /**
      * Create a new type for the given \a data.
      *
      * \param data Data to assign to the new type. The data type must match the class type.
      */
     virtual AbstractType* create(AbstractTypeData* data) const = 0;
 
     /**
      * Call the destructor of the data-type.
      */
     virtual void callDestructor(AbstractTypeData* data) const = 0;
 
     /**
      * Copy contents of type-data \a from one location \a to another.
      *
      * \param from data to copy from
      * \param to data to copy to. This data must not be initialized yet
      *           (the constructor must not have been called yet)
      * \param constant set to true if \a to is to be a static unchangeable
      *                 data type (eg. in the type-repository), or false if
      *                 \a to is to be a dynamic changeable type data.
      */
     virtual void copy(const AbstractTypeData& from, AbstractTypeData& to, bool constant) const = 0;
 
     /**
      * Return the memory size of the given private \a data, including dynamic data.
      *
      * \param data data structure
      * \returns the size in memory of the data.
      */
     virtual uint dynamicSize(const AbstractTypeData& data) const = 0;
 
     /// Destructor.
     virtual ~AbstractTypeFactory()
     {
     }
 };
 
 /**
  * Template class to implement factories for each AbstractType subclass you want
  * to instantiate.
  */
 template <class T, class Data = typename T::Data>
 class TypeFactory
     : public AbstractTypeFactory
 {
 public:
     AbstractType* create(AbstractTypeData* data) const override
     {
 /*    if(!m_reUseTypes.isEmpty()) {
       return new (m_reUseTypes.pop()) T(*static_cast<typename T::Data*>(data));
     }else{*/
         return new T(*static_cast<typename T::Data*>(data));
 //     }
     }
 
     void copy(const AbstractTypeData& from, AbstractTypeData& to, bool constant) const override
     {
         Q_ASSERT(from.typeClassId == T::Identity);
 
         if (( bool )from.m_dynamic == ( bool )!constant) {
             //We have a problem, "from" and "to" should both be either dynamic or constant. We must copy once more.
             Data* temp = &AbstractType::copyDataDirectly<Data>(static_cast<const Data&>(from));
 
             new (&to) Data(*temp); //Call the copy constructor to initialize the target
 
             Q_ASSERT(( bool )to.m_dynamic == ( bool )!constant);
             destroyData(temp);
         } else {
             new (&to) Data(static_cast<const Data&>(from)); //Call the copy constructor to initialize the target
         }
     }
 
     void destroyData(AbstractTypeData* data) const
     {
         callDestructor(data);
         delete[] ( char* )data;
     }
 
     void callDestructor(AbstractTypeData* data) const override
     {
         Q_ASSERT(data->typeClassId == T::Identity);
         static_cast<Data*>(data)->~Data();
     }
 
     uint dynamicSize(const AbstractTypeData& data) const override
     {
         Q_ASSERT(data.typeClassId == T::Identity);
         return static_cast<const Data&>(data).dynamicSize();
     }
 };
 
 /**
  * \short A class which registers data types and creates factories for them.
  *
  * TypeSystem is a global static class which allows you to register new
  * AbstractType subclasses for creation.
  */
 class KDEVPLATFORMLANGUAGE_EXPORT TypeSystem
 {
     Q_DISABLE_COPY_MOVE(TypeSystem)
     TypeSystem() = default;
 public:
     /**
      * Register a new AbstractType subclass.
      */
     template <class T, class Data = typename T::Data>
     void registerTypeClass()
     {
         registerTypeClassInternal(new TypeFactory<T, Data>(), sizeof(Data), T::Identity);
     }
 
     /**
      * Unregister an AbstractType subclass.
      */
     template <class T, class Data = typename T::Data>
     void unregisterTypeClass()
     {
         unregisterTypeClassInternal(T::Identity);
     }
 
     /**
      * Create an AbstractType for the given data. The returned type must be put into a AbstractType::Ptr immediately.
      * Can return null if no type-factory is available for the given data (for example when a language-part is not loaded)
      */
     AbstractType* create(AbstractTypeData* data) const;
 
     /**
      * This just calls the correct constructor on the target. The target must be big enough to hold all the data.
      */
     void copy(const AbstractTypeData& from, AbstractTypeData& to, bool constant) const;
 
     ///Calls the dynamicSize(..) member on the given data, in the most special class. Since we cannot use virtual functions, this is the only way.
     uint dynamicSize(const AbstractTypeData& data) const;
 
     ///Returns the size of the derived class, not including dynamic data.
     ///Returns zero if the class is not known.
     uint dataClassSize(const AbstractTypeData& data) const;
 
     ///Calls the destructor, but does not delete anything. This is needed because the data classes must not contain virtual members.
     void callDestructor(AbstractTypeData* data) const;
 
     ///Returns true if the factory for this data type is loaded.
     ///If false is returned, then any of the other calls will fail.
     bool isFactoryLoaded(const AbstractTypeData& data) const;
 
     /// Access the static TypeSystem instance.
     static TypeSystem& self();
 
 private:
     void registerTypeClassInternal(AbstractTypeFactory* repo, uint dataClassSize, uint identity);
     void unregisterTypeClassInternal(uint identity);
 
     bool ensureFactoryLoaded(const AbstractTypeData& data) const;
 
     QHash<uint, AbstractTypeFactory*> m_factories;
     QHash<uint, uint> m_dataClassSizes;
 };
 
 /// Helper class to register an AbstractType subclass.
 ///
 /// Just use the REGISTER_TYPE(YourTypeClass) macro in your code, and you're done.
 template <class T, class Data = typename T::Data>
 struct TypeSystemRegistrator
 {
     TypeSystemRegistrator()
     {
         TypeSystem::self().registerTypeClass<T, Data>();
     }
     ~TypeSystemRegistrator()
     {
         TypeSystem::self().unregisterTypeClass<T, Data>();
     }
 private:
     Q_DISABLE_COPY(TypeSystemRegistrator)
 };
 
 ///You must add this into your source-files for every AbstractType based class
 ///For this to work, the class must have an "Identity" enumerator, that is unique among all types.
 ///It should be a unique value, but as small as possible, because a buffer at least as big as that number is created internally.
 #define REGISTER_TYPE(Class) TypeSystemRegistrator<Class, Class ## Data> register ## Class
 }
 
 #endif