Finish rework

Add more functionality.
Enhance keyword pull-down menu to be context sensitive.

Author: dl3sdo

src/core/objects/dynamic_object_query.cpp

@@ -1,5 +1,5 @@
 /*
- *    Copyright 2025 Matthias Kühlewein
+ *    Copyright 2026 Matthias Kühlewein
  *
  *    This file is part of OpenOrienteering.
  *
@@ -24,8 +24,10 @@
 
 #include <Qt>
 #include <QLatin1Char>
+#include <QLatin1String>
 
 #include "core/map.h"
+#include "core/map_part.h"
 #include "core/objects/object.h"
 #include "core/symbols/symbol.h"
 
@@ -86,13 +88,13 @@ bool EvaluatePaperReal(const QString& element, int& type)
 
 bool EvaluateSymbolType(QString element, int symbol_type, bool& result)
 {
-	QStringList symbol_types = {QLatin1String("Point"), QLatin1String("Line"), QLatin1String("Area"), QLatin1String("Text"), QLatin1String("Combined")};
+	const QStringList symbol_types = {QLatin1String("Point"), QLatin1String("Line"), QLatin1String("Area"), QLatin1String("Text"), QLatin1String("Combined")};
 	int operation;
 
 	if (element.startsWith(QLatin1String("==")))
-		operation = 0;
-	else if (element.startsWith(QLatin1String("!=")))
 		operation = 1;
+	else if (element.startsWith(QLatin1String("!=")))
+		operation = 0;
 	else
 		return false;
 
@@ -104,17 +106,60 @@ bool EvaluateSymbolType(QString element, int symbol_type, bool& result)
 	if (match != symbol_types.end())
 	{
 		auto index = match - symbol_types.begin();
-		result = operation ? (1<<index != symbol_type) : (1<<index == symbol_type);
+		result = operation ? (1<<index == symbol_type) : (1<<index != symbol_type);
 		return true;
 	}
 	return false;
 }
 
+bool EvaluateSymbolId(QString element, QString symbol_id, bool& result)
+{
+	int operation;
+	
+	if (element.startsWith(QLatin1String("==")))
+		operation = 1;
+	else if (element.startsWith(QLatin1String("!=")))
+		operation = 0;
+	else
+		return false;
+	
+	const auto symbol_id_elements = symbol_id.split(QLatin1Char('.'));
+	const auto valuestr = element.remove(0, 2).trimmed();
+	if (valuestr.isEmpty())
+		return false;
+	const auto value_elements = valuestr.split(QLatin1Char('.'));
+	if (value_elements.size() > 3)
+		return false;
+
+	for (auto i = 0; i < value_elements.size(); ++i)
+	{
+		if (i >= symbol_id_elements.size())
+		{
+			result = !(bool)operation;
+			return true;
+		}
+		if (value_elements.at(i) == QLatin1Char('*'))
+		{
+			result = (bool)operation;
+			return true;
+		}
+		if (value_elements.at(i) != symbol_id_elements.at(i))
+		{
+			result = !(bool)operation;
+			return true;
+		}
+	}
+	result = (bool)operation;
+	return true;
+}
+
 }  // namespace
 
 
 namespace OpenOrienteering {
 
+const QStringList DynamicObjectQueryManager::keywords = {QLatin1String{"LINE"}, QLatin1String{"AREA"}, QLatin1String{"SYMBOL"}, QLatin1String{"OBJECT"}};
+
 DynamicObjectQueryManager::DynamicObjectQueryManager()
 {
 	// nothing else
@@ -124,25 +169,23 @@ DynamicObjectQuery::~DynamicObjectQuery()= default;
 
 DynamicObjectQuery* DynamicObjectQueryManager::parse(QStringRef token_text, QStringRef token_attributes_text)
 {
-	if (AreaObjectQuery::getKeyword() == token_text)
+	if (token_text == keywords[DynamicObjectQuery::AreaObjectQuery])
 	{
 		return new AreaObjectQuery(token_attributes_text);
 	}
-	else if (LineObjectQuery::getKeyword() == token_text)
+	else if (token_text == keywords[DynamicObjectQuery::LineObjectQuery])
 	{
 		return new LineObjectQuery(token_attributes_text);
 	}
-	else if (SymbolQuery::getKeyword() == token_text)
+	else if (token_text == keywords[DynamicObjectQuery::SymbolQuery])
 	{
 		return new SymbolQuery(token_attributes_text);
 	}
-/*
-	else if (ObjectQuery::getKeyword() == token_text)
+	else if (token_text == keywords[DynamicObjectQuery::GeneralObjectQuery])
 	{
-		return new ObjectQuery(token_attributes_text);
+		return new GeneralObjectQuery(token_attributes_text);
 	}
-*/
-	return nullptr;		// 	we should not get here
+	return nullptr;
 }
 
 bool DynamicObjectQueryManager::performDynamicQuery(const Object* object, const DynamicObjectQuery* dynamic_query)
@@ -171,26 +214,94 @@ bool DynamicObjectQueryManager::performDynamicQuery(const Object* object, const
 				const auto map = object->getMap();
 				return symbol && map ? static_cast<const SymbolQuery*>(dynamic_query)->performQuery(map, symbol) : false;
 			}
-/*
-		case DynamicObjectQuery::ObjectQuery:
-			return static_cast<const ObjectQuery*>(dynamic_query)->performQuery(object);
-*/
+		case DynamicObjectQuery::GeneralObjectQuery:
+			{
+				const auto map = object->getMap();
+				return map ? static_cast<const GeneralObjectQuery*>(dynamic_query)->performQuery(map, object) : false;
+			}
 		default:
 			return false;	// we should not get here
 	}
 
 	Q_UNREACHABLE();
 }
 
+const QStringList DynamicObjectQueryManager::getContextKeywords(const QString& text, int position, bool& append)
+{
+	int keyword_found = -1;
+	int i = position - 1;
+	for ( ; i > 3; --i)	// consider shortest keyword
+	{
+		if (text.at(i) == QLatin1Char(')'))
+		{
+			break;
+		}
+		else if (text.at(i) == QLatin1Char('('))
+		{
+			for (auto j = 0; j < keywords.size(); ++j)
+			{
+				auto match = text.lastIndexOf(keywords[j], i-1);
+				if (match != -1 && match == i - keywords[j].length())
+				{
+					keyword_found = j;
+					break;
+				}
+			}
+		}
+	}
+	
+	if (keyword_found == -1)
+	{
+		QStringList context_keywords;
+		for (auto keyword : keywords)
+			context_keywords.append(keyword.append(QLatin1String("()")));
+		append = true;
+		return context_keywords;
+	}
+	
+	auto parameters = text.mid(i, position - i).trimmed();
+	
+	switch (keyword_found)
+	{
+		case DynamicObjectQuery::LineObjectQuery:
+		case DynamicObjectQuery::AreaObjectQuery:
+			for (const auto& comp : numerical_compare_operations)
+			{
+				if (parameters.endsWith(comp.op))
+					return QStringList();
+			}
+			{
+				QStringList keywords = {keyword_found == DynamicObjectQuery::LineObjectQuery ? QLatin1String("ISTOOSHORT;") : QLatin1String("ISTOOSMALL;")};
+				keywords += QString(QLatin1String("PAPER; REAL; AND; OR;")).split(QLatin1Char(' '));
+				for (const auto& comp : numerical_compare_operations)
+					keywords += comp.op;
+				return keywords;
+			}
+			
+		case DynamicObjectQuery::SymbolQuery:
+			if (parameters.endsWith(QLatin1String("==")) || parameters.endsWith(QLatin1String("!=")))
+			{
+				const auto find_type_keyword = parameters.lastIndexOf(QLatin1String("TYPE"));
+				const auto find_id_keyword = parameters.lastIndexOf(QLatin1String("ID"));
+				if (find_type_keyword >= find_id_keyword)	// if both keywords are not found the '=' part is needed for the -1 values
+				{
+					return QString(QLatin1String("Point; Line; Area; Text; Combined;")).split(QLatin1Char(' '));
+				}
+				return QStringList();
+			}
+			return QString(QLatin1String("ISUNDEFINED; TYPE; ID; == != AND; OR;")).split(QLatin1Char(' '));
+			
+		case DynamicObjectQuery::GeneralObjectQuery:
+			return QStringList{QLatin1String("IGNORESYMBOL;"), QLatin1String("ISDUPLICATE;")};
+			
+		default:
+			return QStringList();	// we should not get here
+	}
+	
+	Q_UNREACHABLE();
+}
+
 
-/* Bsp. und Ideen:
- * AREA(ISTOOSMALL)
- * AREA(REAL;<= 20.5;OR;>= 30.2)
- * SYMBOL(ISUNDEFINED) bzw. SYMBOL(TYPE;== UNDEFINED)
- * SYMBOL(TYPE;== AREA)
- * SYMBOL(TYPE;== ISHELPER)
- * SYMBOL(ID;== 102.1)
- * */
 AreaObjectQuery::AreaObjectQuery(QStringRef token_attributes_text)
 : DynamicObjectQuery(DynamicObjectQuery::AreaObjectQuery)
 {
@@ -307,7 +418,7 @@ bool SymbolQuery::performQuery(const Map* map, const Symbol* symbol) const
 	int symbol_property = 0;	// 0 = TYPE, 1 = ID
 
 	bool result = false;
-	bool symbol_type_result;
+	bool eval_symbol_result;
 	for (auto& element : attributes)
 	{
 		if (EvaluateAndOrOperation(element, and_or_operation))
@@ -322,13 +433,17 @@ bool SymbolQuery::performQuery(const Map* map, const Symbol* symbol) const
 			result = and_or_operation ? (result || is_undefined) : (result && is_undefined);
 			and_or_operation = 0;	// default after first operation is AND operation
 		}
-		else if (symbol_property == 0 && EvaluateSymbolType(element, (symbol ? symbol->getType() : 0), symbol_type_result))
+		else if (symbol_property == 0 && EvaluateSymbolType(element, (symbol ? symbol->getType() : 0), eval_symbol_result))
+		{
+			result = and_or_operation ? (result || eval_symbol_result) : (result && eval_symbol_result);
+			and_or_operation = 0;	// default after first operation is AND operation
+		}
+		else if (symbol_property == 1 && EvaluateSymbolId(element, (symbol ? symbol->getNumberAsString() : QLatin1String("1")), eval_symbol_result))
 		{
-			result = and_or_operation ? (result || symbol_type_result) : (result && symbol_type_result);
+			result = and_or_operation ? (result || eval_symbol_result) : (result && eval_symbol_result);
 			and_or_operation = 0;	// default after first operation is AND operation
 		}
-		//else if (symbol_property == 1 && ....)
-		else	// unknown element or failure in EvaluateSymbolType()
+		else	// unknown element or failure in EvaluateSymbolType() or EvaluateSymbolId()
 		{
 			if (!symbol)
 				return false;	// dry run failed
@@ -340,14 +455,48 @@ bool SymbolQuery::performQuery(const Map* map, const Symbol* symbol) const
 	return true;	// dry run was successful
 }
 
-/*
-ObjectQuery::ObjectQuery(QStringRef token_attributes_text)
-: DynamicObjectQuery(DynamicObjectQuery::ObjectQuery)
+
+GeneralObjectQuery::GeneralObjectQuery(QStringRef token_attributes_text)
+: DynamicObjectQuery(DynamicObjectQuery::GeneralObjectQuery)
 {
 	parseTokenAttributes(token_attributes_text);
-	valid = performQuery(nullptr);	// dry run
+	valid = performQuery(nullptr, nullptr);	// dry run
 }
-*/
+
+bool GeneralObjectQuery::performQuery(const Map* map, const Object* object) const
+{
+	int and_or_operation = 1;	// 0 = AND, 1 = OR
+	bool ignore_symbols = false;
+	
+	bool result = false;
+	for (auto& element : attributes)
+	{
+		if (EvaluateAndOrOperation(element, and_or_operation))
+			continue;
+		else if (element == QLatin1String("IGNORESYMBOL"))
+			ignore_symbols = true;
+		else if (element == QLatin1String("ISDUPLICATE"))
+		{
+			if (!map || !object)
+				return true;
+			const bool isduplicate_result = map->getCurrentPart()->existsObject([object, ignore_symbols](auto const* o)
+			                                { return object != o && object->equals(o, !ignore_symbols); }
+			);
+			result = and_or_operation ? (result || isduplicate_result) : (result && isduplicate_result);
+			and_or_operation = 0;	// default after first operation is AND operation
+		}
+		else	// unknown element
+		{
+			if (!object)
+				return false;	// dry run failed
+			break;
+		}
+	}
+	if (object)
+		return result;
+	return true;	// dry run was successful
+}
+
 
 DynamicObjectQuery::DynamicObjectQuery(Type type) noexcept
 : type { type }