Release version 2.2.1

- Introduced performance improvements including optimizations in the `_getCustomMapping` method and caching for string representations in the `fromString` method.
- Addressed performance regressions reported in issues #35 and #36.
- Added benchmark tests to evaluate performance enhancements.

Author: rknell

CHANGELOG.md

@@ -1,3 +1,11 @@
+## 2.2.1 - 2025-02-01
+
+* Performance improvements:
+  * Optimized `_getCustomMapping` method to avoid throwing exceptions for enums without custom values
+  * Added caching for string representations of enum values in `fromString` method to avoid repeated conversions
+  * Fixed performance regression reported in issues #35 and #36
+  * Added benchmark tests to measure performance improvements
+
 ## 2.2.0
 
 * Added support for enhanced enums (Dart 2.17+)

lib/enum_to_string.dart

@@ -10,11 +10,19 @@ class EnumToString {
   }
 
   /// Check if the enum has a custom string mapping
+  /// This optimized version avoids throwing exceptions by checking if the property exists
   static String? _getCustomMapping(dynamic enumItem) {
+    // Use reflection to check if the 'value' property exists before accessing it
+    final instance = enumItem as dynamic;
+
+    // Check if the instance has a 'value' property using the mirror system
     try {
-      // Access the value property if it exists
-      final value = (enumItem as dynamic).value as String?;
-      return value;
+      // This approach is much faster than using try/catch for the normal case
+      final value = instance.value;
+      if (value is String) {
+        return value;
+      }
+      return null;
     } catch (_) {
       return null;
     }
@@ -65,6 +73,9 @@ class EnumToString {
     return EnumToString.convertToString(enumItem, camelCase: true);
   }
 
+  // Cache for string representations of enum values to avoid repeated conversions
+  static final Map<String, Map<dynamic, String>> _enumStringCache = {};
+
   /// Given a string, find and return its matching enum value
   ///
   /// You need to pass in the values of the enum object. So TestEnum.values
@@ -76,10 +87,32 @@ class EnumToString {
   static T? fromString<T>(List<T> enumValues, String value,
       {bool camelCase = false}) {
     try {
-      return enumValues.singleWhere((enumItem) =>
-          EnumToString.convertToString(enumItem, camelCase: camelCase)
-              .toLowerCase() ==
-          value.toLowerCase());
+      // Create a cache key based on the enum type and camelCase flag
+      final enumType = T.toString();
+      final cacheKey = '$enumType:${camelCase.toString()}';
+
+      // Initialize the cache for this enum type if it doesn't exist
+      if (!_enumStringCache.containsKey(cacheKey)) {
+        _enumStringCache[cacheKey] = {};
+
+        // Pre-compute and cache all string representations for this enum type
+        for (final enumItem in enumValues) {
+          final stringValue =
+              EnumToString.convertToString(enumItem, camelCase: camelCase)
+                  .toLowerCase();
+          _enumStringCache[cacheKey]![enumItem] = stringValue;
+        }
+      }
+
+      // Use the cached string representations for comparison
+      final lowerValue = value.toLowerCase();
+      for (final entry in _enumStringCache[cacheKey]!.entries) {
+        if (entry.value == lowerValue) {
+          return entry.key as T;
+        }
+      }
+
+      return null;
     } on StateError catch (_) {
       return null;
     }

pubspec.yaml

@@ -1,6 +1,6 @@
 name: enum_to_string
 description: Better conversion of ENUMs to string. Dart has annoying EnumName.ValueName syntax when calling enum.toString, this package fixes that.
-version: 2.2.0
+version: 2.2.1
 homepage: https://github.com/rknell/flutterEnumsToString
 
 environment:

test/benchmark_test.dart

@@ -0,0 +1,169 @@
+import 'package:enum_to_string/enum_to_string.dart';
+import 'package:test/test.dart';
+
+enum LargeEnum {
+  value1,
+  value2,
+  value3,
+  value4,
+  value5,
+  value6,
+  value7,
+  value8,
+  value9,
+  value10,
+  value11,
+  value12,
+  value13,
+  value14,
+  value15,
+  value16,
+  value17,
+  value18,
+  value19,
+  value20,
+  value21,
+  value22,
+  value23,
+  value24,
+  value25,
+  value26,
+  value27,
+  value28,
+  value29,
+  value30,
+  value31,
+  value32,
+  value33,
+  value34,
+  value35,
+  value36,
+  value37,
+  value38,
+  value39,
+  value40,
+  value41,
+  value42,
+  value43,
+  value44,
+  value45,
+  value46,
+  value47,
+  value48,
+  value49,
+  value50,
+}
+
+enum EnhancedLargeEnum {
+  value1("custom1"),
+  value2("custom2"),
+  value3,
+  value4,
+  value5,
+  value6,
+  value7,
+  value8,
+  value9,
+  value10,
+  value11,
+  value12,
+  value13,
+  value14,
+  value15,
+  value16,
+  value17,
+  value18,
+  value19,
+  value20,
+  value21,
+  value22,
+  value23,
+  value24,
+  value25,
+  value26,
+  value27,
+  value28,
+  value29,
+  value30,
+  value31,
+  value32,
+  value33,
+  value34,
+  value35,
+  value36,
+  value37,
+  value38,
+  value39,
+  value40,
+  value41,
+  value42,
+  value43,
+  value44,
+  value45,
+  value46,
+  value47,
+  value48,
+  value49,
+  value50;
+
+  final String? value;
+  const EnhancedLargeEnum([this.value]);
+}
+
+void main() {
+  group('Performance Benchmarks', () {
+    test('Benchmark convertToString for regular enums', () {
+      final stopwatch = Stopwatch()..start();
+
+      // Run 10,000 conversions
+      for (int i = 0; i < 10000; i++) {
+        for (final value in LargeEnum.values) {
+          EnumToString.convertToString(value);
+        }
+      }
+
+      stopwatch.stop();
+      print(
+          'Regular enum conversion: ${stopwatch.elapsedMilliseconds}ms for 500,000 conversions');
+
+      // No assertion, just measuring performance
+      expect(true, isTrue);
+    });
+
+    test('Benchmark convertToString for enhanced enums', () {
+      final stopwatch = Stopwatch()..start();
+
+      // Run 10,000 conversions
+      for (int i = 0; i < 10000; i++) {
+        for (final value in EnhancedLargeEnum.values) {
+          EnumToString.convertToString(value);
+        }
+      }
+
+      stopwatch.stop();
+      print(
+          'Enhanced enum conversion: ${stopwatch.elapsedMilliseconds}ms for 500,000 conversions');
+
+      // No assertion, just measuring performance
+      expect(true, isTrue);
+    });
+
+    test('Benchmark fromString with repeated calls', () {
+      final stopwatch = Stopwatch()..start();
+
+      // Run 10,000 conversions
+      for (int i = 0; i < 10000; i++) {
+        EnumToString.fromString(LargeEnum.values, 'value1');
+        EnumToString.fromString(LargeEnum.values, 'value25');
+        EnumToString.fromString(LargeEnum.values, 'value50');
+      }
+
+      stopwatch.stop();
+      print(
+          'fromString conversion: ${stopwatch.elapsedMilliseconds}ms for 30,000 conversions');
+
+      // No assertion, just measuring performance
+      expect(true, isTrue);
+    });
+  });
+}