From: Rafal Galka <r.galka@samsung.com>
Date: Mon, 2 Feb 2015 11:22:07 +0000 (+0900)
Subject: Revert "[Calendar] Renaming methods to match google style"
X-Git-Tag: submit/tizen_tv/20150603.064601~1^2~509
X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=b430ae6af134f719870ca618b20e259b48a49836;p=platform%2Fcore%2Fapi%2Fwebapi-plugins.git

Revert "[Calendar] Renaming methods to match google style"

This reverts commit 58c87b0d3800a147401fb6f1e778beb656b0cace.

Change-Id: I57b536007570b1d97d925cdc9e01a6d7783bb460
---

diff --git a/src/calendar/calendar_instance.cc b/src/calendar/calendar_instance.cc
index 3cc183f3..6fd917da 100644
--- a/src/calendar/calendar_instance.cc
+++ b/src/calendar/calendar_instance.cc
@@ -32,182 +32,178 @@ CalendarInstance::CalendarInstance() {
   RegisterSyncHandler(c, std::bind(&CalendarInstance::x, this, _1, _2));
 
   // Calendar
-  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);
+  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);
 
   // Calendar Manager
-  REGISTER_SYNC("CalendarManager_addCalendar", CalendarManagerAddCalendar);
-  REGISTER_SYNC("CalendarManager_getCalendar", CalendarManagerGetCalendar);
+  REGISTER_SYNC("CalendarManager_addCalendar", CalendarManager_addCalendar);
+  REGISTER_SYNC("CalendarManager_getCalendar", CalendarManager_getCalendar);
   REGISTER_SYNC("CalendarManager_removeCalendar",
-                CalendarManagerRemoveCalendar);
+                CalendarManager_removeCalendar);
 #undef REGISTER_SYNC
 
 #define REGISTER_ASYNC(c, x) \
   RegisterHandler(c, std::bind(&CalendarInstance::x, this, _1, _2));
-  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);
+  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);
 #undef REGISTER_ASYNC
 }
 
 CalendarInstance::~CalendarInstance() {}
 
-void CalendarInstance::CalendarGet(const JsonValue& args, JsonObject& out) {
+void CalendarInstance::Calendar_get(const JsonValue& args, JsonObject& out) {
   JsonValue val{JsonObject{}};
   Calendar::GetInstance().Get(common::JsonCast<JsonObject>(args),
                               val.get<JsonObject>());
   ReportSuccess(val, out);
 }
 
-void CalendarInstance::CalendarAdd(const JsonValue& args, JsonObject& out) {
+void CalendarInstance::Calendar_add(const JsonValue& args, JsonObject& out) {
   JsonValue val{JsonObject{}};
   Calendar::GetInstance().Add(common::JsonCast<JsonObject>(args),
                               val.get<JsonObject>());
   ReportSuccess(val, out);
 }
 
-void CalendarInstance::CalendarAddBatch(const JsonValue& args,
-                                        JsonObject& out) {
+void CalendarInstance::Calendar_addBatch(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::CalendarUpdate(const JsonValue& args, JsonObject& out) {
+void CalendarInstance::Calendar_update(const JsonValue& args, JsonObject& out) {
   JsonValue val{JsonObject{}};
   Calendar::GetInstance().Update(common::JsonCast<JsonObject>(args),
                                  val.get<JsonObject>());
   ReportSuccess(val, out);
 }
 
-void CalendarInstance::CalendarUpdateBatch(const JsonValue& args,
-                                           JsonObject& out) {
+void CalendarInstance::Calendar_updateBatch(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::CalendarRemove(const JsonValue& args, JsonObject& out) {
+void CalendarInstance::Calendar_remove(const JsonValue& args, JsonObject& out) {
   JsonValue val{JsonObject{}};
   Calendar::GetInstance().Remove(common::JsonCast<JsonObject>(args),
                                  val.get<JsonObject>());
   ReportSuccess(out);
 }
 
-void CalendarInstance::CalendarRemoveBatch(const JsonValue& args,
-                                           JsonObject& out) {
+void CalendarInstance::Calendar_removeBatch(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::CalendarFind(const JsonValue& args, JsonObject& out) {
+void CalendarInstance::Calendar_find(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::CalendarAddChangeListener(const JsonValue& args,
-                                                 JsonObject& out) {
+void CalendarInstance::Calendar_addChangeListener(const JsonValue& args,
+                                                  JsonObject& out) {
   JsonValue val{JsonObject{}};
   Calendar::GetInstance().AddChangeListener(common::JsonCast<JsonObject>(args),
                                             val.get<JsonObject>());
   ReportSuccess(out);
 }
 
-void CalendarInstance::CalendarRemoveChangeListener(const JsonValue& args,
-                                                    JsonObject& out) {
+void CalendarInstance::Calendar_removeChangeListener(const JsonValue& args,
+                                                     JsonObject& out) {
   JsonValue val{JsonObject{}};
   Calendar::GetInstance().RemoveChangeListener(
       common::JsonCast<JsonObject>(args), val.get<JsonObject>());
@@ -215,44 +211,43 @@ void CalendarInstance::CalendarRemoveChangeListener(const JsonValue& args,
 }
 
 // CalendarManager
-void CalendarInstance::CalendarManagerAddCalendar(const JsonValue& args,
-                                                  JsonObject& out) {
+void CalendarInstance::CalendarManager_addCalendar(const JsonValue& args,
+                                                   JsonObject& out) {
   JsonValue val{JsonObject{}};
   CalendarManager::GetInstance().AddCalendar(common::JsonCast<JsonObject>(args),
                                              val.get<JsonObject>());
   ReportSuccess(val, out);
 }
 
-void CalendarInstance::CalendarManagerGetCalendar(const JsonValue& args,
-                                                  JsonObject& out) {
+void CalendarInstance::CalendarManager_getCalendar(const JsonValue& args,
+                                                   JsonObject& out) {
   JsonValue val{JsonObject{}};
   CalendarManager::GetInstance().GetCalendar(common::JsonCast<JsonObject>(args),
                                              val.get<JsonObject>());
   ReportSuccess(val, out);
 }
 
-void CalendarInstance::CalendarManagerGetCalendars(const JsonValue& args,
-                                                   JsonObject& out) {
+void CalendarInstance::CalendarManager_getCalendars(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 025072c8..51595931 100644
--- 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 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);
+  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);
 
 };