Inflection-77: Final issue resolved and added one CAPI test for iinf_createWithDefaults as InflectableStringConceptTest-c#testCreateWithDefaults

Author: BHK4321

inflection/src/inflection/dialog/DictionaryLookupFunction.cpp

@@ -124,11 +124,6 @@ SpeakableString* DictionaryLookupFunction::getFeatureValue(const DisplayValue& d
     if (result.empty()) {
         return nullptr;
     }
-    for(const auto& [feature, value]: displayValue.getConstraintMap()) {
-        if (feature.getName() == u"speak") {
-            return new SpeakableString(result, value);
-        }
-    }
     return new SpeakableString(result);
 }
 

inflection/src/inflection/dialog/InflectableStringConcept.cpp

@@ -52,11 +52,40 @@ SpeakableString* InflectableStringConcept::getFeatureValue(const SemanticFeature
     if (constraint != nullptr) {
         return new SpeakableString(*npc(constraint));
     }
+    const auto displayValueResult = getDisplayValue(true);
+    if (displayValueResult) {
+        const auto defaultFeatureFunction = npc(getModel())->getDefaultFeatureFunction(feature);
+        ::std::unique_ptr<SpeakableString> computedValue;
+        ::std::unique_ptr<SpeakableString> baseValue;
+        if (defaultFeatureFunction != nullptr) {
+            computedValue.reset(npc(defaultFeatureFunction)->getFeatureValue(*displayValueResult, constraints));
+            baseValue.reset(npc(defaultFeatureFunction)->getFeatureValue(defaultDisplayValue, constraints));
+        }
+        const auto& displayConstraintMap = displayValueResult->getConstraintMap();
+        auto displayConstraint = displayConstraintMap.find(feature);
+        if (displayConstraint != displayConstraintMap.end()) {
+            auto numberFeature = npc(getModel())->getFeature(u"number");
+            if (feature.getName() == u"gender" && baseValue && numberFeature != nullptr && displayConstraintMap.find(*npc(numberFeature)) != displayConstraintMap.end()) {
+                return baseValue.release();
+            }
+            return new SpeakableString(displayConstraint->second);
+        }
+        if (computedValue) {
+            return computedValue.release();
+        }
+        if (baseValue) {
+            return baseValue.release();
+        }
+    }
+    const auto& initialConstraintMap = defaultDisplayValue.getConstraintMap();
+    auto initialConstraint = initialConstraintMap.find(feature);
+    if (initialConstraint != initialConstraintMap.end()) {
+        return new SpeakableString(initialConstraint->second);
+    }
     auto defaultFeatureFunction = npc(getModel())->getDefaultFeatureFunction(feature);
     if (defaultFeatureFunction != nullptr) {
-        const auto displayValueResult = getDisplayValue(true);
-        if (displayValueResult) {
-            return npc(defaultFeatureFunction)->getFeatureValue(*displayValueResult, constraints);
+        if (auto fallbackValue = ::std::unique_ptr<SpeakableString>(npc(defaultFeatureFunction)->getFeatureValue(defaultDisplayValue, constraints))) {
+            return fallbackValue.release();
         }
     }
     return nullptr;
@@ -76,11 +105,7 @@ ::std::optional<DisplayValue> InflectableStringConcept::getDisplayValue(bool all
 {
     auto defaultDisplayFunction = npc(getModel())->getDefaultDisplayFunction();
     if (defaultDisplayFunction != nullptr && !constraints.empty()) {
-        ::std::map<SemanticFeature, ::std::u16string> constraintMap;
-        if (!value.speakEqualsPrint()) {
-            constraintMap.emplace(*npc(getSpeakFeature()), value.getSpeak());
-        }
-        SemanticFeatureModel_DisplayData displayData({DisplayValue(value.getPrint(), constraintMap)});
+        SemanticFeatureModel_DisplayData displayData({defaultDisplayValue});
         ::std::unique_ptr<DisplayValue> returnVal(npc(defaultDisplayFunction)->getDisplayValue(displayData, constraints, allowInflectionGuess));
         if (returnVal != nullptr) {
             return *returnVal;

inflection/test/src/inflection/dialog/InflectableStringConceptTest-c.cpp

@@ -155,6 +155,73 @@ TEST_CASE("InflectableStringConceptTest-c#testExistsAPISpanish")
     iinf_destroy(inflectableConcept);
 }
 
+TEST_CASE("InflectableStringConceptTest-c#testCreateWithDefaults")
+{
+    auto error = U_ZERO_ERROR;
+    auto ccfp = ilccfp_getDefaultCommonConceptFactoryProvider(&error);
+    REQUIRE(U_SUCCESS(error));
+
+    const auto locale = ::inflection::util::LocaleUtils::SPANISH().getName().c_str();
+    auto ccf = ilccfp_getCommonConceptFactory(ccfp, locale, &error);
+    REQUIRE(U_SUCCESS(error));
+
+    auto model = iccf_getSemanticFeatureModel(ccf, &error);
+    REQUIRE(U_SUCCESS(error));
+
+    const std::u16string source = u"cometa";
+    auto sourceString = iss_create(source.c_str(), static_cast<int32_t>(source.size()), &error);
+    REQUIRE(U_SUCCESS(error));
+
+    IDDisplayValue_Constraint defaultConstraints[] = {
+        {u"gender", u"masculine"},
+    };
+
+    auto inflectableConcept = iinf_createWithDefaults(model,
+                                                      sourceString,
+                                                      defaultConstraints,
+                                                      static_cast<int32_t>(sizeof(defaultConstraints) / sizeof(defaultConstraints[0])),
+                                                      &error);
+    iss_destroy(sourceString);
+    REQUIRE(U_SUCCESS(error));
+    REQUIRE(inflectableConcept != nullptr);
+
+    auto semanticConcept = iinf_toSemanticFeatureConcept(inflectableConcept, &error);
+    REQUIRE(U_SUCCESS(error));
+
+    isfc_putConstraintByName(semanticConcept, u"definiteness", u"definite", -1, &error);
+    REQUIRE(U_SUCCESS(error));
+
+    auto printedValue = isfc_toSpeakableStringCopy(semanticConcept, &error);
+    REQUIRE(U_SUCCESS(error));
+    util::StringContainer<IDSpeakableString, iss_getPrint> printedContainer(printedValue);
+    REQUIRE(printedContainer);
+    CHECK(printedContainer.value == u"el cometa");
+    iss_destroy(printedValue);
+
+    auto genderValue = isfc_createFeatureValueByNameCopy(semanticConcept, u"gender", &error);
+    REQUIRE(U_SUCCESS(error));
+    util::StringContainer<IDSpeakableString, iss_getPrint> genderContainer(genderValue);
+    REQUIRE(genderContainer);
+    CHECK(genderContainer.value == u"masculine");
+    iss_destroy(genderValue);
+
+    auto numberValue = isfc_createFeatureValueByNameCopy(semanticConcept, u"number", &error);
+    REQUIRE(U_SUCCESS(error));
+    util::StringContainer<IDSpeakableString, iss_getPrint> numberContainer(numberValue);
+    REQUIRE(numberContainer);
+    CHECK(numberContainer.value == u"singular");
+    iss_destroy(numberValue);
+
+    auto definitenessValue = isfc_createFeatureValueByNameCopy(semanticConcept, u"definiteness", &error);
+    REQUIRE(U_SUCCESS(error));
+    util::StringContainer<IDSpeakableString, iss_getPrint> definitenessContainer(definitenessValue);
+    REQUIRE(definitenessContainer);
+    CHECK(definitenessContainer.value == u"definite");
+    iss_destroy(definitenessValue);
+
+    iinf_destroy(inflectableConcept);
+}
+
 TEST_CASE("InflectableStringConceptTest-c#testSpanish")
 {
     auto error = U_ZERO_ERROR;