TYElement.h

Go to the documentation of this file.

/*
 * Copyright (C) <2012-2014> <EDF-R&D> <FRANCE>
 * This program 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 2 of the License, or
 * (at your option) any later version.
 * This program 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 this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/

#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/widgets/TYElementWidget.h"
  #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; }

    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);

    bool getIsGeometryModified() { return _isGeometryModified; }



    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;

    bool _isGeometryModified;

    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__