From: jh9216.park <jh9216.park@samsung.com>
Date: Thu, 2 Dec 2021 04:58:53 +0000 (-0500)
Subject: Add ReplaceAll() using std::initialize_list<>
X-Git-Tag: accepted/tizen/unified/20220216.010312~18
X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=9e9c3a04929bb8601efbe8eef40eaa5a87a6b23b;p=platform%2Fcore%2Fappfw%2Ftidl.git

Add ReplaceAll() using std::initialize_list<>

Change-Id: I1d3060de7800ea19f593625485232e77992cede9
Signed-off-by: jh9216.park <jh9216.park@samsung.com>
---

diff --git a/idlc/gen/c_body_gen_base.cc b/idlc/gen/c_body_gen_base.cc
index 9581afa..b9f0b40 100644
--- a/idlc/gen/c_body_gen_base.cc
+++ b/idlc/gen/c_body_gen_base.cc
@@ -122,14 +122,15 @@ void CBodyGeneratorBase::GenStructureDef(std::ofstream& stream,
 // @see #CB_STRUCTURE_ARRAY_DEF
 void CBodyGeneratorBase::GenStructureArrayDef(std::ofstream& stream,
     const Structure& st) {
-  std::string code = ReplaceAll(CB_STRUCTURE_ARRAY_DEF, "<PREFIX>",
-      GetHandlePrefix());
-  code = ReplaceAll(code, "<NAME>", st.GetID());
-
   auto& elm = st.GetElements().GetElms().front();
   auto& type = elm->GetType();
   auto element_type = GetDataTypeString(type, false);
-  code = ReplaceAll(code, "<ELEMENT_TYPE>", element_type);
+
+  std::string code = ReplaceAll(CB_STRUCTURE_ARRAY_DEF, {
+      { "<PREFIX>", GetHandlePrefix() },
+      { "<NAME>", st.GetID() },
+      { "<ELEMENT_TYPE>", element_type }
+  });
 
   stream << SmartIndent(code);
 }
@@ -137,9 +138,10 @@ void CBodyGeneratorBase::GenStructureArrayDef(std::ofstream& stream,
 // @see #CB_STRUCTURE_LIST_DEF
 void CBodyGeneratorBase::GenStructureListDef(std::ofstream& stream,
     const Structure& st) {
-  std::string code = ReplaceAll(CB_STRUCTURE_LIST_DEF, "<PREFIX>",
-      GetHandlePrefix());
-  code = ReplaceAll(code, "<NAME>", st.GetID());
+  std::string code = ReplaceAll(CB_STRUCTURE_LIST_DEF, {
+      { "<PREFIX>", GetHandlePrefix() },
+      { "<NAME>", st.GetID() }
+  });
 
   stream << SmartIndent(code);
 }
@@ -147,12 +149,12 @@ void CBodyGeneratorBase::GenStructureListDef(std::ofstream& stream,
 // @see #CB_STRUCTURE_BASE_DEF
 void CBodyGeneratorBase::GenStructureBaseDef(std::ofstream& stream,
     const Structure& st) {
-  std::string code = ReplaceAll(CB_STRUCTURE_BASE_DEF, "<PREFIX>",
-      GetHandlePrefix());
-  code = ReplaceAll(code, "<NAME>", st.GetID());
-
   auto& elms = st.GetElements();
-  code = ReplaceAll(code, "<ELEMENTS>", GenBaseElements(elms));
+  std::string code = ReplaceAll(CB_STRUCTURE_BASE_DEF, {
+      { "<PREFIX>", GetHandlePrefix() },
+      { "<NAME>", st.GetID() },
+      { "<ELEMENTS>", GenBaseElements(elms) }
+  });
 
   stream << SmartIndent(code);
 }
@@ -259,26 +261,25 @@ std::string CBodyGeneratorBase::GenArrayElementsFree(
 // @see #CB_STRUCTURE_ARRAY_BASE
 void CBodyGeneratorBase::GenStructureArrayBase(std::ofstream& stream,
     const Structure& st) {
-  std::string code = ReplaceAll(CB_STRUCTURE_ARRAY_BASE, "<PREFIX>",
-      GetHandlePrefix());
-  code = ReplaceAll(code, "<NAME>", st.GetID());
-
   auto& elm = st.GetElements().GetElms().front();
-  code = ReplaceAll(code, "<PARCEL_WRITE>", GenArrayParcelWrite(elm));
-  code = ReplaceAll(code, "<PARCEL_READ>", GenArrayParcelRead(elm));
-
   auto& type = elm->GetType();
-  auto param_type = GetParamTypeString(ParameterType::Direction::IN, type);
-  code = ReplaceAll(code, "<PARAM_TYPE_IN>", param_type);
-  param_type = GetParamTypeString(ParameterType::Direction::OUT, type);
-  code = ReplaceAll(code, "<PARAM_TYPE_OUT>", param_type);
-
+  auto param_type_in = GetParamTypeString(ParameterType::Direction::IN, type);
+  auto param_type_out = GetParamTypeString(ParameterType::Direction::OUT, type);
   auto element_type = GetDataTypeString(type, false);
-  code = ReplaceAll(code, "<ELEMENT_TYPE>", element_type);
   auto element_type_size = GetDataTypeString(type, false);
   element_type_size = RemoveLastSpaces(element_type_size);
-  code = ReplaceAll(code, "<ELEMENT_TYPE_SIZE>", element_type_size);
-  code = ReplaceAll(code, "<ELEMENTS_FREE>", GenArrayElementsFree(elm));
+
+  std::string code = ReplaceAll(CB_STRUCTURE_ARRAY_BASE, {
+      { "<PREFIX>", GetHandlePrefix() },
+      { "<NAME>", st.GetID() },
+      { "<PARCEL_WRITE>", GenArrayParcelWrite(elm) },
+      { "<PARCEL_READ>", GenArrayParcelRead(elm) },
+      { "<PARAM_TYPE_IN>", param_type_in },
+      { "<PARAM_TYPE_OUT>", param_type_out },
+      { "<ELEMENT_TYPE>", element_type },
+      { "<ELEMENT_TYPE_SIZE>", element_type_size },
+      { "<ELEMENTS_FREE>", GenArrayElementsFree(elm) }
+  });
 
   stream << SmartIndent(code);
 }
@@ -408,24 +409,21 @@ std::string CBodyGeneratorBase::GenListCallbackParamType(
 // @see #CB_STRUCTURE_LIST_BASE
 void CBodyGeneratorBase::GenStructureListBase(std::ofstream& stream,
     const Structure& st) {
-  std::string code = ReplaceAll(CB_STRUCTURE_LIST_BASE, "<PREFIX>",
-      GetHandlePrefix());
-  code = ReplaceAll(code, "<NAME>", st.GetID());
-
   auto& elm = st.GetElements().GetElms().front();
   auto& type = elm->GetType();
-  code = ReplaceAll(code, "<DATA_TYPE>", GetDataTypeString(type, true));
-  code = ReplaceAll(code, "<DATA_FREE>", GenListDataFree(elm));
-
   auto param_type = GetParamTypeString(ParameterType::Direction::IN, type);
-  code = ReplaceAll(code, "<PARAM_TYPE_IN>", param_type);
-
-  code = ReplaceAll(code, "<PARCEL_WRITE>", GenListParcelWrite(elm));
-  code = ReplaceAll(code, "<PARCEL_READ>", GenListParcelRead(elm));
 
-  code = ReplaceAll(code, "<LIST_ADD>", GenListAdd(elm));
-  code = ReplaceAll(code, "<CALLBACK_PARAM_TYPE>",
-      GenListCallbackParamType(elm));
+  std::string code = ReplaceAll(CB_STRUCTURE_LIST_BASE, {
+      { "<PREFIX>", GetHandlePrefix() },
+      { "<NAME>", st.GetID() },
+      { "<DATA_TYPE>", GetDataTypeString(type, true) },
+      { "<DATA_FREE>", GenListDataFree(elm) },
+      { "<PARAM_TYPE_IN>", param_type },
+      { "<PARCEL_WRITE>", GenListParcelWrite(elm) },
+      { "<PARCEL_READ>", GenListParcelRead(elm) },
+      { "<LIST_ADD>", GenListAdd(elm) },
+      { "<CALLBACK_PARAM_TYPE>", GenListCallbackParamType(elm) }
+  });
 
   stream << SmartIndent(code);
 }
@@ -617,20 +615,20 @@ std::string CBodyGeneratorBase::GenBaseSetGet(const std::string& name,
     const Elements& elms) {
   std::string code;
   for (auto& elm : elms.GetElms()) {
-    std::string set_get_code = ReplaceAll(CB_STRUCTURE_BASE_SET_GET,
-        "<PREFIX>", GetHandlePrefix());
-    set_get_code = ReplaceAll(set_get_code, "<NAME>", name);
-    set_get_code = ReplaceAll(set_get_code, "<ELEMENT_NAME>", elm->GetID());
-
     auto& type = elm->GetType();
     auto param_type_in = GetParamTypeString(ParameterType::Direction::IN, type);
-    set_get_code = ReplaceAll(set_get_code, "<PARAM_TYPE_IN>", param_type_in);
     auto param_type_out = GetParamTypeString(ParameterType::Direction::OUT,
         type);
-    set_get_code = ReplaceAll(set_get_code, "<PARAM_TYPE_OUT>", param_type_out);
 
-    set_get_code = ReplaceAll(set_get_code, "<BASE_SET>", GenBaseSet(elm));
-    set_get_code = ReplaceAll(set_get_code, "<BASE_GET>", GenBaseGet(elm));
+    std::string set_get_code = ReplaceAll(CB_STRUCTURE_BASE_SET_GET, {
+        { "<PREFIX>", GetHandlePrefix() },
+        { "<NAME>", name },
+        { "<ELEMENT_NAME>", elm->GetID() },
+        { "<PARAM_TYPE_IN>", param_type_in },
+        { "<PARAM_TYPE_OUT>", param_type_out },
+        { "<BASE_SET>", GenBaseSet(elm) },
+        { "<BASE_GET>", GenBaseGet(elm) }
+    });
 
     code += set_get_code;
   }
@@ -641,18 +639,17 @@ std::string CBodyGeneratorBase::GenBaseSetGet(const std::string& name,
 // @see #CB_STRUCTURE_BASE
 void CBodyGeneratorBase::GenStructureBase(std::ofstream& stream,
     const Structure& st) {
-  std::string code = ReplaceAll(CB_STRUCTURE_BASE, "<PREFIX>",
-      GetHandlePrefix());
-  code = ReplaceAll(code, "<NAME>", st.GetID());
-
   auto& elms = st.GetElements();
-  code = ReplaceAll(code, "<ELEMENTS_FREE>", GenBaseElementsFree(elms));
 
-  code = ReplaceAll(code, "<PARCEL_WRITE>", GenBaseParcelWrite(elms));
-  code = ReplaceAll(code, "<PARCEL_READ>", GenBaseParcelRead(elms));
+  std::string code = ReplaceAll(CB_STRUCTURE_BASE, {
+      { "<PREFIX>", GetHandlePrefix() },
+      { "<NAME>", st.GetID() },
+      { "<ELEMENTS_FREE>", GenBaseElementsFree(elms) },
+      { "<PARCEL_WRITE>", GenBaseParcelWrite(elms) },
+      { "<PARCEL_READ>", GenBaseParcelRead(elms) }
+  });
 
   code += GenBaseSetGet(st.GetID(), elms);
-
   stream << SmartIndent(code);
 }
 
diff --git a/idlc/gen/c_header_gen_base.cc b/idlc/gen/c_header_gen_base.cc
index 8c4d015..a0bb243 100644
--- a/idlc/gen/c_header_gen_base.cc
+++ b/idlc/gen/c_header_gen_base.cc
@@ -101,26 +101,28 @@ void CHeaderGeneratorBase::GenStructures(std::ofstream& stream) {
 // @see #CB_STRUCTURE_HANDLE
 void CHeaderGeneratorBase::GenStructureHandle(std::ofstream& stream,
     const Structure& st) {
-  std::string str = ReplaceAll(CB_STRUCTURE_HANDLE, "<PREFIX>",
-      GetHandlePrefix());
-  str = ReplaceAll(str, "<NAME>", st.GetID());
+  std::string str = ReplaceAll(CB_STRUCTURE_HANDLE, {
+      { "<PREFIX>", GetHandlePrefix() },
+      { "<NAME>", st.GetID() }
+  });
+
   stream << SmartIndent(str);
 }
 
 // @see #CB_STRUCTURE_ARRAY_BASE
 void CHeaderGeneratorBase::GenStructureArrayBase(std::ofstream& stream,
     const Structure& st) {
-  std::string str = ReplaceAll(CB_STRUCTURE_ARRAY_BASE, "<PREFIX>",
-      GetHandlePrefix());
-  str = ReplaceAll(str, "<NAME>", st.GetID());
-
   auto& elm = st.GetElements().GetElms().front();
   auto& type = elm->GetType();
-  auto param_type = GetParamTypeString(ParameterType::Direction::IN, type);
-  str = ReplaceAll(str, "<PARAM_TYPE_IN>", param_type);
+  auto param_type_in = GetParamTypeString(ParameterType::Direction::IN, type);
+  auto param_type_out = GetParamTypeString(ParameterType::Direction::OUT, type);
 
-  param_type = GetParamTypeString(ParameterType::Direction::OUT, type);
-  str = ReplaceAll(str, "<PARAM_TYPE_OUT>", param_type);
+  std::string str = ReplaceAll(CB_STRUCTURE_ARRAY_BASE, {
+      { "<PREFIX>", GetHandlePrefix() },
+      { "<NAME>", st.GetID() },
+      { "<PARAM_TYPE_IN>", param_type_in },
+      { "<PARAM_TYPE_OUT>", param_type_out }
+  });
 
   stream << SmartIndent(str);
 }
@@ -128,14 +130,16 @@ void CHeaderGeneratorBase::GenStructureArrayBase(std::ofstream& stream,
 // @see #CB_STRUCTURE_LIST_BASE
 void CHeaderGeneratorBase::GenStructureListBase(std::ofstream& stream,
     const Structure& st) {
-  std::string str = ReplaceAll(CB_STRUCTURE_LIST_BASE, "<PREFIX>",
-      GetHandlePrefix());
-  str = ReplaceAll(str, "<NAME>", st.GetID());
-
   auto& elm = st.GetElements().GetElms().front();
   auto& type = elm->GetType();
   auto param_type = GetParamTypeString(ParameterType::Direction::IN, type);
-  str = ReplaceAll(str, "<PARAM_TYPE_IN>", param_type);
+
+  std::string str = ReplaceAll(CB_STRUCTURE_LIST_BASE, {
+      { "<PREFIX>", GetHandlePrefix() },
+      { "<NAME>", st.GetID() },
+      { "<PARAM_TYPE_IN>", param_type }
+  });
+
   stream << SmartIndent(str);
 }
 
@@ -148,16 +152,18 @@ void CHeaderGeneratorBase::GenStructureBase(std::ofstream& stream,
   stream << SmartIndent(str);
 
   for (auto& e : st.GetElements().GetElms()) {
-    str = ReplaceAll(CB_STRUCTURE_BASE_SET_GET, "<PREFIX>", GetHandlePrefix());
-    str = ReplaceAll(str, "<NAME>", st.GetID());
-
     auto& type = e->GetType();
-    auto param_type = GetParamTypeString(ParameterType::Direction::IN, type);
-    str = ReplaceAll(str, "<PARAM_TYPE_IN>", param_type);
+    auto param_type_in = GetParamTypeString(ParameterType::Direction::IN, type);
+    auto param_type_out = GetParamTypeString(ParameterType::Direction::OUT, type);
+
+    str = ReplaceAll(CB_STRUCTURE_BASE_SET_GET, {
+        { "<PREFIX>", GetHandlePrefix() },
+        { "<NAME>", st.GetID() },
+        { "<PARAM_TYPE_IN>", param_type_in },
+        { "<PARAM_TYPE_OUT>", param_type_out },
+        { "<ELEMENT_NAME>", e->GetID() }
+    });
 
-    param_type = GetParamTypeString(ParameterType::Direction::OUT, type);
-    str = ReplaceAll(str, "<PARAM_TYPE_OUT>", param_type);
-    str = ReplaceAll(str, "<ELEMENT_NAME>", e->GetID());
     stream << SmartIndent(str);
   }
 }
diff --git a/idlc/gen/c_proxy_body_gen.cc b/idlc/gen/c_proxy_body_gen.cc
index 5c3980f..9eac4a9 100644
--- a/idlc/gen/c_proxy_body_gen.cc
+++ b/idlc/gen/c_proxy_body_gen.cc
@@ -76,10 +76,11 @@ void CProxyBodyGen::GenInterfaceDef(std::ofstream& stream,
 // @see #CB_INTERFACE_DELEGATE_DEF
 void CProxyBodyGen::GenInterfaceDelegateDef(std::ofstream& stream,
     const Interface& iface, const Declaration& decl) {
-  std::string code = ReplaceAll(CB_INTERFACE_DELEGATE_DEF, "<PREFIX>",
-      GetHandlePrefix());
-  code = ReplaceAll(code, "<NAME>", iface.GetID());
-  code = ReplaceAll(code, "<DELEGATE_NAME>", decl.GetID());
+  std::string code = ReplaceAll(CB_INTERFACE_DELEGATE_DEF, {
+      { "<PREFIX>", GetHandlePrefix() },
+      { "<NAME>", iface.GetID() },
+      { "<DELEGATE_NAME>", decl.GetID() }
+  });
 
   stream << SmartIndent(code);
 }
@@ -87,9 +88,10 @@ void CProxyBodyGen::GenInterfaceDelegateDef(std::ofstream& stream,
 // @see #CB_INTERFACE_BASE_DEF
 void CProxyBodyGen::GenInterfaceBaseDef(std::ofstream& stream,
     const Interface& iface) {
-  std::string code = ReplaceAll(CB_INTERFACE_BASE_DEF, "<PREFIX>",
-      GetHandlePrefix());
-  code = ReplaceAll(code, "<NAME>", iface.GetID());
+  std::string code = ReplaceAll(CB_INTERFACE_BASE_DEF, {
+      { "<PREFIX>", GetHandlePrefix() },
+      { "<NAME>", iface.GetID() }
+  });
 
   stream << SmartIndent(code);
 }
@@ -160,10 +162,11 @@ void CProxyBodyGen::GenInterfaceDelegateEnumBase(std::ofstream& stream,
     return;
 
   std::transform(enums.begin(), enums.end(), enums.begin(), ::toupper);
-  std::string code = ReplaceAll(CB_INTERFACE_DELEGATE_ENUM_BASE, "<ENUMS>",
-      enums);
-  code = ReplaceAll(code, "<PREFIX>", GetHandlePrefix());
-  code = ReplaceAll(code, "<NAME>", iface.GetID());
+  std::string code = ReplaceAll(CB_INTERFACE_DELEGATE_ENUM_BASE, {
+      { "<ENUMS>", enums },
+      { "<PREFIX>", GetHandlePrefix() },
+      { "<NAME>", iface.GetID() }
+  });
 
   stream << SmartIndent(code);
 }
@@ -270,27 +273,24 @@ std::string CProxyBodyGen::GenDelegateCallbackArgs(const Declaration& decl) {
 // @see CB_INTERFACE_DELEGATE_BASE
 void CProxyBodyGen::GenInterfaceDelegateBase(std::ofstream& stream,
     const Interface& iface, const Declaration& decl) {
-  std::string code = ReplaceAll(CB_INTERFACE_DELEGATE_BASE, "<PREFIX>",
-      GetHandlePrefix());
-  code = ReplaceAll(code, "<NAME>", iface.GetID());
-  code = ReplaceAll(code, "<DELEGATE_NAME>", decl.GetID());
-
   std::string enum_value = GetHandlePrefix() + "_" + iface.GetID() +
       "_DELEGATE_" + decl.GetID();
   std::transform(enum_value.begin(), enum_value.end(), enum_value.begin(),
       ::toupper);
-  code = ReplaceAll(code, "<DELEGATE_ENUM_VALUE>", enum_value);
-  code = ReplaceAll(code, "<DELEGATE_ARGS_DECL>",
-      GenDelegateArgsDecl(iface, decl));
-  code = ReplaceAll(code, "<DELEGATE_PARCEL_READ>",
-      GenDelegateParcelRead(iface, decl));
   bool has_free = false;
   std::string delegate_args_free = GenDelegateArgsFree(iface, decl, has_free);
-  code = ReplaceAll(code, "<DELEGATE_ARGS_FREE>", delegate_args_free);
-  code = ReplaceAll(code, "<DELEGATE_CALLBACK_ARGS>",
-      GenDelegateCallbackArgs(decl));
-  code = ReplaceAll(code, "<GOTO_STATEMENT>",
-      has_free ? "out:" + NLine(1) : "");
+
+  std::string code = ReplaceAll(CB_INTERFACE_DELEGATE_BASE, {
+      { "<PREFIX>", GetHandlePrefix() },
+      { "<NAME>", iface.GetID() },
+      { "<DELEGATE_NAME>", decl.GetID() },
+      { "<DELEGATE_ENUM_VALUE>", enum_value },
+      { "<DELEGATE_ARGS_DECL>", GenDelegateArgsDecl(iface, decl) },
+      { "<DELEGATE_PARCEL_READ>", GenDelegateParcelRead(iface, decl) },
+      { "<DELEGATE_ARGS_FREE>", delegate_args_free },
+      { "<DELEGATE_CALLBACK_ARGS>", GenDelegateCallbackArgs(decl) },
+      { "<GOTO_STATEMENT>", has_free ? "out:" + NLine(1) : "" }
+  });
 
   stream << SmartIndent(code);
 }
@@ -308,23 +308,25 @@ void CProxyBodyGen::GenInterfaceDelegateTable(std::ofstream& stream,
         "_DELEGATE_" + d->GetID();
     std::transform(enum_value.begin(), enum_value.end(), enum_value.begin(),
         ::toupper);
-    std::string member = ReplaceAll(CB_INTERFACE_DELEGATE_TABLE_MEMBER,
-        "<ENUM_VALUE>", enum_value);
-    member = ReplaceAll(member, "<PREFIX>", GetHandlePrefix());
-    member = ReplaceAll(member, "<NAME>", iface.GetID());
-    member = ReplaceAll(member, "<DELEGATE_NAME>", d->GetID());
-    member = RemoveLine(member);
+    std::string member = ReplaceAll(CB_INTERFACE_DELEGATE_TABLE_MEMBER, {
+        { "<ENUM_VALUE>", enum_value },
+        { "<PREFIX>", GetHandlePrefix() },
+        { "<NAME>", iface.GetID() },
+        { "<DELEGATE_NAME>", d->GetID() }
+    });
 
+    member = RemoveLine(member);
     delegate_handlers += member;
   }
 
   if (delegate_handlers.empty())
     delegate_handlers = "nullptr," + NLine(1);
 
-  std::string code = ReplaceAll(CB_INTERFACE_DELEGATE_TABLE, "<PREFIX>",
-      GetHandlePrefix());
-  code = ReplaceAll(code, "<NAME>", iface.GetID());
-  code = ReplaceAll(code, "<DELEGATE_HANDLERS>", delegate_handlers);
+  std::string code = ReplaceAll(CB_INTERFACE_DELEGATE_TABLE, {
+      { "<PREFIX>", GetHandlePrefix() },
+      { "<NAME>", iface.GetID() },
+      { "<DELEGATE_HANDLERS>", delegate_handlers }
+  });
 
   stream << SmartIndent(code);
 }
@@ -349,10 +351,11 @@ void CProxyBodyGen::GenInterfaceMethodEnumBase(std::ofstream& stream,
   }
 
   std::transform(enums.begin(), enums.end(), enums.begin(), ::toupper);
-  std::string code = ReplaceAll(CB_INTERFACE_METHOD_ENUM_BASE, "<ENUMS>",
-      enums);
-  code = ReplaceAll(code, "<PREFIX>", GetHandlePrefix());
-  code = ReplaceAll(code, "<NAME>", iface.GetID());
+  std::string code = ReplaceAll(CB_INTERFACE_METHOD_ENUM_BASE, {
+      { "<ENUMS>", enums },
+      { "<PREFIX>", GetHandlePrefix() },
+      { "<NAME>", iface.GetID() }
+  });
 
   stream << SmartIndent(code);
 }
diff --git a/idlc/gen/c_proxy_header_gen.cc b/idlc/gen/c_proxy_header_gen.cc
index 847a5a5..e2231a4 100644
--- a/idlc/gen/c_proxy_header_gen.cc
+++ b/idlc/gen/c_proxy_header_gen.cc
@@ -60,9 +60,10 @@ void CProxyHeaderGen::GenInterfaceHandles(std::ofstream& stream) {
 // @see #CB_INTERFACE_HANDLE
 void CProxyHeaderGen::GenInterfaceHandle(std::ofstream& stream,
     const Interface& iface) {
-  std::string code = ReplaceAll(CB_INTERFACE_HANDLE, "<PREFIX>",
-      GetHandlePrefix());
-  code = ReplaceAll(code, "<NAME>", iface.GetID());
+  std::string code = ReplaceAll(CB_INTERFACE_HANDLE, {
+      { "<PREFIX>", GetHandlePrefix() },
+      { "<NAME>", iface.GetID() }
+  });
 
   stream << SmartIndent(code);
 }
@@ -70,10 +71,11 @@ void CProxyHeaderGen::GenInterfaceHandle(std::ofstream& stream,
 // @see #CB_INTERFACE_DELEGATE_HANDLE
 void CProxyHeaderGen::GenInterfaceDelegateHandle(std::ofstream& stream,
     const Interface& iface, const Declaration& decl) {
-  std::string code = ReplaceAll(CB_INTERFACE_DELEGATE_HANDLE, "<PREFIX>",
-      GetHandlePrefix());
-  code = ReplaceAll(code, "<NAME>", iface.GetID());
-  code = ReplaceAll(code, "<DELEGATE_NAME>", decl.GetID());
+  std::string code = ReplaceAll(CB_INTERFACE_DELEGATE_HANDLE, {
+      { "<PREFIX>", GetHandlePrefix() },
+      { "<NAME>", iface.GetID() },
+      { "<DELEGATE_NAME>", decl.GetID() }
+  });
 
   stream << SmartIndent(code);
 }
@@ -110,9 +112,10 @@ void CProxyHeaderGen::GenInterface(std::ofstream& stream,
 // @see #CB_INTERFACE_BASE
 void CProxyHeaderGen::GenInterfaceBase(std::ofstream& stream,
     const Interface& iface) {
-  std::string code = ReplaceAll(CB_INTERFACE_BASE, "<PREFIX>",
-      GetHandlePrefix());
-  code = ReplaceAll(code, "<NAME>", iface.GetID());
+  std::string code = ReplaceAll(CB_INTERFACE_BASE, {
+      { "<PREFIX>", GetHandlePrefix() },
+      { "<NAME>", iface.GetID() }
+  });
 
   stream << SmartIndent(code);
 }
@@ -134,11 +137,12 @@ std::string CProxyHeaderGen::GenDelegateParams(const Interface& iface,
 // @see #CB_INTERFACE_DELEGATE_BASE
 void CProxyHeaderGen::GenInterfaceDelegateBase(std::ofstream& stream,
     const Interface& iface, const Declaration& decl) {
-  std::string code = ReplaceAll(CB_INTERFACE_DELEGATE_BASE, "<PREFIX>",
-      GetHandlePrefix());
-  code = ReplaceAll(code, "<NAME>", iface.GetID());
-  code = ReplaceAll(code, "<DELEGATE_NAME>", decl.GetID());
-  code = ReplaceAll(code, "<DELEGATE_PARAMS>", GenDelegateParams(iface, decl));
+  std::string code = ReplaceAll(CB_INTERFACE_DELEGATE_BASE, {
+      { "<PREFIX>", GetHandlePrefix() },
+      { "<NAME>", iface.GetID() },
+      { "<DELEGATE_NAME>", decl.GetID() },
+      { "<DELEGATE_PARAMS>", GenDelegateParams(iface, decl) }
+  });
 
   stream << SmartIndent(code);
 }
@@ -160,12 +164,13 @@ std::string CProxyHeaderGen::GenMethodParams(const Interface& iface,
 // @see #CB_INTERFACE_METHOD_BASE
 void CProxyHeaderGen::GenInterfaceMethodBase(std::ofstream& stream,
     const Interface& iface, const Declaration& decl) {
-  std::string code = ReplaceAll(CB_INTERFACE_METHOD_BASE, "<RETURN_TYPE>",
-      GetReturnTypeString(decl.GetType()));
-  code = ReplaceAll(code, "<PREFIX>", GetHandlePrefix());
-  code = ReplaceAll(code, "<NAME>", iface.GetID());
-  code = ReplaceAll(code, "<METHOD_NAME>", decl.GetID());
-  code = ReplaceAll(code, "<METHOD_PARAMS>", GenMethodParams(iface, decl));
+  std::string code = ReplaceAll(CB_INTERFACE_METHOD_BASE, {
+      { "<RETURN_TYPE>", GetReturnTypeString(decl.GetType()) },
+      { "<PREFIX>", GetHandlePrefix() },
+      { "<NAME>", iface.GetID() },
+      { "<METHOD_NAME>", decl.GetID() },
+      { "<METHOD_PARAMS>", GenMethodParams(iface, decl) }
+  });
 
   stream << SmartIndent(code);
 }
diff --git a/idlc/gen/c_stub_body_gen.cc b/idlc/gen/c_stub_body_gen.cc
index 60e168a..8b3d759 100644
--- a/idlc/gen/c_stub_body_gen.cc
+++ b/idlc/gen/c_stub_body_gen.cc
@@ -79,27 +79,31 @@ void CStubBodyGen::GenInterfaceEnum(std::ofstream& stream,
 
 // @see #CB_INTERFACE_METHOD_ENUM
 std::string CStubBodyGen::GenMethodEnums(const Interface& iface) {
-  std::string method_enum = ReplaceAll(CB_INTERFACE_METHOD_ENUM,
-      "<UPPERCASE_PREFIX>", GetHandlePrefix());
-  method_enum = ReplaceAll(method_enum, "<UPPERCASE_NAME>", iface.GetID());
-  method_enum = ReplaceAll(method_enum, "<UPPERCASE_METHOD_NAME>", "RESULT_");
+  std::string method_enum = ReplaceAll(CB_INTERFACE_METHOD_ENUM, {
+      { "<UPPERCASE_PREFIX>", GetHandlePrefix() },
+      { "<UPPERCASE_NAME>", iface.GetID() },
+      { "<UPPERCASE_METHOD_NAME>", "RESULT_" }
+  });
+
   std::string method_enums = RemoveLine(method_enum);
 
-  method_enum = ReplaceAll(CB_INTERFACE_METHOD_ENUM, "<UPPERCASE_PREFIX>",
-      GetHandlePrefix());
-  method_enum = ReplaceAll(method_enum, "<UPPERCASE_NAME>", iface.GetID());
-  method_enum = ReplaceAll(method_enum, "<UPPERCASE_METHOD_NAME>", "CALLBACK_");
+  method_enum = ReplaceAll(CB_INTERFACE_METHOD_ENUM, {
+      { "<UPPERCASE_PREFIX>", GetHandlePrefix() },
+      { "<UPPERCASE_NAME>", iface.GetID() },
+      { "<UPPERCASE_METHOD_NAME>", "CALLBACK_" }
+  });
+
   method_enums += RemoveLine(method_enum);
 
   for (auto& d : iface.GetDeclarations().GetDecls()) {
     if (d->GetMethodType() == Declaration::MethodType::DELEGATE)
       continue;
 
-    method_enum = ReplaceAll(CB_INTERFACE_METHOD_ENUM, "<UPPERCASE_PREFIX>",
-        GetHandlePrefix());
-    method_enum = ReplaceAll(method_enum, "<UPPERCASE_NAME>", iface.GetID());
-    method_enum = ReplaceAll(method_enum, "<UPPERCASE_METHOD_NAME>",
-        d->GetID());
+    method_enum = ReplaceAll(CB_INTERFACE_METHOD_ENUM, {
+        { "<UPPERCASE_PREFIX>", GetHandlePrefix() },
+        { "<UPPERCASE_NAME>", iface.GetID() },
+        { "<UPPERCASE_METHOD_NAME>", d->GetID() }
+    });
 
     method_enums += RemoveLine(method_enum);
   }
@@ -112,10 +116,11 @@ std::string CStubBodyGen::GenMethodEnums(const Interface& iface) {
 // @see #CB_INTERFACE_METHOD_ENUM_BASE
 void CStubBodyGen::GenInterfaceMethodEnumBase(std::ofstream& stream,
     const Interface& iface) {
-  std::string code = ReplaceAll(CB_INTERFACE_METHOD_ENUM_BASE, "<PREFIX>",
-      GetHandlePrefix());
-  code = ReplaceAll(code, "<NAME>", iface.GetID());
-  code = ReplaceAll(code, "<METHOD_ENUMS>", GenMethodEnums(iface));
+  std::string code = ReplaceAll(CB_INTERFACE_METHOD_ENUM_BASE, {
+      { "<PREFIX>", GetHandlePrefix() },
+      { "<NAME>", iface.GetID() },
+      { "<METHOD_ENUMS>", GenMethodEnums(iface) }
+  });
 
   stream << SmartIndent(code);
 }
@@ -128,12 +133,12 @@ std::string CStubBodyGen::GenDelegateEnums(const Interface& iface) {
     if (d->GetMethodType() != Declaration::MethodType::DELEGATE)
       continue;
 
-    std::string method_enum = ReplaceAll(CB_INTERFACE_DELEGATE_ENUM,
-        "<UPPERCASE_PREFIX>", GetHandlePrefix());
-    method_enum = ReplaceAll(method_enum, "<UPPERCASE_NAME>", iface.GetID());
-    method_enum = ReplaceAll(method_enum, "<UPPERCASE_DELEGATE_NAME>",
-        d->GetID());
-    method_enum = ReplaceAll(method_enum, "<NUMBER>", std::to_string(num++));
+    std::string method_enum = ReplaceAll(CB_INTERFACE_DELEGATE_ENUM, {
+        { "<UPPERCASE_PREFIX>", GetHandlePrefix() },
+        { "<UPPERCASE_NAME>", iface.GetID() },
+        { "<UPPERCASE_DELEGATE_NAME>", d->GetID() },
+        { "<NUMBER>", std::to_string(num++) }
+    });
 
     method_enums += RemoveLine(method_enum);
   }
@@ -150,10 +155,11 @@ void CStubBodyGen::GenInterfaceDelegateEnumBase(std::ofstream& stream,
   if (delegate_enums.empty())
     return;
 
-  std::string code = ReplaceAll(CB_INTERFACE_DELEGATE_ENUM_BASE, "<PREFIX>",
-      GetHandlePrefix());
-  code = ReplaceAll(code, "<NAME>", iface.GetID());
-  code = ReplaceAll(code, "<DELEGATE_ENUMS>", delegate_enums);
+  std::string code = ReplaceAll(CB_INTERFACE_DELEGATE_ENUM_BASE, {
+      { "<PREFIX>", GetHandlePrefix() },
+      { "<NAME>", iface.GetID() },
+      { "<DELEGATE_ENUMS>", delegate_enums }
+  });
 
   stream << SmartIndent(code);
 }
@@ -189,10 +195,11 @@ void CStubBodyGen::GenInterfaceDef(std::ofstream& stream,
 // @see #CB_INTERFACE_DELEGATE_DEF
 void CStubBodyGen::GenInterfaceDelegateDef(std::ofstream& stream,
     const Interface& iface, const Declaration& decl) {
-  std::string code = ReplaceAll(CB_INTERFACE_DELEGATE_DEF, "<PREFIX>",
-      GetHandlePrefix());
-  code = ReplaceAll(code, "<NAME>", iface.GetID());
-  code = ReplaceAll(code, "<DELEGATE_NAME>", decl.GetID());
+  std::string code = ReplaceAll(CB_INTERFACE_DELEGATE_DEF, {
+      { "<PREFIX>", GetHandlePrefix() },
+      { "<NAME>", iface.GetID() },
+      { "<DELEGATE_NAME>", decl.GetID() }
+  });
 
   stream << SmartIndent(code);
 }
@@ -200,9 +207,10 @@ void CStubBodyGen::GenInterfaceDelegateDef(std::ofstream& stream,
 // @see #CB_INTERFACE_CALLBACK_PORT_CHECK_DEF
 void CStubBodyGen::GenInterfaceCallbackPortCheckDef(std::ofstream& stream,
     const Interface& iface) {
-  std::string code = ReplaceAll(CB_INTERFACE_CALLBACK_PORT_CHECK_DEF,
-      "<PREFIX>", GetHandlePrefix());
-  code = ReplaceAll(code, "<NAME>", iface.GetID());
+  std::string code = ReplaceAll(CB_INTERFACE_CALLBACK_PORT_CHECK_DEF, {
+      { "<PREFIX>", GetHandlePrefix() },
+      { "<NAME>", iface.GetID() }
+  });
 
   stream << SmartIndent(code);
 }
@@ -210,9 +218,10 @@ void CStubBodyGen::GenInterfaceCallbackPortCheckDef(std::ofstream& stream,
 // @see #CB_INTERFACE_CONTEXT_DEF
 void CStubBodyGen::GenInterfaceContextDef(std::ofstream& stream,
     const Interface& iface) {
-  std::string code = ReplaceAll(CB_INTERFACE_CONTEXT_DEF, "<PREFIX>",
-      GetHandlePrefix());
-  code = ReplaceAll(code, "<NAME>", iface.GetID());
+  std::string code = ReplaceAll(CB_INTERFACE_CONTEXT_DEF, {
+      { "<PREFIX>", GetHandlePrefix() },
+      { "<NAME>", iface.GetID() }
+  });
 
   stream << SmartIndent(code);
 }
@@ -220,9 +229,10 @@ void CStubBodyGen::GenInterfaceContextDef(std::ofstream& stream,
 // @see #CB_INTERFACE_BASE_DEF
 void CStubBodyGen::GenInterfaceBaseDef(std::ofstream& stream,
     const Interface& iface) {
-  std::string code = ReplaceAll(CB_INTERFACE_BASE_DEF, "<PREFIX>",
-      GetHandlePrefix());
-  code = ReplaceAll(code, "<NAME>", iface.GetID());
+  std::string code = ReplaceAll(CB_INTERFACE_BASE_DEF, {
+      { "<PREFIX>", GetHandlePrefix() },
+      { "<NAME>", iface.GetID() }
+  });
 
   stream << SmartIndent(code);
 }
@@ -266,9 +276,10 @@ void CStubBodyGen::GenInterface(std::ofstream& stream, const Interface& iface) {
 // @see #CB_INTERFACE_CONTEXT_BASE
 void CStubBodyGen::GenInterfaceContextBase(std::ofstream& stream,
     const Interface& iface) {
-  std::string code = ReplaceAll(CB_INTERFACE_CONTEXT_BASE, "<PREFIX>",
-      GetHandlePrefix());
-  code = ReplaceAll(code, "<NAME>", iface.GetID());
+  std::string code = ReplaceAll(CB_INTERFACE_CONTEXT_BASE, {
+      { "<PREFIX>", GetHandlePrefix() },
+      { "<NAME>", iface.GetID() }
+  });
 
   stream << SmartIndent(code);
 }
@@ -352,21 +363,20 @@ std::string CStubBodyGen::GenDelegateParcelWrite(const Interface& iface,
 // @see #CB_INTERFACE_DELEGATE_BASE
 void CStubBodyGen::GenInterfaceDelegateBase(std::ofstream& stream,
     const Interface& iface, const Declaration& decl) {
-  std::string code = ReplaceAll(CB_INTERFACE_DELEGATE_BASE, "<PREFIX>",
-      GetHandlePrefix());
-  code = ReplaceAll(code, "<NAME>", iface.GetID());
-  code = ReplaceAll(code, "<DELEGATE_NAME>", decl.GetID());
-  code = ReplaceAll(code, "<DELEGATE_PARAMS>", GenDelegateParams(iface, decl));
-  code = ReplaceAll(code, "<DELEGATE_PARAMS_CHECK>",
-      GenDelegateParamsCheck(iface, decl));
-
   std::string enum_value = GetHandlePrefix() + "_" + iface.GetID() +
       "_DELEGATE_" + decl.GetID();
   std::transform(enum_value.begin(), enum_value.end(), enum_value.begin(),
       ::toupper);
-  code = ReplaceAll(code, "<DELEGATE_ENUM_VALUE>", enum_value);
-  code = ReplaceAll(code, "<DELEGATE_PARCEL_WRITE>",
-      GenDelegateParcelWrite(iface, decl));
+
+  std::string code = ReplaceAll(CB_INTERFACE_DELEGATE_BASE, {
+      { "<PREFIX>", GetHandlePrefix() },
+      { "<NAME>", iface.GetID() },
+      { "<DELEGATE_NAME>", decl.GetID() },
+      { "<DELEGATE_PARAMS>", GenDelegateParams(iface, decl) },
+      { "<DELEGATE_PARAMS_CHECK>", GenDelegateParamsCheck(iface, decl) },
+      { "<DELEGATE_ENUM_VALUE>", enum_value },
+      { "<DELEGATE_PARCEL_WRITE>", GenDelegateParcelWrite(iface, decl) }
+  });
 
   stream << SmartIndent(code);
 }
@@ -613,20 +623,19 @@ std::string CStubBodyGen::GenMethodHandlerArgsFree(const Interface& iface,
 // @see #CB_INTERFACE_METHOD_HANDLER_BASE
 void CStubBodyGen::GenInterfaceMethodHandlerBase(std::ofstream& stream,
     const Interface& iface, const Declaration& decl) {
-  std::string code = ReplaceAll(CB_INTERFACE_METHOD_HANDLER_BASE, "<PREFIX>",
-      GetHandlePrefix());
-  code = ReplaceAll(code, "<NAME>", iface.GetID());
-  code = ReplaceAll(code, "<METHOD_NAME>", decl.GetID());
-  code = ReplaceAll(code, "<METHOD_HANDLER_ARGS_DECL>",
-      GenMethodHandlerArgsDecl(iface, decl));
-  code = ReplaceAll(code, "<METHOD_HANDLER_PARCEL_READ>",
-      GenMethodHandlerParcelRead(iface, decl));
-  code = ReplaceAll(code, "<METHOD_HANDLER_CALLBACK_INVOKE>",
-      GenMethodHandlerCallbackInvoke(decl));
-  code = ReplaceAll(code, "<METHOD_HANDLER_PARCEL_WRITE>",
-      GenMethodHandlerParcelWrite(iface, decl));
-  code = ReplaceAll(code, "<METHOD_HANDLER_ARGS_FREE>",
-      GenMethodHandlerArgsFree(iface, decl));
+  std::string code = ReplaceAll(CB_INTERFACE_METHOD_HANDLER_BASE, {
+      { "<PREFIX>", GetHandlePrefix() },
+      { "<NAME>", iface.GetID() },
+      { "<METHOD_NAME>", decl.GetID() },
+      { "<METHOD_HANDLER_ARGS_DECL>", GenMethodHandlerArgsDecl(iface, decl) },
+      { "<METHOD_HANDLER_PARCEL_READ>",
+          GenMethodHandlerParcelRead(iface, decl) },
+      { "<METHOD_HANDLER_CALLBACK_INVOKE>",
+          GenMethodHandlerCallbackInvoke(decl) },
+      { "<METHOD_HANDLER_PARCEL_WRITE>",
+          GenMethodHandlerParcelWrite(iface, decl) },
+      { "<METHOD_HANDLER_ARGS_FREE>", GenMethodHandlerArgsFree(iface, decl) }
+  });
 
   stream << SmartIndent(code);
 }
@@ -642,11 +651,12 @@ std::string CStubBodyGen::GenMethodHandlers(const Interface& iface) {
       "_METHOD_" + d->GetID();
     std::transform(enum_value.begin(), enum_value.end(), enum_value.begin(),
         ::toupper);
-    std::string method_handler = ReplaceAll(CB_INTERFACE_METHOD_HANDLER,
-        "<ENUM_VALUE>", enum_value);
-    method_handler = ReplaceAll(method_handler, "<PREFIX>", GetHandlePrefix());
-    method_handler = ReplaceAll(method_handler, "<NAME>", iface.GetID());
-    method_handler = ReplaceAll(method_handler, "<METHOD_NAME>", d->GetID());
+    std::string method_handler = ReplaceAll(CB_INTERFACE_METHOD_HANDLER, {
+        { "<ENUM_VALUE>", enum_value },
+        { "<PREFIX>", GetHandlePrefix() },
+        { "<NAME>", iface.GetID() },
+        { "<METHOD_NAME>", d->GetID() }
+    });
 
     code += RemoveLine(method_handler);
   }
@@ -657,9 +667,10 @@ std::string CStubBodyGen::GenMethodHandlers(const Interface& iface) {
 // @see #CB_INTERFACE_METHOD_TABLE
 void CStubBodyGen::GenInterfaceMethodTable(std::ofstream& stream,
     const Interface& iface) {
-  std::string code = ReplaceAll(CB_INTERFACE_METHOD_TABLE, "<NAME>",
-      iface.GetID());
-  code = ReplaceAll(code, "<METHOD_HANDLERS>", GenMethodHandlers(iface));
+  std::string code = ReplaceAll(CB_INTERFACE_METHOD_TABLE, {
+      { "<NAME>", iface.GetID() },
+      { "<METHOD_HANDLERS>", GenMethodHandlers(iface) }
+  });
 
   stream << SmartIndent(code);
 }
@@ -667,9 +678,10 @@ void CStubBodyGen::GenInterfaceMethodTable(std::ofstream& stream,
 // @see #CB_INTERFACE_CALLBACK_PORT_CHECK
 void CStubBodyGen::GenInterfaceCallbackPortCheck(std::ofstream& stream,
     const Interface& iface) {
-  std::string code = ReplaceAll(CB_INTERFACE_CALLBACK_PORT_CHECK, "<PREFIX>",
-      GetHandlePrefix());
-  code = ReplaceAll(code, "<NAME>", iface.GetID());
+  std::string code = ReplaceAll(CB_INTERFACE_CALLBACK_PORT_CHECK, {
+      { "<PREFIX>", GetHandlePrefix() },
+      { "<NAME>", iface.GetID() }
+  });
 
   stream << SmartIndent(code);
 }
@@ -680,10 +692,10 @@ std::string CStubBodyGen::GenAccessControlSet(const Interface& iface) {
   std::string code;
   for (auto& attr : iface.GetAttributes().GetAttrs()) {
     if (attr->GetKey() == "privilege") {
-      std::string privilege_add = ReplaceAll(CB_INTERFACE_PRIVILEGE_ADD,
-          "<NAME>", iface.GetID());
-      privilege_add = ReplaceAll(privilege_add, "<PRIVILEGE>",
-          attr->GetValue());
+      std::string privilege_add = ReplaceAll(CB_INTERFACE_PRIVILEGE_ADD, {
+          { "<NAME>", iface.GetID() },
+          { "<PRIVILEGE>", attr->GetValue() }
+      });
 
       code += privilege_add;
     } else if (attr->GetKey() == "trusted" && attr->GetValue() == "true") {
@@ -700,10 +712,11 @@ std::string CStubBodyGen::GenAccessControlSet(const Interface& iface) {
 // @see #CB_INTERFACE_BASE
 void CStubBodyGen::GenInterfaceBase(std::ofstream& stream,
     const Interface& iface) {
-  std::string code = ReplaceAll(CB_INTERFACE_BASE, "<PREFIX>",
-      GetHandlePrefix());
-  code = ReplaceAll(code, "<NAME>", iface.GetID());
-  code = ReplaceAll(code, "<ACCESS_CONTROL_SET>", GenAccessControlSet(iface));
+  std::string code = ReplaceAll(CB_INTERFACE_BASE, {
+      { "<PREFIX>", GetHandlePrefix() },
+      { "<NAME>", iface.GetID() },
+      { "<ACCESS_CONTROL_SET>", GenAccessControlSet(iface) }
+  });
 
   stream << SmartIndent(code);
 }
diff --git a/idlc/gen/c_stub_header_gen.cc b/idlc/gen/c_stub_header_gen.cc
index abd91d8..1eb5f67 100644
--- a/idlc/gen/c_stub_header_gen.cc
+++ b/idlc/gen/c_stub_header_gen.cc
@@ -60,9 +60,10 @@ void CStubHeaderGen::GenInterfaceHandles(std::ofstream& stream) {
 // @see #CB_INTERFACE_CONTEXT_HANDLE
 void CStubHeaderGen::GenInterfaceContextHandle(std::ofstream& stream,
     const Interface& iface) {
-  std::string code = ReplaceAll(CB_INTERFACE_CONTEXT_HANDLE, "<PREFIX>",
-      GetHandlePrefix());
-  code = ReplaceAll(code, "<NAME>", iface.GetID());
+  std::string code = ReplaceAll(CB_INTERFACE_CONTEXT_HANDLE, {
+      { "<PREFIX>", GetHandlePrefix() },
+      { "<NAME>", iface.GetID() }
+  });
 
   stream << SmartIndent(code);
 }
@@ -70,10 +71,11 @@ void CStubHeaderGen::GenInterfaceContextHandle(std::ofstream& stream,
 // @see #CB_INTERFACE_DELEGATE_HANDLE
 void CStubHeaderGen::GenInterfaceDelegateHandle(std::ofstream& stream,
     const Interface& iface, const Declaration& decl) {
-  std::string code = ReplaceAll(CB_INTERFACE_DELEGATE_HANDLE, "<PREFIX>",
-      GetHandlePrefix());
-  code = ReplaceAll(code, "<NAME>", iface.GetID());
-  code = ReplaceAll(code, "<DELEGATE_NAME>", decl.GetID());
+  std::string code = ReplaceAll(CB_INTERFACE_DELEGATE_HANDLE, {
+      { "<PREFIX>", GetHandlePrefix() },
+      { "<NAME>", iface.GetID() },
+      { "<DELEGATE_NAME>", decl.GetID() }
+  });
 
   stream << SmartIndent(code);
 }
@@ -97,9 +99,10 @@ void CStubHeaderGen::GenInterfaceCallbacks(std::ofstream& stream) {
 // @see #CB_INTERFACE_CALLBACK_BASE
 void CStubHeaderGen::GenInterfaceCallbackBase(std::ofstream& stream,
     const Interface& iface) {
-  std::string code = ReplaceAll(CB_INTERFACE_CALLBACK_BASE, "<PREFIX>",
-      GetHandlePrefix());
-  code = ReplaceAll(code, "<NAME>", iface.GetID());
+  std::string code = ReplaceAll(CB_INTERFACE_CALLBACK_BASE, {
+      { "<PREFIX>", GetHandlePrefix() },
+      { "<NAME>", iface.GetID() }
+  });
 
   stream << SmartIndent(code);
 }
@@ -121,12 +124,13 @@ std::string CStubHeaderGen::GenMethodParams(const Interface& iface,
 // @see #CB_INTERFACE_METHOD_CALLBACK_BASE
 void CStubHeaderGen::GenInterfaceMethodCallbackBase(std::ofstream& stream,
     const Interface& iface, const Declaration& decl) {
-  std::string code = ReplaceAll(CB_INTERFACE_METHOD_CALLBACK_BASE,
-      "<RETURN_TYPE>", GetReturnTypeString(decl.GetType()));
-  code = ReplaceAll(code, "<PREFIX>", GetHandlePrefix());
-  code = ReplaceAll(code, "<NAME>", iface.GetID());
-  code = ReplaceAll(code, "<METHOD_NAME>", decl.GetID());
-  code = ReplaceAll(code, "<METHOD_PARAMS>", GenMethodParams(iface, decl));
+  std::string code = ReplaceAll(CB_INTERFACE_METHOD_CALLBACK_BASE, {
+      { "<RETURN_TYPE>", GetReturnTypeString(decl.GetType()) },
+      { "<PREFIX>", GetHandlePrefix() },
+      { "<NAME>", iface.GetID() },
+      { "<METHOD_NAME>", decl.GetID() },
+      { "<METHOD_PARAMS>", GenMethodParams(iface, decl) }
+  });
 
   stream << SmartIndent(code);
 }
@@ -157,9 +161,10 @@ void CStubHeaderGen::GenInterface(std::ofstream& stream,
 // @see #CB_INTERFACE_CONTEXT_BASE
 void CStubHeaderGen::GenInterfaceContextBase(std::ofstream& stream,
     const Interface& iface) {
-  std::string code = ReplaceAll(CB_INTERFACE_CONTEXT_BASE, "<PREFIX>",
-      GetHandlePrefix());
-  code = ReplaceAll(code, "<NAME>", iface.GetID());
+  std::string code = ReplaceAll(CB_INTERFACE_CONTEXT_BASE, {
+      { "<PREFIX>", GetHandlePrefix() },
+      { "<NAME>", iface.GetID() }
+  });
 
   stream << SmartIndent(code);
 }
@@ -181,11 +186,12 @@ std::string CStubHeaderGen::GenDelegateParams(const Interface& iface,
 // @see #CB_INTERFACE_DELEGATE_BASE
 void CStubHeaderGen::GenInterfaceDelegateBase(std::ofstream& stream,
     const Interface& iface, const Declaration& decl) {
-  std::string code = ReplaceAll(CB_INTERFACE_DELEGATE_BASE, "<PREFIX>",
-      GetHandlePrefix());
-  code = ReplaceAll(code, "<NAME>", iface.GetID());
-  code = ReplaceAll(code, "<DELEGATE_NAME>", decl.GetID());
-  code = ReplaceAll(code, "<DELEGATE_PARAMS>", GenDelegateParams(iface, decl));
+  std::string code = ReplaceAll(CB_INTERFACE_DELEGATE_BASE, {
+      { "<PREFIX>", GetHandlePrefix() },
+      { "<NAME>", iface.GetID() },
+      { "<DELEGATE_NAME>", decl.GetID() },
+      { "<DELEGATE_PARAMS>", GenDelegateParams(iface, decl) }
+  });
 
   stream << SmartIndent(code);
 }
@@ -198,11 +204,11 @@ std::string CStubHeaderGen::GenMethodCallbackDecls(const Interface& iface) {
       continue;
 
     std::string method_callback_decl = ReplaceAll(
-        CB_INTERFACE_METHOD_CALLBACK_DECL, "<PREFIX>", GetHandlePrefix());
-    method_callback_decl = ReplaceAll(method_callback_decl, "<NAME>",
-        iface.GetID());
-    method_callback_decl = ReplaceAll(method_callback_decl, "<METHOD_NAME>",
-        d->GetID());
+        CB_INTERFACE_METHOD_CALLBACK_DECL, {
+            { "<PREFIX>", GetHandlePrefix() },
+            { "<NAME>", iface.GetID() },
+            { "<METHOD_NAME>", d->GetID() }
+        });
 
     method_callback_decl = RemoveLine(method_callback_decl);
     method_callback_decls += RemoveLine(method_callback_decl, 2);
@@ -214,11 +220,11 @@ std::string CStubHeaderGen::GenMethodCallbackDecls(const Interface& iface) {
 // @see #CB_INTERFACE_BASE
 void CStubHeaderGen::GenInterfaceBase(std::ofstream& stream,
     const Interface& iface) {
-  std::string code = ReplaceAll(CB_INTERFACE_BASE, "<PREFIX>",
-      GetHandlePrefix());
-  code = ReplaceAll(code, "<NAME>", iface.GetID());
-  code = ReplaceAll(code, "<METHOD_CALLBACK_DECLS>",
-      GenMethodCallbackDecls(iface));
+  std::string code = ReplaceAll(CB_INTERFACE_BASE, {
+      { "<PREFIX>", GetHandlePrefix() },
+      { "<NAME>", iface.GetID() },
+      { "<METHOD_CALLBACK_DECLS>", GenMethodCallbackDecls(iface) }
+  });
 
   stream << SmartIndent(code);
 }
diff --git a/idlc/gen/generator.cc b/idlc/gen/generator.cc
index 3602462..790ff22 100644
--- a/idlc/gen/generator.cc
+++ b/idlc/gen/generator.cc
@@ -98,6 +98,14 @@ std::string Generator::ReplaceAll(std::string str,
   return str;
 }
 
+std::string Generator::ReplaceAll(std::string str,
+    std::initializer_list<std::pair<std::string, std::string>> list) {
+  for (const auto& i : list)
+    str = ReplaceAll(str, i.first, i.second);
+
+  return str;
+}
+
 bool Generator::IsDelegateType(const BaseType& type) {
   for (auto& i : GetDocument().GetBlocks()) {
     if (i->GetType() != Block::TYPE_INTERFACE)
diff --git a/idlc/gen/generator.h b/idlc/gen/generator.h
index 9eba127..a7beed2 100755
--- a/idlc/gen/generator.h
+++ b/idlc/gen/generator.h
@@ -39,6 +39,8 @@ class Generator {
   std::string GetFileNamespace() const;
   std::string ReplaceAll(std::string str,
                          const std::string& from, const std::string& to);
+  std::string ReplaceAll(std::string str,
+      std::initializer_list<std::pair<std::string, std::string>> list);
   bool IsDelegateType(const Interface& inf, const BaseType& type);
   bool IsDelegateType(const BaseType& type);