Remove FunctionFactory again

Author: catamorphism

icu4c/source/i18n/messageformat2.cpp

@@ -216,14 +216,13 @@ FunctionContext MessageFormatter::makeFunctionContext(const FunctionOptions& opt
     }
 
     // Look up the function name
-    FunctionFactory* functionFactory = lookupFunctionFactory(functionName, status);
+    Function* function = lookupFunction(functionName, status);
     if (U_FAILURE(status)) {
         // Function is unknown -- set error and use the fallback value
         status = U_ZERO_ERROR;
         context.getErrors().setUnknownFunction(functionName, status);
         return InternalValue::fallback(fallbackStr);
     }
-    LocalPointer<Function> function(functionFactory->createFunction(status));
     // Value is not a fallback, so we can safely call takeValue()
     LocalPointer<FunctionValue> functionArg(rand.takeValue(status));
     U_ASSERT(U_SUCCESS(status));

icu4c/source/i18n/messageformat2_formatter.cpp

@@ -122,22 +122,22 @@ namespace message2 {
         // Set up the standard function registry
         MFFunctionRegistry::Builder standardFunctionsBuilder(success);
 
-        LocalPointer<FunctionFactory> dateTime(StandardFunctions::DateTimeFactory::dateTime(success));
-        LocalPointer<FunctionFactory> date(StandardFunctions::DateTimeFactory::date(success));
-        LocalPointer<FunctionFactory> time(StandardFunctions::DateTimeFactory::time(success));
-        LocalPointer<FunctionFactory> number(StandardFunctions::NumberFactory::number(success));
-        LocalPointer<FunctionFactory> integer(StandardFunctions::NumberFactory::integer(success));
-        LocalPointer<FunctionFactory> string(StandardFunctions::StringFactory::string(success));
+        LocalPointer<Function> dateTime(StandardFunctions::DateTime::dateTime(success));
+        LocalPointer<Function> date(StandardFunctions::DateTime::date(success));
+        LocalPointer<Function> time(StandardFunctions::DateTime::time(success));
+        LocalPointer<Function> number(StandardFunctions::Number::number(success));
+        LocalPointer<Function> integer(StandardFunctions::Number::integer(success));
+        LocalPointer<Function> string(StandardFunctions::String::string(success));
         CHECK_ERROR(success);
-        standardFunctionsBuilder.adoptFunctionFactory(FunctionName(UnicodeString("datetime")),
+        standardFunctionsBuilder.adoptFunction(FunctionName(UnicodeString("datetime")),
                                                       dateTime.orphan(), success)
-            .adoptFunctionFactory(FunctionName(UnicodeString("date")), date.orphan(), success)
-            .adoptFunctionFactory(FunctionName(UnicodeString("time")), time.orphan(), success)
-            .adoptFunctionFactory(FunctionName(UnicodeString("number")),
+            .adoptFunction(FunctionName(UnicodeString("date")), date.orphan(), success)
+            .adoptFunction(FunctionName(UnicodeString("time")), time.orphan(), success)
+            .adoptFunction(FunctionName(UnicodeString("number")),
                                   number.orphan(), success)
-            .adoptFunctionFactory(FunctionName(UnicodeString("integer")),
+            .adoptFunction(FunctionName(UnicodeString("integer")),
                                   integer.orphan(), success)
-            .adoptFunctionFactory(FunctionName(UnicodeString("string")),
+            .adoptFunction(FunctionName(UnicodeString("string")),
                                   string.orphan(), success);
         CHECK_ERROR(success);
         standardMFFunctionRegistry = standardFunctionsBuilder.build();
@@ -225,17 +225,17 @@ namespace message2 {
         return standardMFFunctionRegistry.hasFunction(functionName);
     }
 
-    FunctionFactory*
-    MessageFormatter::lookupFunctionFactory(const FunctionName& functionName,
-                                            UErrorCode& status) const {
+    Function*
+    MessageFormatter::lookupFunction(const FunctionName& functionName,
+                                     UErrorCode& status) const {
         NULL_ON_ERROR(status);
 
         if (isBuiltInFunction(functionName)) {
             return standardMFFunctionRegistry.getFunction(functionName);
         }
         if (hasCustomMFFunctionRegistry()) {
             const MFFunctionRegistry& customMFFunctionRegistry = getCustomMFFunctionRegistry();
-            FunctionFactory* function = customMFFunctionRegistry.getFunction(functionName);
+            Function* function = customMFFunctionRegistry.getFunction(functionName);
             if (function != nullptr) {
                 return function;
             }

icu4c/source/i18n/messageformat2_function_registry.cpp

@@ -38,7 +38,6 @@ namespace message2 {
 
 // Function registry implementation
 
-FunctionFactory::~FunctionFactory() {}
 Function::~Function() {}
 FunctionValue::~FunctionValue() {}
 
@@ -52,9 +51,9 @@ MFFunctionRegistry MFFunctionRegistry::Builder::build() {
 }
 
 MFFunctionRegistry::Builder&
-MFFunctionRegistry::Builder::adoptFunctionFactory(const FunctionName& functionName,
-                                                  FunctionFactory* function,
-                                                  UErrorCode& errorCode) {
+MFFunctionRegistry::Builder::adoptFunction(const FunctionName& functionName,
+                                           Function* function,
+                                           UErrorCode& errorCode) {
     if (U_SUCCESS(errorCode)) {
         U_ASSERT(functions != nullptr);
         functions->put(functionName, function, errorCode);
@@ -100,9 +99,9 @@ MFFunctionRegistry::Builder::~Builder() {
 
 // Returns non-owned pointer. Returns pointer rather than reference because it can fail.
 // Returns non-const because Function is mutable.
-FunctionFactory* MFFunctionRegistry::getFunction(const FunctionName& functionName) const {
+Function* MFFunctionRegistry::getFunction(const FunctionName& functionName) const {
     U_ASSERT(functions != nullptr);
-    return static_cast<FunctionFactory*>(functions->get(functionName));
+    return static_cast<Function*>(functions->get(functionName));
 }
 
 UBool MFFunctionRegistry::getDefaultFormatterNameByType(const UnicodeString& type, FunctionName& name) const {
@@ -227,54 +226,19 @@ MFFunctionRegistry::~MFFunctionRegistry() {
 
 // --------- Number
 
-/* static */ StandardFunctions::NumberFactory*
-StandardFunctions::NumberFactory::integer(UErrorCode& success) {
-    return NumberFactory::create(true, success);
-}
-
-/* static */ StandardFunctions::NumberFactory*
-StandardFunctions::NumberFactory::number(UErrorCode& success) {
-    return NumberFactory::create(false, success);
-}
-
-/* static */ StandardFunctions::NumberFactory*
-StandardFunctions::NumberFactory::create(bool isInteger,
-                                         UErrorCode& success) {
-    NULL_ON_ERROR(success);
-
-    LocalPointer<NumberFactory> result(new NumberFactory(isInteger));
-    if (!result.isValid()) {
-        success = U_MEMORY_ALLOCATION_ERROR;
-        return nullptr;
-    }
-    return result.orphan();
-}
-
-Function*
-StandardFunctions::NumberFactory::createFunction(UErrorCode& errorCode) {
-    NULL_ON_ERROR(errorCode);
-
-    Number* result = new Number(isInteger);
-    if (result == nullptr) {
-        errorCode = U_MEMORY_ALLOCATION_ERROR;
-    }
-    return result;
-}
-
 /* static */ StandardFunctions::Number*
-StandardFunctions::Number::integer(const Locale& loc, UErrorCode& success) {
-    return create(loc, true, success);
+StandardFunctions::Number::integer(UErrorCode& success) {
+    return create(true, success);
 }
 
 /* static */ StandardFunctions::Number*
-StandardFunctions::Number::number(const Locale& loc, UErrorCode& success) {
-    return create(loc, false, success);
+StandardFunctions::Number::number(UErrorCode& success) {
+    return create(false, success);
 }
 
 /* static */ StandardFunctions::Number*
-StandardFunctions::Number::create(const Locale& loc, bool isInteger, UErrorCode& success) {
+StandardFunctions::Number::create(bool isInteger, UErrorCode& success) {
     NULL_ON_ERROR(success);
-    (void) loc;
 
     LocalPointer<Number> result(new Number(isInteger));
     if (!result.isValid()) {
@@ -622,7 +586,6 @@ UnicodeString StandardFunctions::NumberValue::formatToString(UErrorCode& errorCo
     return formattedNumber.toString(errorCode);
 }
 
-StandardFunctions::NumberFactory::~NumberFactory() {}
 StandardFunctions::Number::~Number() {}
 StandardFunctions::NumberValue::~NumberValue() {}
 
@@ -728,59 +691,23 @@ void StandardFunctions::NumberValue::selectKeys(const UnicodeString* keys,
 
 // --------- DateTime
 
-/*
-// Date/time options only
-static UnicodeString defaultForOption(const UnicodeString& optionName) {
-    if (optionName == UnicodeString("dateStyle")
-        || optionName == UnicodeString("timeStyle")
-        || optionName == UnicodeString("style")) {
-        return UnicodeString("short");
-    }
-    return {}; // Empty string is default
-}
-*/
-
-/* static */ StandardFunctions::DateTimeFactory*
-StandardFunctions::DateTimeFactory::date(UErrorCode& success) {
-    return DateTimeFactory::create(DateTimeType::kDate, success);
-}
-
-/* static */ StandardFunctions::DateTimeFactory*
-StandardFunctions::DateTimeFactory::time(UErrorCode& success) {
-    return DateTimeFactory::create(DateTimeType::kTime, success);
-}
-
-/* static */ StandardFunctions::DateTimeFactory*
-StandardFunctions::DateTimeFactory::dateTime(UErrorCode& success) {
-    return DateTimeFactory::create(DateTimeType::kDateTime, success);
+/* static */ StandardFunctions::DateTime*
+StandardFunctions::DateTime::date(UErrorCode& success) {
+    return DateTime::create(DateTimeType::kDate, success);
 }
 
-/* static */ StandardFunctions::DateTimeFactory*
-StandardFunctions::DateTimeFactory::create(DateTimeFactory::DateTimeType type,
-                                           UErrorCode& success) {
-    NULL_ON_ERROR(success);
-
-    LocalPointer<DateTimeFactory> result(new DateTimeFactory(type));
-    if (!result.isValid()) {
-        success = U_MEMORY_ALLOCATION_ERROR;
-        return nullptr;
-    }
-    return result.orphan();
+/* static */ StandardFunctions::DateTime*
+StandardFunctions::DateTime::time(UErrorCode& success) {
+    return DateTime::create(DateTimeType::kTime, success);
 }
 
-Function*
-StandardFunctions::DateTimeFactory::createFunction(UErrorCode& errorCode) {
-    NULL_ON_ERROR(errorCode);
-
-    DateTime* result = new DateTime(type);
-    if (result == nullptr) {
-        errorCode = U_MEMORY_ALLOCATION_ERROR;
-    }
-    return result;
+/* static */ StandardFunctions::DateTime*
+StandardFunctions::DateTime::dateTime(UErrorCode& success) {
+    return DateTime::create(DateTimeType::kDateTime, success);
 }
 
 /* static */ StandardFunctions::DateTime*
-StandardFunctions::DateTime::create(DateTimeFactory::DateTimeType type,
+StandardFunctions::DateTime::create(DateTime::DateTimeType type,
                                     UErrorCode& success) {
     NULL_ON_ERROR(success);
 
@@ -838,7 +765,7 @@ UnicodeString StandardFunctions::DateTimeValue::formatToString(UErrorCode& statu
     return formattedDate;
 }
 
-StandardFunctions::DateTimeValue::DateTimeValue(DateTimeFactory::DateTimeType type,
+StandardFunctions::DateTimeValue::DateTimeValue(DateTime::DateTimeType type,
                                                 const FunctionContext& context,
                                                 FunctionValue& val,
                                                 FunctionOptions&& options,
@@ -873,7 +800,7 @@ StandardFunctions::DateTimeValue::DateTimeValue(DateTimeFactory::DateTimeType ty
     bool hasTimeStyleOption = timeStyleOption.length() > 0;
     bool noOptions = opts.optionsCount() == 0;
 
-    using DateTimeType = DateTimeFactory::DateTimeType;
+    using DateTimeType = DateTime::DateTimeType;
 
     bool useStyle = (type == DateTimeType::kDateTime
                      && (hasDateStyleOption || hasTimeStyleOption
@@ -1090,24 +1017,11 @@ StandardFunctions::DateTimeValue::DateTimeValue(DateTimeFactory::DateTimeType ty
     formattedDate = result;
 }
 
-StandardFunctions::DateTimeFactory::~DateTimeFactory() {}
 StandardFunctions::DateTime::~DateTime() {}
 StandardFunctions::DateTimeValue::~DateTimeValue() {}
 
 // --------- String
 
-/* static */ StandardFunctions::StringFactory*
-StandardFunctions::StringFactory::string(UErrorCode& success) {
-    NULL_ON_ERROR(success);
-
-    LocalPointer<StringFactory> result(new StringFactory());
-    if (!result.isValid()) {
-        success = U_MEMORY_ALLOCATION_ERROR;
-        return nullptr;
-    }
-    return result.orphan();
-}
-
 /* static */ StandardFunctions::String*
 StandardFunctions::String::string(UErrorCode& success) {
     NULL_ON_ERROR(success);
@@ -1120,17 +1034,6 @@ StandardFunctions::String::string(UErrorCode& success) {
     return result.orphan();
 }
 
-Function*
-StandardFunctions::StringFactory::createFunction(UErrorCode& errorCode) {
-    NULL_ON_ERROR(errorCode);
-
-    String* result = new String();
-    if (result == nullptr) {
-        errorCode = U_MEMORY_ALLOCATION_ERROR;
-    }
-    return result;
-}
-
 extern UnicodeString formattableToString(const Locale&,
                                          const UBiDiDirection,
                                          const Formattable&,
@@ -1185,7 +1088,6 @@ void StandardFunctions::StringValue::selectKeys(const UnicodeString* keys,
     }
 }
 
-StandardFunctions::StringFactory::~StringFactory() {}
 StandardFunctions::String::~String() {}
 StandardFunctions::StringValue::~StringValue() {}