Merge GH-1437

Revise file import and symbol assignment

Author: dg0yt

code-check-wrapper.sh

@@ -84,6 +84,8 @@ PATTERN=" \
   renderable_implementation.cpp \
   settings_dialog.cpp \
   /symbol.cpp \
+  symbol_replacement.cpp \
+  symbol_replacement_dialog.cpp \
   symbol_rule_set.cpp \
   symbol_t.cpp \
   symbol_tooltip.cpp \

src/CMakeLists.txt

@@ -125,8 +125,9 @@ set(Mapper_Common_SRCS
   gui/symbols/line_symbol_settings.cpp
   gui/symbols/point_symbol_editor_widget.cpp
   gui/symbols/point_symbol_settings.cpp
-  gui/symbols/replace_symbol_set_dialog.cpp
   gui/symbols/symbol_properties_widget.cpp
+  gui/symbols/symbol_replacement.cpp
+  gui/symbols/symbol_replacement_dialog.cpp
   gui/symbols/symbol_setting_dialog.cpp
   gui/symbols/text_symbol_settings.cpp
 

src/core/objects/symbol_rule_set.cpp

@@ -65,19 +65,35 @@ Q_STATIC_ASSERT(std::is_nothrow_move_assignable<SymbolRuleSet>::value);
 
 
 // static
-SymbolRuleSet SymbolRuleSet::forOriginalSymbols(const Map& map)
+SymbolRuleSet SymbolRuleSet::forMatchingSymbols(const Map& map, const std::function<bool (int)>& predicate)
 {
 	SymbolRuleSet list;
 	list.reserve(std::size_t(map.getNumSymbols()));
 	for (int i = 0; i < map.getNumSymbols(); ++i)
 	{
+		if (!predicate(i))
+			continue;
 		auto original = map.getSymbol(i);
 		list.push_back({{original}, nullptr, SymbolRule::NoAssignment});
 	}
 	list.sortByQueryKeyAndValue();
 	return list;
 }
 
+// static
+SymbolRuleSet SymbolRuleSet::forAllSymbols(const Map& map)
+{
+	return SymbolRuleSet::forMatchingSymbols(map, [](int /*i*/) { return true; });
+}
+
+// static
+SymbolRuleSet SymbolRuleSet::forUsedSymbols(const Map& map)
+{
+	std::vector<bool> symbols_in_use(std::size_t(map.getNumSymbols()));
+	map.determineSymbolsInUse(symbols_in_use);
+	return SymbolRuleSet::forMatchingSymbols(map, [&symbols_in_use](int i) { return symbols_in_use[std::size_t(i)]; });
+}
+
 
 SymbolRuleSet SymbolRuleSet::squeezed() const
 {
@@ -90,6 +106,38 @@ SymbolRuleSet SymbolRuleSet::squeezed() const
 }
 
 
+void SymbolRuleSet::merge(SymbolRuleSet&& other, MergeMode mode)
+{
+	for (auto& item : other)
+	{
+		for (auto& current : *this)
+		{
+			if (item.query == current.query)
+			{
+				if (item.type != SymbolRule::NoAssignment)
+				{
+					current.symbol = item.symbol;
+					current.type = item.type;
+					item = {};
+				}
+				break;
+			}
+		}
+	}
+	
+	if (mode == UpdateAndAppend)
+	{
+		for (auto&& item : other)
+		{
+			if (item.query.getOperator() != ObjectQuery::OperatorInvalid)
+			{
+				emplace_back(std::move(item));
+			}
+		}
+	}
+}
+
+
 
 void SymbolRuleSet::sortByQuerySymbol()
 {
@@ -309,6 +357,59 @@ void SymbolRuleSet::writeCrt(QTextStream& stream) const
 
 
 
+void SymbolRuleSet::recognizeSymbolPatterns(const Map& symbol_set)
+{
+	for (auto& item : *this)
+	{
+		if (item.type == SymbolRule::NoAssignment
+		    || item.query.getOperator() != ObjectQuery::OperatorSearch)
+			continue;
+		Q_ASSERT(item.symbol);
+		
+		auto operands = item.query.tagOperands();
+		if (!operands || operands->value.isEmpty())
+			continue;
+		
+		// Find original symbol number matching the pattern
+		for (int i = 0; i < symbol_set.getNumSymbols(); ++i)
+		{
+			auto symbol = symbol_set.getSymbol(i);
+			if (symbol->getNumberAsString() == operands->value)
+			{
+				if (Symbol::areTypesCompatible(symbol->getType(), item.symbol->getType()))
+					item.query = { symbol };
+				break;
+			}
+		}
+	}
+}
+
+
+
+const Symbol* SymbolRuleSet::findDuplicateSymbolPattern() const
+{
+	for (auto const& item : *this)
+	{
+		if (item.query.getOperator() != ObjectQuery::OperatorSymbol)
+			continue;
+		
+		auto has_conflict = [&item](const auto& other)->bool {
+			return &other != &item
+			       && other.type != SymbolRule::NoAssignment
+			       && item.query == other.query
+			       && item.symbol != other.symbol;
+		};
+		using std::begin; using std::end;
+		if (std::any_of(begin(*this), end(*this), has_conflict))
+		{
+			return item.symbol;
+		}
+	}
+	return nullptr;
+}
+
+
+
 void SymbolRuleSet::operator()(Object* object) const
 {
 	for (const auto& item : *this)

src/core/objects/symbol_rule_set.h

@@ -21,6 +21,7 @@
 #ifndef OPENORIENTEERING_SYMBOL_RULE_SET_H
 #define OPENORIENTEERING_SYMBOL_RULE_SET_H
 
+#include <functional>
 #include <vector>
 
 #include <QFlags>
@@ -71,22 +72,54 @@ class SymbolRuleSet : public std::vector<SymbolRule>
 	// Intentionally no user-defined constructors, destructor, assignment.
 	// Default ones are fine.
 
+	/**
+	 * Creates a list which has a NoAssignment rule for every original symbol
+	 * that the predicate returns true for.
+	 * 
+	 * The argument to the predicate is the symbol number.
+	 * 
+	 * The created list is sorted by formatted symbol number.
+	 */
+	static SymbolRuleSet forMatchingSymbols(const Map& map, const std::function<bool (int)>& predicate);
+	
 	/** 
-	 * Creates a list of NoAssignment items for the map's symbols as originals.
+	 * Creates a list which has a NoAssignment rule for every original symbol.
 	 * 
 	 * This function can be used to easily initialize variables of type
 	 * SymbolRuleSet despite the absence of specialized constructors.
-	 * Each item is initialized with an object query for a symbol from the map.
 	 * 
-	 * The created list is sorted by formatted symbol number.
+	 * \see SymbolRuleSet::forMatchingSymbols
 	 */
-	static SymbolRuleSet forOriginalSymbols(const Map& map);
+	static SymbolRuleSet forAllSymbols(const Map& map);
+	
+	/**
+	 * Creates a list which has a NoAssignment rule for every used original symbol.
+	 * 
+	 * This function can be used to easily initialize variables of type
+	 * SymbolRuleSet despite the absence of specialized constructors.
+	 * 
+	 * \see SymbolRuleSet::forMatchingSymbols
+	 */
+	static SymbolRuleSet forUsedSymbols(const Map& map);
 
 	/**
 	 * Returns a copy which has all NoAssignment items removed.
 	 */
 	SymbolRuleSet squeezed() const;
 
+	/**
+	 * Modes for merging rule sets
+	 */
+	enum MergeMode
+	{
+		UpdateOnly,       ///< Update existing rules only.
+		UpdateAndAppend,  ///< Update existing rules, and append new rules.
+	};
+	
+	/**
+	 * Merges a second rule set into this one.
+	 */
+	void merge(SymbolRuleSet&& other, MergeMode mode);
 
 	/** 
 	 * Sorts the items by original symbol number and name if possible.
@@ -156,6 +189,19 @@ class SymbolRuleSet : public std::vector<SymbolRule>
 	void writeCrt(QTextStream& stream) const;
 
 
+	/**
+	 * Converts plain search patterns into symbol patterns where possible.
+	 */
+	void recognizeSymbolPatterns(Map const& symbol_set);
+	
+	/**
+	 * Finds symbols that are matched by multiple symbol number patterns.
+	 * 
+	 * Returns an arbitrary affected symbol, or nullptr if no such symbol exists.
+	 */
+	Symbol const* findDuplicateSymbolPattern() const;
+	
+	
 	/**
 	 * Applies the matching rules to the object.
 	 *