FactoryModelFilters.h

Go to the documentation of this file.

#pragma once
#include "DLLInfo.h"
#include <NDEVR/DesignObjectLookup.h>
#include <NDEVR/Deployment.h>
#include <NDEVR/StationModel.h>
#include <NDEVR/ModelIterator.h>
#include <NDEVR/Set.h>
namespace NDEVR
{
    /**--------------------------------------------------------------------------------------------------
    \brief Provides easy filtering tools for factories that are only able to export certain types of
        models or geometries.
    **/
    class NDEVR_FACTORY_API FactoryModelFilters
    {
    public:
        template<class t_type>
        static void SortModelsByName(Buffer<t_type>& models)
        {
            std::sort(models.begin(), models.end(), [](t_type& a, t_type& b)
            {
                return String::AlphaNumericCompare(a.displayNamePath().translation(), b.displayNamePath().translation());
            });
        }
        static Buffer<Model> FilterTypeModels(Buffer<UUID> models_to_check, const DesignObjectLookup* lookup, const Buffer<String>& types)
        {
            RLock lock(lookup->readLock());
            Buffer<Model> models;
            for (UUID id : models_to_check)
            {
                Model model = lookup->model(id);
                if (model.isValid())
                {
                    if (model.exportIgnored())
                        continue;
                    if (types.size() == 0)
                    {
                        models.add(model);
                    }
                    else
                    {
                        for (const String& type : types)
                        {
                            if (model.isOfType(type))
                                models.add(model);
                            else
                                models.addAll(model.getDescendentsByType(type));
                        }
                    }
                }
            }
            for (uint04 i = models.size() - 1; !IsInvalid(i); i--)
            {
                if (models[i].exportIgnored())
                    models.removeIndex(i);
            }
            return models;
        }
        template<class t_type>
        static Buffer<t_type> FilterTypeModels(Buffer<UUID> models_to_check, const DesignObjectLookup* lookup)
        {
            RLock lock(lookup->readLock());
            Buffer<t_type> models;
            for (UUID id : models_to_check)
            {
                Model model = lookup->model(id);
                if (model.isValid())
                {
                    if (model.exportIgnored())
                        continue;
                    if (model.isOfType(t_type::TypeName()))
                        models.add(t_type(model));
                    else
                        models.addAll(model.getTypeDescendents<t_type>(t_type::TypeName()));
                }
            }
            return models;
        }
#if NDEVR_DEPLOYMENT
        static Buffer<Deployment> FilterDeploymentModels(Buffer<UUID> models_to_check, const DesignObjectLookup* lookup, bool sort, bool allow_planned = false)
        {
            RLock lock(lookup->readLock());
            Buffer<Deployment> models;
            for (UUID id : models_to_check)
            {
                Model model = lookup->model(id);
                if (model.isValid())
                {
                    if (model.isOfType(Deployment::TypeName()))
                        models.add(Deployment(model));
                    else
                        models.addAll(model.getTypeDescendents<Deployment>(Deployment::TypeName()));
                }
            }
            models.removeAllUnordered([allow_planned](Deployment& deployment)
            {
                if (deployment.recordCount() == 0)
                    return true;
                return !allow_planned && deployment.isPlanned();
            });
            if (sort)
            {
                SortModelsByName(models);
            }
            return models;
        }
#endif
#if NDEVR_STATION_MODEL && NDEVR_DEPLOYMENT
        static Buffer<StationModel> FilterStationDeploymentModels(Buffer<UUID> models_to_check, const DesignObjectLookup* lookup, bool sort, bool allow_planned = false)
        {
            Buffer<Deployment> deployments = FilterDeploymentModels(models_to_check, lookup, false, allow_planned);
            Dictionary<UUID, StationModel> stations;
            for (const Deployment& deployment : deployments)
            {
                StationModel station = deployment.getStation();
                if (station.isValid() && !stations.hasKey(station.uuid()))
                    stations.add(station.uuid(), station);
 
            }
            Buffer<StationModel> models = stations.values();
            if (sort)
                SortModelsByName(models);
            return models;
        }
#endif
        static Buffer<Model> FilterGeometryModels(Buffer<UUID> models_to_check, const DesignObjectLookup* lookup, GeometryType type)
        {
            RLock lock(lookup->readLock());
            Buffer<Model> all_models;
            BasicModelIterator iter([&all_models, type](const Model& m, Geometry& geo) -> BasicModelIterator::ParseResult
            {
                if (!m.exportIgnored() && geo.getGeometryType() == type)
                    all_models.add(m);
                return BasicModelIterator::ParseResult::e_continue_parsing;
            });
            iter.model_filter = [](const Model& m) 
            {
                return !m.exportIgnored() && !m.isApplicationOwned();
            };
            for (uint04 i = 0; i < models_to_check.size(); i++)
            {
                Model model = lookup->model(models_to_check[i]);
                if (model.isValid())
                    iter.parseAll(model);
            }
            return Model::ReduceToRoots(all_models, [](const Model& model, const Set<Model>& all_set)->bool
            {
                if (model.isApplicationOwned() || model.exportIgnored())
                    return true;
                Buffer<Model> children = model.getChildren();
                for (const Model& child : children)
                {
                    if (child.isApplicationOwned() || child.exportIgnored())
                        continue;
                    if (!all_set.hasValue(child))
                        return false;
                }
                return true;
            });
        }
        static Buffer<Model> FilterGeometryModels(Buffer<UUID> models_to_check, const DesignObjectLookup* lookup, const Buffer<GeometryType>& types)
        {
            RLock lock(lookup->readLock());
            Buffer<Model> all_models;
            BasicModelIterator iter([&all_models, types](const Model& m, Geometry& geo) -> BasicModelIterator::ParseResult
            {
                if (!m.exportIgnored() && types.contains(geo.getGeometryType()))
                    all_models.add(m);
                return BasicModelIterator::ParseResult::e_continue_parsing;
            });
            iter.model_filter = [](const Model& m)
            {
                return !m.exportIgnored() && !m.isApplicationOwned();
            };
            for (uint04 i = 0; i < models_to_check.size(); i++)
            {
                Model model = lookup->model(models_to_check[i]);
                if (model.isValid())
                    iter.parseAll(model);
            }
            return Model::ReduceToRoots(all_models, [](const Model& model, const Set<Model>& all_set)->bool
            {
                if (model.isApplicationOwned() || model.exportIgnored())
                    return true;
                Buffer<Model> children = model.getChildren();
                for (const Model& child : children)
                {
                    if (child.isApplicationOwned() || child.exportIgnored())
                        continue;
                    if (!all_set.hasValue(child))
                        return false;
                }
                return true;
            });
        }
    };
}