DesignObjectResourceCache.h

#pragma once
#include <NDEVR/Model.h>
#include <NDEVR/Geometry.h>
namespace NDEVR
{
    class DesignObjectResourceCache
    {
    public:
        void setModelToDefaults(Model& model)
        {
            Model parent = model.getParent();
            if (parent.isValid())
                parent.removeChild(model);
            model.clearChildren();
            model.clearLayer();
            model.clearMaterial();
            model.removeGeometry();
 
            model.set(NDPO::is_deleted, false);
            model.set<NDPO::transform>(Matrix<fltp08>(1.0));
            model.set<NDPN::type>(StringView());
            model.set<NDPN::calculation_ignored>(false);
            model.set<NDPO::is_application_owned>(false);
            model.set(NDPN::child_base_ptr, nullptr);
            model.set<NDPN::can_select_children>(false);
            model.set(NDPN::fixed_bounding_box, Constant<Bounds<3, fltp08>>::Invalid);
            model.set<NDPO::author>(StringView());
            Time time = Time::SystemTime();
            model.set<NDPO::modified_time>(time);
            model.set<NDPO::desc_modified_time>(time);
            model.set<NDPO::asc_modified_time>(time);
            model.set<NDPO::creation_time>(time);
            model.set<NDPO::library_id>(Constant<UUID>::Invalid);
            model.clearAllMetaData();
 
        }

        void addToCache(const Buffer<Model>& items)
        {
            for (Model iter : items)
                setModelToDefaults(iter);
            models.addAll(items);
        }

        void addToCache(const Buffer<Geometry>& items)
        {
            for (Geometry iter : items)
            {
                Buffer<Model> parents = iter.getParents();
                for (Model parent : parents)
                    parent.removeGeometry();
            }
            geometries.addAll(items);
        }

        void createChildren(Model& parent, uint04 size)
        {
            if (size > models.size())
            {
                parent.createChildren(size - models.size());
            }
            uint04 cache_size = models.size();
            for (uint04 i = 0; i < getMin(cache_size, size); i++)
            {
                createModel(parent);
            }
        }

        Model createModel(Model& parent)
        {
            if (models.size() > 0)
            {
                Model model = models.last();
                models.removeLast();
                parent.addChild(model);
                return model;
            }
            else
            {
                return parent.createChild();
            }
        }

        Geometry createGeometry(Model& parent)
        {
            if (geometries.size() > 0)
            {
                Geometry geo = geometries.last();
                geometries.removeLast();
                parent.setGeometryChild(geo);
                return geo;
            }
            else
            {
                return parent.createChildGeometry();
            }
        }
 
        Buffer<Model> models;           
        Buffer<Geometry> geometries;     
    };
}