TYElement.h

Go to the documentation of this file.

/*
 * Copyright (C) <2012-2024> <EDF-DTG> <FRANCE>
 * This file is part of Code_TYMPAN (R).
 * Code_TYMPAN (R) is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 * Code_TYMPAN (R) 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 General Public License for more details.
 * You should have received a copy of the GNU General Public License along
 * with Code_TYMPAN (R). If not, see <https://www.gnu.org/licenses/>.
 */
 
#ifndef __TY_ELEMENT__
#define __TY_ELEMENT__
 
#ifdef HAVE_CONFIG_H
    #include "config.h"
#endif // HAVE_CONFIG_H
 
#if _MSC_VER > 1000
    #pragma once
#endif // _MSC_VER > 1000
#ifdef _MSC_VER
    #pragma warning(disable : 4275 4800 4355 4273 4786 4018 4503 4081)
#endif
 
#include <memory>
#include <unordered_map>
#include <iostream>
 
#include <boost/exception/error_info.hpp>
 
#ifndef _NDEBUG
    #include <QDebug>
#endif // _NDEBUG
 
#include "Tympan/core/defines.h"
#include "Tympan/core/macros.h"
#include "Tympan/core/idgen.h"
#include "Tympan/models/business/TYNameManager.h"
#if TY_USE_IHM
    #include "Tympan/gui/gl/TYElementGraphic.h"
#endif // TY_USE_IHM
#include "TYDefines.h"
#include "TYXMLTools.h"
 
// Nom de la categorie pour la sauvegarde des preferences.
#define TYDIRPREFERENCEMANAGER "UserPreferences"
 
// Definition de macros pour la creation de nouveaux types
// derives de OPrototype.
 
#define OPROTODECL(classname)                                                                                \
public:                                                                                                      \
    virtual OPrototype* clone() const                                                                        \
    {                                                                                                        \
        return new classname();                                                                              \
    }                                                                                                        \
    virtual const char* getClassName() const                                                                 \
    {                                                                                                        \
        return #classname;                                                                                   \
    }                                                                                                        \
    static classname* safeDownCast(OPrototype* pObject)                                                      \
    {                                                                                                        \
        if (pObject)                                                                                         \
        {                                                                                                    \
            classname* pTypedObject = dynamic_cast<classname*>(pObject);                                     \
            if (pTypedObject != nullptr)                                                                     \
            {                                                                                                \
                return pTypedObject;                                                                         \
            }                                                                                                \
        }                                                                                                    \
        return nullptr;                                                                                      \
    }
 
 
namespace tympan
{
typedef boost::error_info<struct tag_classname, std::string> oproto_classname_errinfo;
} // namespace tympan
 
class OPrototype
{
    // Methodes
public:
    virtual ~OPrototype();
 
    static OPrototype* findAndClone(const char* className);
 
    static int findPrototype(const char* className);
 
    virtual OPrototype* clone() const = 0;
 
    virtual const char* getClassName() const
    {
        return "OPrototype";
    }
 
    bool isA(const char* className) const;
 
    static OPrototype* safeDownCast(OPrototype* pObject);
 
    class IOProtoFactory
    {
    public:
        typedef std::unique_ptr<IOProtoFactory> ptr_type;
        virtual std::unique_ptr<OPrototype> make() = 0;
    };
 
    template <typename T> class Factory : public IOProtoFactory
    {
    public:
        typedef std::unique_ptr<T> ptr_type;
 
        static_assert(std::is_base_of<OPrototype, T>::value, "Factory<T> : T must inherit from OPrototype");
 
        ptr_type typed_make()
        {
            return ptr_type(new T());
        }
        virtual std::unique_ptr<OPrototype> make()
        {
            return typed_make();
        }
    };
 
    static void add_factory(const char*, IOProtoFactory::ptr_type factory);
 
protected:
    OPrototype();
 
    // Membres
private:
    static std::unordered_map<std::string, IOProtoFactory::ptr_type> _factory_map;
};
 
template <typename T> std::unique_ptr<OPrototype::Factory<T>> build_factory()
{
    return std::unique_ptr<OPrototype::Factory<T>>(new OPrototype::Factory<T>());
}
 
typedef std::vector<LPTYElement> LPTYElementArray;
 
typedef std::map<TYUUID, TYElement*> TYElementContainer;
 
#if TY_USE_IHM
 
    #if defined(WIN32)
        #define TY_EXTENSION_DECL(classname)                                                                 \
            friend class classname;                                                                          \
                                                                                                             \
        public:                                                                                              \
            virtual TYEditWidget* getEditWidget()                                                            \
            {                                                                                                \
                return new classname##Widget(this);                                                          \
            }
    #else
        #define TY_EXTENSION_DECL(classname)                                                                 \
        public:                                                                                              \
            virtual TYEditWidget* getEditWidget()                                                            \
            {                                                                                                \
                return new classname##Widget(this);                                                          \
            }
    #endif
 
    #define TY_EXTENSION_DECL_ONLY(classname)                                                                \
    public:                                                                                                  \
        virtual TYEditWidget* getEditWidget();
 
    #define TY_EXTENSION_INST(classname)                                                                     \
        TYEditWidget* classname::getEditWidget()                                                             \
        {                                                                                                    \
            return new classname##Widget(this);                                                              \
        }
 
#else // TY_USE_IHM
 
    #define TY_EXTENSION_DECL(classname)
    #define TY_EXTENSION_DECL_ONLY(classname)
    #define TY_EXTENSION_INST(classname)
#endif // TY_USE_IHM
 
#if TY_USE_IHM
 
    #if defined(WIN32)
        #define TY_EXT_GRAPHIC_DECL(classname)                                                               \
            friend class classname;                                                                          \
                                                                                                             \
        public:                                                                                              \
            virtual LPTYElementGraphic getGraphicObject()                                                    \
            {                                                                                                \
                if (!_pGraphicObject)                                                                        \
                    _pGraphicObject = new classname##Graphic(this);                                          \
                return _pGraphicObject;                                                                      \
            }
    #else
        #define TY_EXT_GRAPHIC_DECL(classname)                                                               \
        public:                                                                                              \
            virtual LPTYElementGraphic getGraphicObject()                                                    \
            {                                                                                                \
                if (!_pGraphicObject)                                                                        \
                    _pGraphicObject = new classname##Graphic(this);                                          \
                return _pGraphicObject;                                                                      \
            }
    #endif
 
    #define TY_EXT_GRAPHIC_DECL_ONLY(classname)                                                              \
    public:                                                                                                  \
        virtual LPTYElementGraphic getGraphicObject();
 
    #define TY_EXT_GRAPHIC_INST(classname)                                                                   \
        LPTYElementGraphic classname::getGraphicObject()                                                     \
        {                                                                                                    \
            if (!_pGraphicObject)                                                                            \
                _pGraphicObject = new classname##Graphic(this);                                              \
            return _pGraphicObject;                                                                          \
        }
#else
 
    #define TY_EXT_GRAPHIC_DECL(classname)
    #define TY_EXT_GRAPHIC_DECL_ONLY(classname)
    #define TY_EXT_GRAPHIC_INST(classname)
typedef void* LPTYElementGraphic;
#endif // TY_USE_IHM
 
typedef class OGenID TYUUID;
 
template <typename T> T* downcast(TYElement* elt)
{
    return T::safeDownCast(elt);
}
 
class TYElement : public IRefCount, public OPrototype
{
    OPROTODECL(TYElement)
 
    // Methodes
public:
    TYElement();
 
    TYElement(TYElement* pParent, bool PutInInstanceList = true);
 
    TYElement(const TYElement& other, bool PutInInstanceList = true);
 
    virtual ~TYElement();
 
 
 
    virtual DOM_Element toXML(DOM_Element& domElement) /* const */;
    virtual int fromXML(DOM_Element domElement);
 
 
 
    virtual void updateCurrentCalcul(TYListID& listID, bool recursif = true);
 
    virtual void getChilds(LPTYElementArray& childs, bool recursif = true) {}
 
    virtual void setInCurrentCalcul(bool state, bool recurschild = true, bool recursparent = true);
    virtual bool isInCurrentCalcul()
    {
        return _inCurrentCalcul;
    }
 
    void addCopy()
    {
        _copyCount++;
    }
 
    void setCopyCount(const unsigned int copyCount)
    {
        _copyCount = copyCount;
    }
 
private:
    void OnChildInCalculStatusChange();
 
 
public:
#if TY_USE_IHM
 
 
    virtual LPTYElementGraphic getGraphicObject()
    {
        return NULL;
    }
 
    virtual LPTYElementGraphic getGraphicObject() const
    {
        return NULL;
    }
    void drawGraphic(bool draw = true);
 
    virtual void updateGraphic();
 
    virtual void updateGraphicTree();
 
 
 
    virtual TYEditWidget* getEditWidget();
 
    int edit(TYEditWidget* pParent = NULL);
 
#endif
 
 
    void setID(TYUUID id);
    void setID(const QString& str_id);
 
    const TYUUID& getID() const;
    QString getStringID() const
    {
        return getID().toString();
    }
 
    bool hasNullID() const
    {
        return _uuid.isNull();
    }
 
    void regenerateID();
 
    void setName(QString name)
    {
        _name = name;
    }
 
    void setName(std::string name)
    {
        _name = QString::fromStdString(name);
    }
 
    virtual QString getName() const
    {
        return _name;
    }
 
    void setParent(TYElement* pParent)
    {
        _pParent = pParent;
    }
    TYElement* getParent() const
    {
        return _pParent;
    }
 
 
 
    virtual void setIsAcousticModified(bool isModified);
    bool getIsAcousticModified()
    {
        return _isAcousticModified;
    }
 
    virtual void setIsGeometryModified(bool isModified);
 
 
 
    TYElement& operator=(const TYElement& other);
 
    bool operator==(const TYElement& other) const;
 
    bool operator!=(const TYElement& other) const;
 
    virtual bool deepCopy(const TYElement* pOther, bool copyId = true, bool pUseCopyTag = false);
 
 
 
    virtual std::string toString() const
    {
        return "TYElement";
    };
 
    bool callFromXMLIfEqual(DOM_Element& domElement, int* pRetVal = NULL);
 
    std::string getMetierName();
 
 
    static LPTYElementArray findTypeCollectionAndCallFromXML(DOM_Element parentElem, const char* type);
 
    static void setLogInstances(bool log)
    {
        _logInstances = log;
    }
    static bool getLogInstances()
    {
        return _logInstances;
    }
 
    static TYElement* getInstance(TYUUID uuid);
 
    static void purgeInstances();
 
    static bool testId(const TYUUID& id, const TYElement* pElem);
 
    static TYUUID newID();
 
    static TYUUID fromString(QString id);
 
    static QString toString(TYUUID& uuid);
 
    static uint64 getConstructorCount();
 
    static uint64 getDestructorCount();
 
    static uint64 getIdGenerationCount();
 
    static bool getIsSavedOk()
    {
        return _toSave;
    }
 
    static void setIsSavedOk(const bool& toSave)
    {
        _toSave = toSave;
    }
 
    static void setRegenerateID(const bool& bRegenerate)
    {
        _bRegenerateID = bRegenerate;
    }
    static bool getRegenerateID()
    {
        return _bRegenerateID;
    }
 
    void* getAllUses()
    {
        return _allUses;
    }
    void setAllUses(void* allUses)
    {
        _allUses = allUses;
    }
    void cleanAllUses()
    {
        free(_allUses);
        _allUses = nullptr;
    }
 
private:
    void addInstance();
 
    void remInstance();
 
    // Membres
private:
    mutable TYUUID _uuid;
 
protected:
    QString _name;
 
    TYElement* _pParent;
 
    // Pour eviter de grossir la liste d'instance avec des objets temporaires:
    bool _bPutInInstanceList;
 
    // Decompte du nombre de copies
    unsigned int _copyCount;
 
    bool _inCurrentCalcul;
 
    bool _isAcousticModified;
 
    LPTYElementGraphic _pGraphicObject;
 
    void* _allUses;
 
private:
    static bool _logInstances;
    // XXX This should be a map (of weak pointers) not a list !
    static TYElementContainer* _instances;
    static TYElementContainer& getInstances();
    static bool _toSave;
    static bool _bRegenerateID;
 
    static uint64 ty_created_counter;
    static uint64 ty_destroyed_counter;
    static uint64 ty_regen_id_counter;
};
 
// Some simple auxilliary fonction to help debugging and reporting
 
inline const char* str_qt2c(const QString& qstr)
{
    return qstr.toLocal8Bit().data();
} // TODO Clarifiy consistency wrt Local8Bit vs Utf8
 
inline QString xml2qstring(const QDomNode& node)
{
    QString msg;
    QTextStream str(&msg);
    node.save(str, 0);
    return msg;
}
 
inline const char* xml2cstring(const QDomNode& node)
{
    return str_qt2c(xml2qstring(node));
}
 
#ifndef _NDEBUG
inline QDebug _debugXml(const char* expr, const QDomNode& node)
{
    return qDebug() << expr << xml2qstring((node));
}
 
    #define debugXml(expr) _debugXml(#expr, (expr))
#else // _NDEBUG
    #define debugXml(expr) ((void)0)
#endif // _NDEBUG
 
#endif // __TY_ELEMENT__