Don't recreate PluralFormsCalculator needlessly

Add caching to PluralFormsExpr::calc() so that plural expressions are
only parsed once and the created calculator objects are reused.

This is MT safe, because the calculator, once constructed, is const and
doesn't modify its internal state.

Author: vslavik

src/language.cpp

@@ -803,12 +803,32 @@ int PluralFormsExpr::nplurals() const
 
 std::shared_ptr<PluralFormsCalculator> PluralFormsExpr::calc() const
 {
-    auto self = const_cast<PluralFormsExpr*>(this);
     if (m_calcCreated)
         return m_calc;
+
     if (!m_expr.empty())
-        self->m_calc = PluralFormsCalculator::make(m_expr.c_str());
-    self->m_calcCreated = true;
+    {
+        // There's typically only a few expressions used at runtime. Cache them to
+        // avoid unnecessary re-creation.
+        static std::unordered_map<std::string, std::shared_ptr<PluralFormsCalculator>> cache;
+        static std::mutex cacheMutex;
+
+        std::lock_guard<std::mutex> lock(cacheMutex);
+
+        auto it = cache.find(m_expr);
+        if (it != cache.end())
+        {
+            m_calc = it->second;
+        }
+        else
+        {
+            // Create new calculator and cache it
+            m_calc = PluralFormsCalculator::make(m_expr.c_str());
+            cache[m_expr] = m_calc;
+        }
+    }
+
+    m_calcCreated = true;
     return m_calc;
 }
 

src/language.h

@@ -235,8 +235,8 @@ class PluralFormsExpr
 
     std::string m_expr;
     mutable int m_nplurals;
-    bool m_calcCreated;
-    std::shared_ptr<PluralFormsCalculator> m_calc;
+    mutable bool m_calcCreated;
+    mutable std::shared_ptr<PluralFormsCalculator> m_calc;
 };
 
 #endif // Poedit_language_h