Database.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
#pragma once
 
#include "Core/CADKernelArchive.h"
#include "Core/CADEntity.h"
#include "Core/Types.h"
#include "Containers/Queue.h"
 
namespace UE::CADKernel
{
class FCADKernelArchive;
class FModel;
class FTopologicalEntity;
class FTopologicalShapeEntity;
 
class CADKERNEL_API FDatabase
{
    friend class FCADKernelArchive;
    friend class FEntity;
    friend class FSession;
    template<typename, ESPMode> friend class SharedPointerInternals::TIntrusiveReferenceController;
 
protected:
 
    TSharedPtr<FModel> Model;
 
    TArray<TSharedPtr<FEntity>> DatabaseEntities;
 
    TArray<FIdent> AvailableIdents;
 
    TArray<TSharedPtr<FEntity>> ArchiveEntities;
 
    TArray<TArray<TSharedPtr<FEntity>*>> ArchiveIdToWaitingSharedPointers;
    TArray<TArray<TWeakPtr<FEntity>*>> ArchiveIdToWaitingWeakPointers;
    TArray<TArray<FEntity**>> ArchiveIdToWaitingPointers;
 
    TSet<FIdent> EntitiesToBeSerialized;
 
    TQueue<FIdent> NotYetSerialized;
 
    mutable bool bForceSpawning = false;
    bool bIsRecursiveSerialization = false;
    uint32 EntityCount;
 
public:
 
    FDatabase();
 
    FModel& GetModel() { return *GetModelAsShared(); }
    TSharedPtr<FModel> GetModelAsShared();
 
    void RemoveEntity(FIdent idEntity);
    void RemoveEntity(FEntity& Entity);
 
 
    void SerializeSelection(FCADKernelArchive& Ar, const TArray<FIdent>& SelectionIds);
 
    void Serialize(FCADKernelArchive& Ar);
 
    void Deserialize(FCADKernelArchive& Ar);
 
    void CleanArchiveEntities();
 
    void Empty();
 
    void AddEntity(TSharedPtr<FEntity> Entity)
    {
        if (!Entity.IsValid())
        {
            return;
        }
 
        if (Entity->GetId() > 0)
        {
            return;
        }
        FIdent Id = CreateId();
        DatabaseEntities[Id] = Entity;
        Entity->Id = Id;
    }
 
    void AddEntityFromArchive(TSharedPtr<FEntity>Entity)
    {
        FIdent ArchiveId = Entity->GetId();
        ensureCADKernel(ArchiveEntities.Num() > (int32)ArchiveId);
        // Add the entity to ArchiveEntities map.
        ArchiveEntities[ArchiveId] = Entity;
 
        // Check if the entity is not referenced by other entities if the archive(ArchiveIdToWaitingPointers).
        // If yes(IdToWaitingPointers[ArchiveId].Num() > 0), set all TSharedPtr with the new entity
        {
            TArray<TSharedPtr<FEntity>*>& WaitingList = ArchiveIdToWaitingSharedPointers[ArchiveId];
            if (WaitingList.Num() > 0)
            {
                for (TSharedPtr<FEntity>* SharedPtr : WaitingList)
                {
                    *SharedPtr = Entity;
                }
                WaitingList.Empty();
            }
        }
 
        {
            TArray<TWeakPtr<FEntity>*>& WaitingList = ArchiveIdToWaitingWeakPointers[ArchiveId];
            if (WaitingList.Num() > 0)
            {
                for (TWeakPtr<FEntity>* WeakPtr : WaitingList)
                {
                    *WeakPtr = Entity;
                }
                WaitingList.Empty();
            }
        }
 
        {
            TArray<FEntity**>& WaitingList = ArchiveIdToWaitingPointers[ArchiveId];
            if (WaitingList.Num() > 0)
            {
                for (FEntity** Ptr : WaitingList)
                {
                    *Ptr = &*Entity;
                }
                WaitingList.Empty();
            }
        }
 
        // Reset Id to add it in the DatabaseEntities map.
        Entity->Id = 0;
        // Add the entity to DatabaseEntities map.
        AddEntity(Entity);
    }
 
    void SetReferencedEntityOrAddToWaitingList(FIdent ArchiveId, TSharedPtr<FEntity>& Entity)
    {
        if (ArchiveId == 0)
        {
            Entity = TSharedPtr<FEntity>();
            return;
        }
 
        TSharedPtr<FEntity>& EntityPtr = ArchiveEntities[ArchiveId];
        if (EntityPtr.IsValid())
        {
            Entity = EntityPtr;
        }
        else
        {
            ArchiveIdToWaitingSharedPointers[ArchiveId].Add(&Entity);
        }
    }
 
    void SetReferencedEntityOrAddToWaitingList(FIdent ArchiveId, TWeakPtr<FEntity>& Entity)
    {
        if (ArchiveId == 0)
        {
            Entity = TWeakPtr<FEntity>();
            return;
        }
 
        TSharedPtr<FEntity>& EntityPtr = ArchiveEntities[ArchiveId];
        if (EntityPtr.IsValid())
        {
            Entity = EntityPtr;
        }
        else
        {
            ArchiveIdToWaitingWeakPointers[ArchiveId].Add(&Entity);
        }
    }
 
    void SetReferencedEntityOrAddToWaitingList(FIdent ArchiveId, FEntity** Entity)
    {
        if (ArchiveId == 0)
        {
            *Entity = nullptr;
            return;
        }
 
        TSharedPtr<FEntity>& EntityPtr = ArchiveEntities[ArchiveId];
        if (EntityPtr.IsValid())
        {
            *Entity = EntityPtr.Get();
        }
        else
        {
            ArchiveIdToWaitingPointers[ArchiveId].Add(Entity);
        }
    }
 
    uint32 SpawnEntityIdents(const TArray<TSharedPtr<FEntity>>& SelectedEntities, bool bForceSpawning = false);
    uint32 SpawnEntityIdents(const TArray<FEntity*>& SelectedEntities, bool bForceSpawning = false);
    uint32 SpawnEntityIdent(FEntity& SelectedEntity, bool bForceSpawning = false);
 
protected:
    void AddEntityToSave(FIdent EntityId)
    {
        if (bIsRecursiveSerialization && !EntitiesToBeSerialized.Find(EntityId))
        {
            EntitiesToBeSerialized.Add(EntityId);
            NotYetSerialized.Enqueue(EntityId);
        }
    }
 
private:
    FIdent CreateId();
 
    // =========================================================================================================================================================================================================
    // =========================================================================================================================================================================================================
    // =========================================================================================================================================================================================================
    //
    //
    //                                                                            NOT YET REVIEWED
    //
    //
    // =========================================================================================================================================================================================================
    // =========================================================================================================================================================================================================
    // =========================================================================================================================================================================================================
 
public:
 
    TSharedPtr<FEntity> GetEntity(FIdent id) const;
    void GetEntities(const TArray<FIdent>& ids, TArray<TSharedPtr<FEntity>>& Entities) const;
    void GetEntities(const TArray<FIdent>& ids, TArray<FEntity*>& Entities) const;
    void GetTopologicalEntities(const TArray<FIdent>& ids, TArray<FTopologicalEntity*>& Entities) const;
    void GetTopologicalShapeEntities(const TArray<FIdent>& ids, TArray<FTopologicalShapeEntity*>& Entities) const;
 
    void GetEntitiesOfType(EEntity Type, TArray<TSharedPtr<FEntity>>& OutEntities) const;
    void GetEntitiesOfTypes(const TSet<EEntity>& Types, TArray<TSharedPtr<FEntity>>& OutEntities) const;
 
    void ExpandSelection(TSharedPtr<FEntity> Entities, const TSet<EEntity>& Filter, TSet<TSharedPtr<FEntity>>& OutSelection) const;
    void ExpandSelection(const TArray<TSharedPtr<FEntity>>& Entities, const TSet<EEntity>& Filter, TSet<TSharedPtr<FEntity>>& OutSelection) const;
    void ExpandSelection(const TArray<TSharedPtr<FEntity>>& Entities, const TSet<EEntity>& Filter, TArray<TSharedPtr<FEntity>>& OutSelection) const;
 
    void TopologicalEntitiesSelection(const TArray<TSharedPtr<FEntity>>& Entities, TArray<TSharedPtr<FTopologicalEntity>>& OutTopoEntities, bool bFindSurfaces, bool bFindEdges, bool bFindVertices) const;
    void CadEntitiesSelection(const TArray<TSharedPtr<FEntity>>& Entities, TArray<TSharedPtr<FEntity>>& OutCadEntities) const;
    void MeshEntitiesSelection(const TArray<TSharedPtr<FEntity>>& Entities, TArray<TSharedPtr<FEntity>>& OutMeshEntities) const;
 
    TSharedPtr<FEntity> GetFirstEntityOfType(EEntity Type) const;
};
 
} // namespace UE::CADKernel