[ui/base;css] adding string template expression replacement

base/strings/string_util.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/strings/string_util.h"
 
 #include <ctype.h>
 #include <errno.h>
 #include <math.h>
 #include <stdarg.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <time.h>
 #include <wchar.h>
 #include <wctype.h>
 
 #include <algorithm>
+#include <map>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/memory/singleton.h"
 #include "base/strings/string_split.h"
 #include "base/strings/utf_string_conversion_utils.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/third_party/icu/icu_utf.h"
 #include "build/build_config.h"
@@ skipping 833 matching lines @@
 std::string JoinString(const std::vector<std::string>& parts,
                        const std::string& separator) {
   return JoinStringT(parts, separator);
 }
 
 string16 JoinString(const std::vector<string16>& parts,
                     const string16& separator) {
   return JoinStringT(parts, separator);
 }
 
-template<class FormatStringType, class OutStringType>
-OutStringType DoReplaceStringPlaceholders(const FormatStringType& format_string,
-    const std::vector<OutStringType>& subst, std::vector<size_t>* offsets) {
+template <class FormatStringType, class OutStringType>
+OutStringType DoReplaceStringPlaceholders(
+    const FormatStringType& format_string,
+    const std::map<std::string, OutStringType>& subst) {
+  OutStringType formatted;
+  const size_t kValueLengthGuess = 16;
+  formatted.reserve(format_string.length() + subst.size() * kValueLengthGuess);
+  for (typename FormatStringType::const_iterator i = format_string.begin();
+       i != format_string.end(); ++i) {

[Dan Beam, 2015/07/07 02:23:31]

please remove auto-increment, IMO

[dschuyler, 2015/07/07 23:05:30]

Done.

+    if (*i == '$') {
+      if (i + 1 != format_string.end()) {
+        ++i;
+        if (*i == '{') {
+          std::string index;
+          ++i;
+          while (i != format_string.end() && *i != '}') {
+            index.push_back(*i);
+            ++i;
+          }
+          const auto& replacement = subst.find(index);
+          if (replacement != subst.end())
+            formatted.append(replacement->second);
+        } else if (*i == '$') {
+          while (i != format_string.end() && *i == '$') {
+            formatted.push_back('$');
+            ++i;
+          }
+          --i;
+        }
+      }
+    } else {
+      formatted.push_back(*i);
+    }
+  }
+  return formatted;
+}
+
+std::string ReplaceStringPlaceholders(
+    const std::string& format_string,
+    const std::map<std::string, std::string>& subst) {
+  return DoReplaceStringPlaceholders(format_string, subst);
+}
+
+template <class FormatStringType, class OutStringType>
+OutStringType DoReplaceStringPlaceholders(
+    const FormatStringType& format_string,
+    const std::vector<OutStringType>& subst,
+    std::vector<size_t>* offsets) {
   size_t substitutions = subst.size();
-
   size_t sub_length = 0;
   for (typename std::vector<OutStringType>::const_iterator iter = subst.begin();
        iter != subst.end(); ++iter) {
     sub_length += iter->length();
   }
 
   OutStringType formatted;
   formatted.reserve(format_string.length() + sub_length);
 
   std::vector<ReplacementOffset> r_offsets;
@@ skipping 93 matching lines @@
 }
 
 }  // namespace
 
 size_t base::strlcpy(char* dst, const char* src, size_t dst_size) {
   return lcpyT<char>(dst, src, dst_size);
 }
 size_t base::wcslcpy(wchar_t* dst, const wchar_t* src, size_t dst_size) {
   return lcpyT<wchar_t>(dst, src, dst_size);
 }