[Calendar] Renaming methods to match google style

[Verification] TCT without change

Change-Id: I88d3ea57f0940321f39ec3617ddad560dd41ec7e
Signed-off-by: Pawel Kaczmarek <p.kaczmarek3@samsung.com>

diff --git a/src/calendar/calendar_instance.cc b/src/calendar/calendar_instance.cc
index 6fd917d..3cc183f 100644 (file)
--- a/src/calendar/calendar_instance.cc
+++ b/src/calendar/calendar_instance.cc
@@ -32,178 +32,182 @@ CalendarInstance::CalendarInstance() {
   RegisterSyncHandler(c, std::bind(&CalendarInstance::x, this, _1, _2));
 
   // Calendar
-  REGISTER_SYNC("Calendar_get", Calendar_get);
-  REGISTER_SYNC("Calendar_add", Calendar_add);
-  REGISTER_SYNC("Calendar_update", Calendar_update);
-  REGISTER_SYNC("Calendar_remove", Calendar_remove);
-  REGISTER_SYNC("Calendar_addChangeListener", Calendar_addChangeListener);
-  REGISTER_SYNC("Calendar_removeChangeListener", Calendar_removeChangeListener);
+  REGISTER_SYNC("Calendar_get", CalendarGet);
+  REGISTER_SYNC("Calendar_add", CalendarAdd);
+  REGISTER_SYNC("Calendar_update", CalendarUpdate);
+  REGISTER_SYNC("Calendar_remove", CalendarRemove);
+  REGISTER_SYNC("Calendar_addChangeListener", CalendarAddChangeListener);
+  REGISTER_SYNC("Calendar_removeChangeListener", CalendarRemoveChangeListener);
 
   // Calendar Manager
-  REGISTER_SYNC("CalendarManager_addCalendar", CalendarManager_addCalendar);
-  REGISTER_SYNC("CalendarManager_getCalendar", CalendarManager_getCalendar);
+  REGISTER_SYNC("CalendarManager_addCalendar", CalendarManagerAddCalendar);
+  REGISTER_SYNC("CalendarManager_getCalendar", CalendarManagerGetCalendar);
   REGISTER_SYNC("CalendarManager_removeCalendar",
-                CalendarManager_removeCalendar);
+                CalendarManagerRemoveCalendar);
 #undef REGISTER_SYNC
 
 #define REGISTER_ASYNC(c, x) \
   RegisterHandler(c, std::bind(&CalendarInstance::x, this, _1, _2));
-  REGISTER_ASYNC("Calendar_addBatch", Calendar_addBatch);
-  REGISTER_ASYNC("Calendar_updateBatch", Calendar_updateBatch);
-  REGISTER_ASYNC("Calendar_removeBatch", Calendar_removeBatch);
-  REGISTER_ASYNC("Calendar_updateBatch", Calendar_updateBatch);
-  REGISTER_ASYNC("CalendarManager_getCalendars", CalendarManager_getCalendars);
-  REGISTER_ASYNC("Calendar_find", Calendar_find);
+  REGISTER_ASYNC("Calendar_addBatch", CalendarAddBatch);
+  REGISTER_ASYNC("Calendar_updateBatch", CalendarUpdateBatch);
+  REGISTER_ASYNC("Calendar_removeBatch", CalendarRemoveBatch);
+  REGISTER_ASYNC("Calendar_updateBatch", CalendarUpdateBatch);
+  REGISTER_ASYNC("CalendarManager_getCalendars", CalendarManagerGetCalendars);
+  REGISTER_ASYNC("Calendar_find", CalendarFind);
 #undef REGISTER_ASYNC
 }
 
 CalendarInstance::~CalendarInstance() {}
 
-void CalendarInstance::Calendar_get(const JsonValue& args, JsonObject& out) {
+void CalendarInstance::CalendarGet(const JsonValue& args, JsonObject& out) {
   JsonValue val{JsonObject{}};
   Calendar::GetInstance().Get(common::JsonCast<JsonObject>(args),
                               val.get<JsonObject>());
   ReportSuccess(val, out);
 }
 
-void CalendarInstance::Calendar_add(const JsonValue& args, JsonObject& out) {
+void CalendarInstance::CalendarAdd(const JsonValue& args, JsonObject& out) {
   JsonValue val{JsonObject{}};
   Calendar::GetInstance().Add(common::JsonCast<JsonObject>(args),
                               val.get<JsonObject>());
   ReportSuccess(val, out);
 }
 
-void CalendarInstance::Calendar_addBatch(const JsonValue& args,
-                                         JsonObject& out) {
+void CalendarInstance::CalendarAddBatch(const JsonValue& args,
+                                        JsonObject& out) {
   const double callback_id = args.get("callbackId").get<double>();
-  auto get = [=](const std::shared_ptr<JsonValue>& response) -> void {
+  auto get = [=](const std::shared_ptr<JsonValue> & response)->void {
     try {
       JsonValue result = JsonValue(JsonArray());
       Calendar::GetInstance().AddBatch(common::JsonCast<JsonObject>(args),
                                        result.get<JsonArray>());
       ReportSuccess(result, response->get<picojson::object>());
-    } catch (const PlatformException& e) {
+    }
+    catch (const PlatformException& e) {
       ReportError(e, response->get<picojson::object>());
     }
   };
 
-  auto get_response =
-      [callback_id, this](const std::shared_ptr<JsonValue>& response) -> void {
-        picojson::object& obj = response->get<picojson::object>();
-        obj.insert(std::make_pair("callbackId", callback_id));
-        LoggerD("callback is %s", response->serialize().c_str());
-        PostMessage(response->serialize().c_str());
-      };
+  auto get_response = [ callback_id, this ](const std::shared_ptr<JsonValue> &
+                                            response)->void {
+    picojson::object& obj = response->get<picojson::object>();
+    obj.insert(std::make_pair("callbackId", callback_id));
+    LoggerD("callback is %s", response->serialize().c_str());
+    PostMessage(response->serialize().c_str());
+  };
 
   TaskQueue::GetInstance().Queue<JsonValue>(
       get, get_response,
       std::shared_ptr<JsonValue>(new JsonValue(JsonObject())));
 }
 
-void CalendarInstance::Calendar_update(const JsonValue& args, JsonObject& out) {
+void CalendarInstance::CalendarUpdate(const JsonValue& args, JsonObject& out) {
   JsonValue val{JsonObject{}};
   Calendar::GetInstance().Update(common::JsonCast<JsonObject>(args),
                                  val.get<JsonObject>());
   ReportSuccess(val, out);
 }
 
-void CalendarInstance::Calendar_updateBatch(const JsonValue& args,
-                                            JsonObject& out) {
+void CalendarInstance::CalendarUpdateBatch(const JsonValue& args,
+                                           JsonObject& out) {
   const double callback_id = args.get("callbackId").get<double>();
-  auto get = [=](const std::shared_ptr<JsonValue>& response) -> void {
+  auto get = [=](const std::shared_ptr<JsonValue> & response)->void {
     try {
       JsonValue result = JsonValue(JsonArray());
       Calendar::GetInstance().UpdateBatch(common::JsonCast<JsonObject>(args),
                                           result.get<JsonArray>());
       ReportSuccess(result, response->get<picojson::object>());
-    } catch (const PlatformException& e) {
+    }
+    catch (const PlatformException& e) {
       ReportError(e, response->get<picojson::object>());
     }
   };
 
-  auto get_response =
-      [callback_id, this](const std::shared_ptr<JsonValue>& response) -> void {
-        picojson::object& obj = response->get<picojson::object>();
-        obj.insert(std::make_pair("callbackId", callback_id));
-        LoggerD("callback is %s", response->serialize().c_str());
-        PostMessage(response->serialize().c_str());
-      };
+  auto get_response = [ callback_id, this ](const std::shared_ptr<JsonValue> &
+                                            response)->void {
+    picojson::object& obj = response->get<picojson::object>();
+    obj.insert(std::make_pair("callbackId", callback_id));
+    LoggerD("callback is %s", response->serialize().c_str());
+    PostMessage(response->serialize().c_str());
+  };
 
   TaskQueue::GetInstance().Queue<JsonValue>(
       get, get_response,
       std::shared_ptr<JsonValue>(new JsonValue(JsonObject())));
 }
 
-void CalendarInstance::Calendar_remove(const JsonValue& args, JsonObject& out) {
+void CalendarInstance::CalendarRemove(const JsonValue& args, JsonObject& out) {
   JsonValue val{JsonObject{}};
   Calendar::GetInstance().Remove(common::JsonCast<JsonObject>(args),
                                  val.get<JsonObject>());
   ReportSuccess(out);
 }
 
-void CalendarInstance::Calendar_removeBatch(const JsonValue& args,
-                                            JsonObject& out) {
+void CalendarInstance::CalendarRemoveBatch(const JsonValue& args,
+                                           JsonObject& out) {
   const double callback_id = args.get("callbackId").get<double>();
-  auto get = [=](const std::shared_ptr<JsonValue>& response) -> void {
+  auto get = [=](const std::shared_ptr<JsonValue> & response)->void {
     try {
       JsonValue result = JsonValue(JsonArray());
       Calendar::GetInstance().RemoveBatch(common::JsonCast<JsonObject>(args),
                                           result.get<JsonArray>());
       ReportSuccess(result, response->get<picojson::object>());
-    } catch (const PlatformException& e) {
+    }
+    catch (const PlatformException& e) {
       ReportError(e, response->get<picojson::object>());
     }
   };
 
-  auto get_response =
-      [callback_id, this](const std::shared_ptr<JsonValue>& response) -> void {
-        picojson::object& obj = response->get<picojson::object>();
-        obj.insert(std::make_pair("callbackId", callback_id));
-        LoggerD("callback is %s", response->serialize().c_str());
-        PostMessage(response->serialize().c_str());
-      };
+  auto get_response = [ callback_id, this ](const std::shared_ptr<JsonValue> &
+                                            response)->void {
+    picojson::object& obj = response->get<picojson::object>();
+    obj.insert(std::make_pair("callbackId", callback_id));
+    LoggerD("callback is %s", response->serialize().c_str());
+    PostMessage(response->serialize().c_str());
+  };
 
   TaskQueue::GetInstance().Queue<JsonValue>(
       get, get_response,
       std::shared_ptr<JsonValue>(new JsonValue(JsonObject())));
 }
 
-void CalendarInstance::Calendar_find(const JsonValue& args, JsonObject& out) {
+void CalendarInstance::CalendarFind(const JsonValue& args, JsonObject& out) {
   const double callback_id = args.get("callbackId").get<double>();
-  auto get = [=](const std::shared_ptr<JsonValue>& response) -> void {
+  auto get = [=](const std::shared_ptr<JsonValue> & response)->void {
     try {
       JsonValue result = JsonValue(JsonArray());
       Calendar::GetInstance().Find(common::JsonCast<JsonObject>(args),
                                    result.get<JsonArray>());
       ReportSuccess(result, response->get<picojson::object>());
-    } catch (const PlatformException& e) {
+    }
+    catch (const PlatformException& e) {
       ReportError(e, response->get<picojson::object>());
     }
   };
 
-  auto get_response =
-      [callback_id, this](const std::shared_ptr<JsonValue>& response) -> void {
-        picojson::object& obj = response->get<picojson::object>();
-        obj.insert(std::make_pair("callbackId", callback_id));
-        LoggerD("callback isssssss %s", response->serialize().c_str());
-        PostMessage(response->serialize().c_str());
-      };
+  auto get_response = [ callback_id, this ](const std::shared_ptr<JsonValue> &
+                                            response)->void {
+    picojson::object& obj = response->get<picojson::object>();
+    obj.insert(std::make_pair("callbackId", callback_id));
+    LoggerD("callback isssssss %s", response->serialize().c_str());
+    PostMessage(response->serialize().c_str());
+  };
 
   TaskQueue::GetInstance().Queue<JsonValue>(
       get, get_response,
       std::shared_ptr<JsonValue>(new JsonValue(JsonObject())));
 }
 
-void CalendarInstance::Calendar_addChangeListener(const JsonValue& args,
-                                                  JsonObject& out) {
+void CalendarInstance::CalendarAddChangeListener(const JsonValue& args,
+                                                 JsonObject& out) {
   JsonValue val{JsonObject{}};
   Calendar::GetInstance().AddChangeListener(common::JsonCast<JsonObject>(args),
                                             val.get<JsonObject>());
   ReportSuccess(out);
 }
 
-void CalendarInstance::Calendar_removeChangeListener(const JsonValue& args,
-                                                     JsonObject& out) {
+void CalendarInstance::CalendarRemoveChangeListener(const JsonValue& args,
+                                                    JsonObject& out) {
   JsonValue val{JsonObject{}};
   Calendar::GetInstance().RemoveChangeListener(
       common::JsonCast<JsonObject>(args), val.get<JsonObject>());
@@ -211,43 +215,44 @@ void CalendarInstance::Calendar_removeChangeListener(const JsonValue& args,
 }
 
 // CalendarManager
-void CalendarInstance::CalendarManager_addCalendar(const JsonValue& args,
-                                                   JsonObject& out) {
+void CalendarInstance::CalendarManagerAddCalendar(const JsonValue& args,
+                                                  JsonObject& out) {
   JsonValue val{JsonObject{}};
   CalendarManager::GetInstance().AddCalendar(common::JsonCast<JsonObject>(args),
                                              val.get<JsonObject>());
   ReportSuccess(val, out);
 }
 
-void CalendarInstance::CalendarManager_getCalendar(const JsonValue& args,
-                                                   JsonObject& out) {
+void CalendarInstance::CalendarManagerGetCalendar(const JsonValue& args,
+                                                  JsonObject& out) {
   JsonValue val{JsonObject{}};
   CalendarManager::GetInstance().GetCalendar(common::JsonCast<JsonObject>(args),
                                              val.get<JsonObject>());
   ReportSuccess(val, out);
 }
 
-void CalendarInstance::CalendarManager_getCalendars(const JsonValue& args,
-                                                    JsonObject& out) {
+void CalendarInstance::CalendarManagerGetCalendars(const JsonValue& args,
+                                                   JsonObject& out) {
   const double callback_id = args.get("callbackId").get<double>();
-  auto get = [=](const std::shared_ptr<JsonValue>& response) -> void {
+  auto get = [=](const std::shared_ptr<JsonValue> & response)->void {
     try {
       JsonValue result = JsonValue(JsonArray());
       CalendarManager::GetInstance().GetCalendars(
           common::JsonCast<JsonObject>(args), result.get<JsonArray>());
       ReportSuccess(result, response->get<picojson::object>());
-    } catch (const PlatformException& e) {
+    }
+    catch (const PlatformException& e) {
       ReportError(e, response->get<picojson::object>());
     }
   };
 
-  auto get_response =
-      [callback_id, this](const std::shared_ptr<JsonValue>& response) -> void {
-        picojson::object& obj = response->get<picojson::object>();
-        obj.insert(std::make_pair("callbackId", callback_id));
-        LoggerD("callback is %s", response->serialize().c_str());
-        PostMessage(response->serialize().c_str());
-      };
+  auto get_response = [ callback_id, this ](const std::shared_ptr<JsonValue> &
+                                            response)->void {
+    picojson::object& obj = response->get<picojson::object>();
+    obj.insert(std::make_pair("callbackId", callback_id));
+    LoggerD("callback is %s", response->serialize().c_str());
+    PostMessage(response->serialize().c_str());
+  };
 
   TaskQueue::GetInstance().Queue<JsonValue>(
       get, get_response,

diff --git a/src/calendar/calendar_instance.h b/src/calendar/calendar_instance.h
index 5159593..025072c 100644 (file)
--- a/src/calendar/calendar_instance.h
+++ b/src/calendar/calendar_instance.h
@@ -18,21 +18,21 @@ class CalendarInstance : public common::ParsedInstance {
   static CalendarInstance& GetInstance();
 
  private:
-  void Calendar_get(const picojson::value& args, picojson::object& out);
-  void Calendar_add(const picojson::value& args, picojson::object& out);
-  void Calendar_addBatch(const picojson::value& args, picojson::object& out);
-  void Calendar_update(const picojson::value& args, picojson::object& out);
-  void Calendar_updateBatch(const picojson::value& args, picojson::object& out);
-  void Calendar_remove(const picojson::value& args, picojson::object& out);
-  void Calendar_removeBatch(const picojson::value& args, picojson::object& out);
-  void Calendar_find(const picojson::value& args, picojson::object& out);
-  void Calendar_addChangeListener(const picojson::value& args, picojson::object& out);
-  void Calendar_removeChangeListener(const picojson::value& args, picojson::object& out);
-
-  void CalendarManager_addCalendar(const picojson::value& args, picojson::object& out);
-  void CalendarManager_getCalendar(const picojson::value& args, picojson::object& out);
-  void CalendarManager_getCalendars(const picojson::value& args, picojson::object& out);
-  void CalendarManager_removeCalendar(const picojson::value& args, picojson::object& out);
+  void CalendarGet(const picojson::value& args, picojson::object& out);
+  void CalendarAdd(const picojson::value& args, picojson::object& out);
+  void CalendarAddBatch(const picojson::value& args, picojson::object& out);
+  void CalendarUpdate(const picojson::value& args, picojson::object& out);
+  void CalendarUpdateBatch(const picojson::value& args, picojson::object& out);
+  void CalendarRemove(const picojson::value& args, picojson::object& out);
+  void CalendarRemoveBatch(const picojson::value& args, picojson::object& out);
+  void CalendarFind(const picojson::value& args, picojson::object& out);
+  void CalendarAddChangeListener(const picojson::value& args, picojson::object& out);
+  void CalendarRemoveChangeListener(const picojson::value& args, picojson::object& out);
+
+  void CalendarManagerAddCalendar(const picojson::value& args, picojson::object& out);
+  void CalendarManagerGetCalendar(const picojson::value& args, picojson::object& out);
+  void CalendarManagerGetCalendars(const picojson::value& args, picojson::object& out);
+  void CalendarManagerRemoveCalendar(const picojson::value& args, picojson::object& out);
 
 };