CoreDocument.h

Go to the documentation of this file.

#pragma once
#pragma warning(disable : 4251)

#include <Base/GlobalAttachment.h>
#include <Base/Observer.h>
#include <Core/DocObject.h>
#include <Core/PropertyBundle.h>
#include <Core/PropertyContainer.h>
#include <Core/PropertyInteger.h>
#include <Core/PropertyLink.h>
#include <Core/PropertyText.h>
#include <Core/PythonScriptObject.h>
#include <Core/core_defines2.h>

#include <QDateTime>
#include <boost/unordered_map.hpp>
#include <boost/unordered_set.hpp>
#include <map>
#include <set>
#include <vector>

#define DIR_NAME_INTERNAL_CATALOG "__internalCatalog__"
#define DIR_NAME_WEBGL_GT "webgl"
#define DIR_NAME_GEOID "geoid"
#define FILE_NAME_CAMERA_ANIMATION "CameraAnimation.ivc"

typedef std::vector<Core::DocObject*> DOCOBJECTS;
typedef std::map<Core::DocObject*, std::vector<std::string>> DOCOBJECTS_ERROR_MAP;

namespace zipios
{
class ZipInputStream;
}

namespace App
{
class ElementTool;
}

namespace Core
{
class Variant;
class ObjectGraph;
class DocObject;
class ExecObject;
class PropertyLinkBase;
class CoreDocumentImpl;
class PropertyGUID;
class DocumentTimeStampSentinel;

typedef std::vector<Core::DocObject*> ObjectVector;
typedef boost::unordered_set<Core::DocObject*> ObjectSet;
typedef boost::unordered_map<DocObject::IdType, Core::DocObject*> ObjectMap;
typedef std::vector<Core::ExecObject*> ExecObjectVector;
typedef boost::unordered_set<Core::ExecObject*> ExecObjectSet;
typedef boost::unordered_map<DocObject::IdType, Core::ExecObject*> ExecObjectMap;
typedef std::map<Base::Type, ObjectSet> ObjectTypeMap;

struct AttachmentEntry
{
    Base::String FileName;
    Base::String FeatName;
};
typedef std::multimap<Base::String, Core::AttachmentEntry> Attachments;

/*
Core::DocChanges
This class notifies the observers about a recompute of the document.
It can also be used to send messages to the Observers:
1. Example:

Core::ExecObject* o = ...

Core::DocChanges docChanges;
docChanges.Why      = Core::DocChanges::MESSAGE_BY_NAME
docChanges.MsgName  = "MsgObjectAdded";
docChanges.Value    = Core::Variant(o);
notify(docChandes);

2. Example:

enum DocMessage
{
    MSG_OBJECT_ADDED = 1,
    ...
}

Core::ExecObject* o = ...

Core::DocChanges docChanges;
docChanges.Why      = Core::DocChanges::MESSAGE_BY_ID
docChanges.MsgId    = DocMessage::MSG_OBJECT_ADDED;
docChanges.Value    = Core::Variant(o);
notify(docChandes);
*/

class CORE_EXPORT DocChanges
{
public:
    DocChanges(Core::CoreDocument* doc) : Value(0), Document(doc) {}

    enum why
    {
        RECOMPUTED,
        MESSAGE_BY_NAME,
        MESSAGE_BY_ID
    } Why = RECOMPUTED;

    std::string MsgName = "";
    int MsgId = -1;
    Core::Variant Value;
    Core::CoreDocument* Document;

    std::vector<Core::DocObject*> NewObjects;
    std::vector<Core::DocObject*> UpdatedObjects;
    std::vector<Core::DocObject*> DeletedObjects;
    std::map<Core::DocObject*, std::vector<std::string>> ErroneousObjects;  // Objects that caused an error in recompute with its error messages

private:
    DocChanges() : MsgId(0), Document(nullptr){};
};

// All Lexocad Core message Ids are in the range 1000 - 1999
const int LEXOCAD_CORE_MSGID = 1000;

enum CORE_EXPORT DocMessage
{
    RecomputeError = LEXOCAD_CORE_MSGID,
    Rename = LEXOCAD_CORE_MSGID + 1,
    NewFile = LEXOCAD_CORE_MSGID + 2,
    FileOpened = LEXOCAD_CORE_MSGID + 3,
    BeforeSave = LEXOCAD_CORE_MSGID + 4,
    AfterSave = LEXOCAD_CORE_MSGID + 5,
    CleanAll = LEXOCAD_CORE_MSGID + 6,
    AddDirectoryPath = LEXOCAD_CORE_MSGID + 7,
    RecomputeFinished = LEXOCAD_CORE_MSGID + 8,
    ErrorCanNotOpenFile = LEXOCAD_CORE_MSGID + 9,
    ChangeToDefaultUser = LEXOCAD_CORE_MSGID + 10,
    GUID_Conflict = LEXOCAD_CORE_MSGID + 11,
    Export = LEXOCAD_CORE_MSGID + 12,
    Import = LEXOCAD_CORE_MSGID + 13,
    SaveStart = LEXOCAD_CORE_MSGID + 14,
    Closing = LEXOCAD_CORE_MSGID + 15,
    PriceCalculationChanged = LEXOCAD_CORE_MSGID + 16,
    PostCheck = LEXOCAD_CORE_MSGID + 17
};



struct CORE_EXPORT DocumentState
{
    // Copy constructor
    DocumentState() = default;
    DocumentState(const DocumentState& rhs)
    {
        PropertyErrors = rhs.PropertyErrors;
        LastErroneousObjects = rhs.LastErroneousObjects;
        LastRecomputeTime = rhs.LastRecomputeTime;
        LastNotifyTime = rhs.LastNotifyTime;
    }

    std::vector<std::string> PropertyErrors;
    std::map<Core::DocObject*, std::vector<std::string>> LastErroneousObjects;
    unsigned long LastRecomputeTime;
    unsigned long LastNotifyTime;

    void clear();
};

struct CORE_EXPORT PropertyLinkDesc
{
    PropertyLinkDesc(std::string sourceDocObjectID, std::string sourcePropertyName, Base::Type sourcePropertyTypeID, std::string targetDocObjectID)
        : m_SourceDocObjectID(sourceDocObjectID)
        , m_SourcePropertyName(sourcePropertyName)
        , m_SourcePropertyTypeID(sourcePropertyTypeID)
        , m_TargetDocObjectID(m_TargetDocObjectID)
    {
    }

    // Copy constructor
    PropertyLinkDesc(const PropertyLinkDesc& rhs)
    {
        m_SourceDocObjectID = rhs.m_SourceDocObjectID;
        m_SourcePropertyName = rhs.m_SourcePropertyName;
        m_SourcePropertyTypeID = rhs.m_SourcePropertyTypeID;
        m_TargetDocObjectID = rhs.m_TargetDocObjectID;
    }

    std::string m_SourceDocObjectID;
    std::string m_SourcePropertyName;
    Base::Type m_SourcePropertyTypeID;

    std::string m_TargetDocObjectID;
};


class CORE_EXPORT CoreDocument : public Core::PropertyContainer, public Base::Subject<Core::DocChanges>
{
    TYPESYSTEM_HEADER();
    LX_NODE_HEADER();

public:
    friend class CoreApplication;
    friend class CoreDocument_Factory;
    friend class ::App::ElementTool;
    friend class PropertyGUID;
    friend class DocumentTimeStampSentinel;

    //                                                       //
    // --------------------- BEGIN API --------------------- //
    //                                                       //
    // ATTENTION: DO NOT CHANGE ANY SIGNATURES IN THE API !  //
    //                                                       //

    Core::PropertyText name;
    Core::PropertyText documentVersion;
    Core::PropertyText compatibleInfo;
    Core::PropertyText documentGUID;
    Core::PropertyIndex documentChanges;
    Core::PropertyIndex documentMaxID;
    Core::PropertyIndex application_mainversion;
    Core::PropertyText documentTypeName;
    Core::PropertyText filename;
    Core::PropertyText createdBy;     // designer
    Core::PropertyText creationDate;  // date
    Core::PropertyText lastModifiedBy;
    Core::PropertyText lastModifiedDate;
    Core::PropertyText company;  // customer
    Core::PropertyText comment;
    Core::PropertyText projectNumber;  // related to PieceList
    Core::PropertyText architect;

    Base::String fileName;

    int getDocumentVersion() const;
    bool addObject(Core::DocObject* e);
    void removeObject(Core::DocObject* e);
    void removeObjectFinal(Core::DocObject* e, bool deep = false);

    Base::Type getCopyType() const;
    void clearCopyType();
    Core::DocObject* copyObject(Core::DocObject* o, DocObjectMap& copyMap = DocObjectMap());
    Core::DocObject* copyToDifferentType(Core::DocObject* o, Base::Type typeToCreate, DocObjectMap& copyMap);
    Core::DocObject* copySharedObject(Core::DocObject* o, DocObjectMap& copyMap);
    template <typename Type>
    Type copyObjectShallow(Type o)
    {
        Core::DocObject* copy = o->shallowCopy(this);
        assert(copy && "Document::copyObjectShallow could not copy object");
        copy->setDocument(this);
        copy->setNew();
        copy->initDocObject();

        Type typedCopy = dynamic_cast<Type>(copy);
        assert(typedCopy && "Document::copyObjectShallow could not cast object");

        return typedCopy;
    }

    std::vector<Core::DocObject*> getObjects(bool includeDeletedObjects = false) const;
    std::vector<Core::DocObject*> getObjectsSorted() const;
    std::vector<Core::ExecObject*> getExecObjects(bool includeDeletedObjects = false) const;
    Core::DocObject* createObjectFromTypeName(const char* typeName);
    Core::DocObject* createObjectFromType(Base::Type type);
    std::vector<Core::DocObject*> getObjectsByTypeName(const std::string& typeName) const;
    virtual void recompute();
    virtual void recompute(
        std::function<void(DOCOBJECTS newObj, DOCOBJECTS updatedObj, DOCOBJECTS deletedObj, DOCOBJECTS_ERROR_MAP errorObj)> onRecomputedCB);
    virtual bool saveAs(const Base::String& filename);
    Base::String getTmpDirectory();
    bool isActive() const;
    virtual bool isChanged();
    Core::DocObject* getObjectByGlobalId(const Base::GlobalId& guid) const;

    std::string getDocXMLAsString();

#ifndef LXAPI
    virtual Core::DocObject* getObjectById(const DocObject::IdType& id) const;
    Core::DocObject* getObjectByUserName(const Base::String& s) const;



    //                                                       //
    // ---------------------- END API ---------------------- //
    //                                                       //

    template <typename T>
    T* createObject()
    {
        Core::DocObject* o = createObjectFromType(T::getClassTypeId());
        if (o)
            return static_cast<T*>(o);

        return nullptr;
    }

    template <typename T>
    T* addImmutableObject(Core::PropertyBundle<T>* po)
    {
        // Check if it really is immutable
        if (T::isMutableStatic())
            return nullptr;

        // Check if an immutable object with these values already exists
        Core::DocObject* check = getImmutableObjectWithSameValues(T::getClassTypeId(), po);
        if (check)
            return static_cast<T*>(check);

        // If it doesn't exist make a new one and initialize it with the
        // property values from the Core::PropertyBundle.
        Core::DocObject* o = createObjectFromType(T::getClassTypeId());
        if (o)
        {
            o->_setPropertyValues(po, /* bool isInit = */ true);
            o->setStatus(Core::PropertyContainer::Status::New);  // At initialization the status needs to stay NEW
            addImmutableObjectMaterial(o);
            return static_cast<T*>(o);
        }

        return nullptr;
    }

    template <typename T>
    T* addImmutableObject_NoCheck(Core::PropertyBundle<T>* po)
    {
        // Check if it really is immutable
        if (T::isMutableStatic())
            return nullptr;

        // If it doesn't exist make a new one and initialize it with the
        // property values from the Core::PropertyBundle.
        Core::DocObject* o = createObjectFromType(T::getClassTypeId());
        if (o)
        {
            o->_setPropertyValues(po, /* bool isInit = */ true);
            o->setStatus(Core::PropertyContainer::Status::New);  // At initialization the status needs to stay NEW
            addImmutableObjectMaterial(o);
            return static_cast<T*>(o);
        }

        return nullptr;
    }

    template <typename T>
    std::vector<T*> getObjectsByType() const
    {
        // get all resulting types including derived classes
        Base::Type t = T::getClassTypeId();
        std::set<Base::Type> typeset;
        t.getAllChildren(typeset);
        typeset.insert(t);

        std::vector<T*> returnObjs{};
        for (const auto& type : typeset)
        {
            auto type2objects = getTypeMap().find(type);
            if (type2objects == getTypeMap().end())  // do we know this type?
                continue;

            const auto& docObjects = type2objects->second;
            for (const auto& obj : docObjects)  // get un-deleted objects of given type
            {
                if (!obj->isDeleted())
                    returnObjs.push_back(static_cast<T*>(obj));
            }
        }

        return returnObjs;
    }

    template <typename T>
    void getObjectsByType(std::vector<T*>& objs) const
    {
        const auto& objectMap = getObjectMap();
        for (const auto& it : objectMap)  //#todo go only over seconds
        {
            if (!it.second->isDeleted() && it.second->isDerivedFrom<T>())  // #todo why test for type when the type is in first?
                objs.push_back((T*)it.second);
        }
    }

    void getObjectsFromTypeMap(Base::Type t, std::vector<Core::DocObject*>& ret) const;
    const ObjectTypeMap& getTypeMap() const;

    void addPropertyLinkError(const std::string& from, const std::string& to);
    const DocumentState& getDocumentState() const;
    bool checkObjectLinks(std::vector<Core::DocObject*>& objvec,
                          std::vector<std::pair<const Core::DocObject*, const Core::DocObject*>>* errors = nullptr);
    bool checkObjectLinks(std::vector<Core::DocObject*>& objvec,
                          std::vector<Core::DocObject*>& objToCheck,
                          std::vector<std::pair<const Core::DocObject*, const Core::DocObject*>>* errors = nullptr);


    std::vector<const Core::DocObject*> getInner(const Core::DocObject* me, std::function<bool(const Core::DocObject*)>* allowToAddObject = 0);
    std::vector<const Core::DocObject*> getOuter(const Core::DocObject* me);

    std::vector<const Core::DocObject*> getLinksByProperties(const Core::DocObject* o);
    std::vector<PropertyLinkDesc> getLinkDescByProperties(const Core::DocObject* o);
    void getBackLinksByProperties(const Core::DocObject* source, std::vector<const Core::DocObject*>& links);

    void removeLinkInProperties(const Core::DocObject* source, Core::DocObject* link);
    void removeBackLinkInProperties(const Core::DocObject* source, Core::DocObject* link);

    std::string dumpGraph(void);
    std::vector<std::string> check_graph();
    std::vector<const Core::DocObject*> getLinksToMe(const Core::DocObject* o);
    std::vector<const Core::DocObject*> getBackLinksToMe(const Core::DocObject* o);
    std::vector<const Core::DocObject*> getLinksFromMe(const Core::DocObject* o);
    std::vector<const Core::DocObject*> getBackLinksFromMe(const Core::DocObject* o);
    
    virtual bool maybeSave() { return true; }
    std::vector<Core::DocObject*> getObjectsToSave();
    bool saveFile(bool toExport = false, bool saveBackupCopy = false);
    bool saveAsFile(const Base::String& filename = Base::String(),
                    bool toExport = false,
                    bool saveBackupCopy = false,
                    const Base::String& initialDir = Base::String());
    bool saveAsFileVersion(int version,
                           const Base::String& filename = Base::String(),
                           bool toExport = false,
                           bool saveBackupCopy = false,
                           const Base::String& initialDir = Base::String(),
                           bool dontRename = false);
    void setOnSaveChangeToDefaultUser(bool onoff);
    bool getOnSaveChangeToDefaultUser() const;
    bool askAndSetNewFilename(QString& newFilename, const Base::String& initialDir = Base::String());
    void setSaveBlocksUntilFinished(bool onoff);
    bool getSaveBlocksUntilFinished() const;

    virtual void addInventorDirectory(const Base::String&) {}
    virtual void createGroundPlate_deprecated() {}
    virtual void deleteObject(Core::DocObject* o);
    void setGuidPolicy(const Base::GlobalId_Policy& policy);
    void setGuidPolicy(const Base::String& suffix, const Base::GlobalId_Policy& policy);
    Base::GlobalId_Policy getGuidPolicy() const;
    bool getGuidPolicy(const Base::String& suffix, Base::GlobalId_Policy& policy) const;

    void addReferenceFrom(Core::DocObject* from);
    void removeReferenceFrom(Core::DocObject* from);
    bool hasReferencesFrom(Core::DocObject* from) const;
    const std::set<Core::DocObject*>& getReferences() const;
    void setFullFileName(const Base::String& fullfilename);

    virtual const char* subject_name(void) { return "CoreDocument"; };

    virtual bool restoreGlobalAttachment(Base::GlobalAttachment* gAtta, std::istream*, uint64_t streamsize, const Base::String& entryName);

    bool addFileToZip(const Base::String& entryName, const Base::String& path);
    bool restoreFileFromZip(const Base::String& entryName, const Base::String& targetpath, bool binaryMode);

    void forceBackupOnNextSave();

    bool hasErrorObjectsInRecompute();
    void resetHasErrorObjectsInRecompute();

    size_t getRecomputeCount() const;

    virtual void setChanged(bool changed);

    bool getImmutableObjects(Base::Type t, ObjectSet& set) const;
    virtual Core::DocObject* addImmutableObjectMaterial(Core::PropertyContainer* pc);

    void setImportedIFCFile(QString a);
    QString getImportedIFCFile();

#endif

protected:
    CoreDocument();
    // Copy constructor
    CoreDocument(const CoreDocument& rhs);

    virtual ~CoreDocument();


    Core::DocObject::IdType getUniqueObjectId() const;
    void addToDocumentMaps(Core::DocObject* o);
    Core::DocObject* getImmutableObjectWithSameValues(Base::Type t, Core::PropertyContainer* pc) const;
    virtual Core::DocObject* restoreObject(const std::string& typeName, const std::string& typeHierarchy, const std::string& id);
    void restoreProperty(Core::Property* property,
                         const Base::String& name,
                         Base::AbstractXMLReader& reader,
                         Base::PersistanceVersion& version) override;
    virtual void saveDocument(std::shared_ptr<Base::AbstractWriter> writer, int version2save, bool showProgress);
    virtual int restoreDocument(Base::XMLReader& reader, Core::Attachments& attachments);
    virtual std::vector<Core::DocObject*> build_savemap();
    void addNewObjectsToGraph();
    void resolveLinkInDocument(Core::PropertyLinkBase* link);
    virtual bool renameTypeFromOlderVersions(int, Base::String&) { return false; }
    virtual void checkBeforeObjectRestoring(int, int) {}
    virtual void checkAndConfigureOpenedDocument() {}
    virtual void checkAndConfigureOpenedDocumentAfterRecompute(int, int) {}
    virtual void onFileOpened() {}
    virtual bool convertFromOlderVersions(int docVersion, int appVersion);

    virtual bool getPatchedUserTypes(Base::String filename, std::map<QString, QString>& id2TypeMap);

    virtual void cleanUndoStack() {}
    virtual void storeDirectory(const QString&, Base::AbstractWriter&) {}
    virtual void restoreDirectory(const QString&) {}

    virtual void initDocument(bool) {}
    const ObjectMap& getObjectMap() const;
    void createTempDirectory();
    void cleanTempDirectory();
    bool maybe_add_GUID(const Base::GlobalId& guid, Core::DocObject* o);
    void add_GUID(const Base::GlobalId& guid, Core::DocObject* o);
    void remove_GUID(const Base::GlobalId& guid, Core::DocObject* o);
    void waitForSaveIsFinished();

    bool isCatalogFile() const;

    bool createBackupFile(const Base::String& path, bool savePath);
    bool createBackupFileAfterOpeningDoc(const Base::String& path, bool savePath);

    // Internal, do not use
    void __setEnableTimeStamps__(bool aOnOff);
    bool __getEnableTimeStamps__() const;

    DocumentState _state;
    // Map of all objects
    ObjectMap _all_objects_map;
    // For performance reasons we have a vector of all objects
    ObjectVector _all_objects_vector;
    // Map of all executable objects
    ExecObjectMap _exec_objects_map;
    // Map of all non-executable objects
    ObjectMap _non_exec_objects_map;
    // Map of immutable objects < Type, set of immutable objects >
    ObjectTypeMap _immutableObjectsMap;
    // Map of all objects
    ObjectMap _solvable_objects_map;
    // The object graph
    ObjectGraph* _graph;
    // Set of objects per type
    ObjectTypeMap _typeObjects;

    std::set<Core::DocObject*> _references;
    std::map<Base::GlobalId, Core::DocObject*> _guid_map;
    std::map<long, Core::DocObject*> _ifcId_map;

    bool _hasErrorObjectsInRecompute = false;
    bool _needRestoreBeforeRecompute = false;
    size_t _recomputeCnt = 0;
    bool mSolvingEnabled = true; 
private:
    bool openFile(const Base::String& filename, bool savePath = true);

    Core::DocObject* clone_and_replace_Object(const char* typeName, Core::DocObject* base);
    bool close(bool dontNotify = false);
    void _cleanTempDirectory_Helper(const Base::String& dir);
    void _copyFilesInTemp(Core::DocObject* original, Core::DocObject* copy);
    bool _saveFile(int version, bool toExport, bool saveBackupCopy);
    void _initNewObject(Core::DocObject* o, const DocObject::IdType& id = "");
    void _saveDocFiles(std::shared_ptr<Base::AbstractWriter> writer);
    bool _docWrite(std::shared_ptr<Base::AbstractWriter> mainwriter,
                   QString tmpfile,
                   QString fileName,
                   bool inThread,
                   bool toExport,
                   bool saveBackupCopy,
                   std::vector<Base::String> tempFilesToDelete);
    void cleanOldTempDirectories();
    // never make it public, copyShare param must be controlled ONLY from CoreDocument
    Core::DocObject* copyObjectInternal(Core::DocObject* o, DocObjectMap& copyMap, bool standardCopyOfShared = false, bool aCreateNewType = false);

    void notifyDocChange(DocChanges::why aWhy, DocMessage aMsgId, const Base::String& aValue);

    bool restoreDocuments(int& docVersion, int& appVersion);

    Base::Type m_copyType = Base::Type::badType();
    QString m_importedIFCFile;
    QDateTime _lastBackupFileTime;
    int _backupFilesCounter;
    int _numOfExistBackupFiles;
    bool _onSaveChangeToDefaultUser = false;
    bool _saveBlocksUntilFinished = false;
    Base::String _tmpdirectory;

    // Map for <file suffix / GUID policy>
    std::map<Base::String, Base::GlobalId_Policy> _guidPolicyMap;

    std::map<Base::String, Base::String> _additionalFiles;

    CoreDocumentImpl* _pimpl{};
};

/* @brief This class takes care that time stamping can be securely
 *  deactivated as long as an instance of this class stays in scope.
 *  It restores the old state when the destructor is called.
 */
class CORE_EXPORT DocumentTimeStampSentinel
{
public:
    DocumentTimeStampSentinel() = delete;
    DocumentTimeStampSentinel(Core::CoreDocument* aDoc) : mDoc(aDoc)
    {
        mOldEnableTimeStamps = mDoc->__getEnableTimeStamps__();
        mDoc->__setEnableTimeStamps__(false);
    }

    ~DocumentTimeStampSentinel()
    {
        mDoc->__setEnableTimeStamps__(mOldEnableTimeStamps);
    }
    Core::CoreDocument* mDoc;
    bool mOldEnableTimeStamps = true;
};

class CORE_EXPORT DocumentFactory
{
public:
    friend class CoreApplication;
    DocumentFactory() {}
    ~DocumentFactory() {}

    static std::map<std::string, Core::DocumentFactory*> registry;

protected:
    virtual Core::CoreDocument* createByFactory() = 0;
    static Core::CoreDocument* create(const std::string& type);
};


class CoreDocument_Factory : public Core::DocumentFactory
{
    virtual Core::CoreDocument* createByFactory()
    {
        Core::CoreDocument* doc = new Core::CoreDocument;
        return doc;
    }
};

}  // namespace Core



#define DECLARE_DOCUMENT_FACTORY(_factoryName_, _class_) \
    class _factoryName_ : public Core::DocumentFactory \
    { \
    private: \
        virtual Core::CoreDocument* createByFactory() \
        { \
            Core::CoreDocument* doc = new _class_; \
            return doc; \
        } \
    };

#define REGISTER_DOCUMENT_FACTORY(_factoryName_, _class_) Core::DocumentFactory::registry[#_class_] = (Core::DocumentFactory*)new _factoryName_();