wan

@@ -23,10 +23,10 @@ using namespace std;
 namespace fs = boost::filesystem;
 
 bool DmpMainServer::initialized_ = false;
-string DmpMainServer::module_path_ = "";
-string DmpMainServer::service_path_ = "";
+string DmpMainServer::modulePath_ = "";
+string DmpMainServer::servicePath_ = "";
 DmpServerManager *DmpMainServer::serverManager_ = nullptr;
-DmpServerInterfaceImpl *DmpMainServer::server_interface_ = nullptr;
+DmpServerInterfaceImpl *DmpMainServer::serverInterface_ = nullptr;
 
 DmpMainServer::DmpMainServer()
 {
@@ -41,13 +41,13 @@ bool DmpMainServer::Init()
         return false;
     }
     LOGGER_INFO("-------------------dmap server init start--------------------");
-    service_path_ = DmpApplication::Instance()->pkgDataPath() + "services";
+    servicePath_ = DmpApplication::Instance()->pkgDataPath() + "services";
     serverManager_ = new DmpServerManager();
-    server_interface_ = new DmpServerInterfaceImpl();
+    serverInterface_ = new DmpServerInterfaceImpl();
     // Load service module
-    module_path_ = DmpApplication::Instance()->libexecPath() + "server";
-    LOGGER_DEBUG("Initializing server modules from " + module_path_);
-    serverManager_->init(module_path_);
+    modulePath_ = DmpApplication::Instance()->libexecPath() + "server";
+    LOGGER_DEBUG("Initializing server modules from " + modulePath_);
+    serverManager_->init(modulePath_);
 
 #ifdef HAVE_SERVER_PYTHON_PLUGINS
     InitPython();
@@ -61,7 +61,7 @@ bool DmpMainServer::Init()
 void DmpMainServer::HandleRequest(DmpServerRequest &request, DmpServerResponse &response)
 {
     LOGGER_DEBUG("DmpMainServer: HandleRequest");
-    DmpFilterResponseDecorator responseDecorator(server_interface_->Filters(), response);
+    DmpFilterResponseDecorator responseDecorator(serverInterface_->filters(), response);
     DmpRequestHandler requestHandler(request, response);
     try
     {
@@ -73,7 +73,7 @@ void DmpMainServer::HandleRequest(DmpServerRequest &request, DmpServerResponse &
     }
 
     // Set the request handler into the interface for plugins to manipulate it
-    server_interface_->SetRequestHandler(&requestHandler);
+    serverInterface_->setRequestHandler(&requestHandler);
 
     try
     {

@@ -30,10 +30,10 @@ public:
 
 private:
   static bool initialized_;
-  static DmpServerInterfaceImpl *server_interface_;
+  static DmpServerInterfaceImpl *serverInterface_;
   static DmpServerManager *serverManager_;
-  static std::string module_path_;
-  static std::string service_path_;
+  static std::string modulePath_;
+  static std::string servicePath_;
 };
 
 #endif // __dmpmainserver_h__
\ No newline at end of file

@@ -9,22 +9,22 @@
 #include "dmpserverfilter.h"
 #include "dmplogger.h"
 
-DmpServerFilter::DmpServerFilter(DmpServerInterface *server_interface) : 
-    server_interface_(server_interface)
+DmpServerFilter::DmpServerFilter(DmpServerInterface *serverInterface) : 
+    serverInterface_(serverInterface)
 {
 }
 
-void DmpServerFilter::RequestReady()
+void DmpServerFilter::requestReady()
 {
     LOGGER_DEBUG("DmpServerFilter plugin default requestReady called");
 }
 
-void DmpServerFilter::ResponseComplete()
+void DmpServerFilter::responseComplete()
 {
     LOGGER_DEBUG("DmpServerFilter plugin default responseComplete called");
 }
 
-void DmpServerFilter::SendResponse()
+void DmpServerFilter::sendResponse()
 {
     LOGGER_DEBUG("DmpServerFilter plugin default sendResponse called");
 }

@@ -18,20 +18,20 @@ class DmpServerInterface;
 class SERVER_EXPORT DmpServerFilter
 {
 public:
-  DmpServerFilter(DmpServerInterface *server_interface);
+  DmpServerFilter(DmpServerInterface *serverInterface);
 
   virtual ~DmpServerFilter() = default;
 
-  DmpServerInterface *server_interface() { return server_interface_; }
+  DmpServerInterface *serverInterface() { return serverInterface_; }
 
-  virtual void RequestReady();
+  virtual void requestReady();
 
-  virtual void ResponseComplete();
+  virtual void responseComplete();
 
-  virtual void SendResponse();
+  virtual void sendResponse();
 
 private:
-  DmpServerInterface *server_interface_ = nullptr;
+  DmpServerInterface *serverInterface_ = nullptr;
 };
 
 typedef std::map<int, DmpServerFilter *> DmpServerFiltersMap;

@@ -11,9 +11,9 @@
 DmpServerInterface::DmpServerInterface()
 {
 }
-void DmpServerInterface::SetFilters(DmpServerFiltersMap *filters) 
+void DmpServerInterface::setFilters(DmpServerFiltersMap *filters) 
 {
 }
-void DmpServerInterface::SetRequestHandler( DmpRequestHandler *requestHandler )
+void DmpServerInterface::setRequestHandler( DmpRequestHandler *requestHandler )
 {
 }
\ No newline at end of file

@@ -23,15 +23,15 @@ public:
 
     virtual ~DmpServerInterface() = default;
 
-    virtual DmpRequestHandler *RequestHandler() = 0;
+    virtual DmpRequestHandler *requestHandler() = 0;
 
-    virtual void SetRequestHandler(DmpRequestHandler *requestHandler);
+    virtual void setRequestHandler(DmpRequestHandler *requestHandler);
 
-    virtual void SetFilters(DmpServerFiltersMap *filters) ;
+    virtual void setFilters(DmpServerFiltersMap *filters) ;
 
-    virtual void RegisterFilter( DmpServerFilter *filter, int priority = 0 ) = 0;
+    virtual void registerFilter( DmpServerFilter *filter, int priority = 0 ) = 0;
 
-    virtual DmpServerFiltersMap Filters(){ return filters_;}
+    virtual DmpServerFiltersMap filters(){ return filters_;}
 
 protected:
     

@@ -10,7 +10,7 @@
 
 DmpServerInterfaceImpl::DmpServerInterfaceImpl()
 {
-    request_handler_ = nullptr;
+    requestHandler_ = nullptr;
 // #ifdef HAVE_SERVER_PYTHON_PLUGINS
 //     mAccessControls = new QgsAccessControl();
 //     mCacheManager = new QgsServerCacheManager();
@@ -25,17 +25,17 @@ DmpServerInterfaceImpl::~DmpServerInterfaceImpl()
 // #endif
 }
 
-void DmpServerInterfaceImpl::SetRequestHandler(DmpRequestHandler *request_handler)
+void DmpServerInterfaceImpl::setRequestHandler(DmpRequestHandler *requestHandler)
 {
-    request_handler_ = request_handler;
+    requestHandler_ = requestHandler;
 }
 
-void DmpServerInterfaceImpl::RegisterFilter(DmpServerFilter *filter, int priority) 
+void DmpServerInterfaceImpl::registerFilter(DmpServerFilter *filter, int priority) 
 {
     filters_[priority] = filter;
 }
 
-void DmpServerInterfaceImpl::SetFilters(DmpServerFiltersMap *filters) 
+void DmpServerInterfaceImpl::setFilters(DmpServerFiltersMap *filters) 
 {
     filters_ = *filters;
 }
\ No newline at end of file

@@ -19,16 +19,15 @@ class SERVER_EXPORT DmpServerInterfaceImpl : public DmpServerInterface
   public:
 
     DmpServerInterfaceImpl();
-    // DmpServerInterfaceImpl();
     ~DmpServerInterfaceImpl() override;
   
-    DmpRequestHandler  *RequestHandler() override { return request_handler_; }
-    void SetRequestHandler( DmpRequestHandler *request_handler ) override;
-    void RegisterFilter(DmpServerFilter *filter, int priority = 0 ) override;
-    void SetFilters( DmpServerFiltersMap *filters ) override;
+    DmpRequestHandler  *requestHandler() override { return requestHandler_; }
+    void setRequestHandler( DmpRequestHandler *requestHandler ) override;
+    void registerFilter(DmpServerFilter *filter, int priority = 0 ) override;
+    void setFilters( DmpServerFiltersMap *filters ) override;
 
   private:
-    DmpRequestHandler *request_handler_ = nullptr;
+    DmpRequestHandler *requestHandler_ = nullptr;
 };
 
 #endif //__dmpserverinterfaceimpl_h__

@@ -141,27 +141,27 @@ struct DmpServerResponseWrap : DmpServerResponse, wrapper<DmpServerResponse>
 
 struct DmpServerFilterWrap : DmpServerFilter, wrapper<DmpServerFilter>
 {
-  DmpServerFilterWrap(DmpServerInterface *server_interface)
-        : DmpServerFilter(server_interface)
+  DmpServerFilterWrap(DmpServerInterface *serverInterface)
+        : DmpServerFilter(serverInterface)
   {
   }
 
-  void RequestReady()
+  void requestReady()
   {
     this->get_override("request_ready")();
   }
 
-  void RequestReadyDefault()
+  void requestReadyDefault()
   {
-    return this->DmpServerFilter::RequestReady();
+    return this->DmpServerFilter::requestReady();
   }
 
-  void ResponseComplete()
+  void responseComplete()
   {
     this->get_override("response_complete")();
   }
 
-  void SendResponse()
+  void sendResponse()
   {
     this->get_override("send_response")();
   }
@@ -169,18 +169,18 @@ struct DmpServerFilterWrap : DmpServerFilter, wrapper<DmpServerFilter>
 
 struct DmpServerInterfaceWrap : DmpServerInterface, wrapper<DmpServerInterface>
 {
-  virtual DmpRequestHandler *RequestHandler()
+  virtual DmpRequestHandler *requestHandler()
   {
     return this->get_override("request_handler")();
   }
-  virtual void RegisterFilter(DmpServerFilter *filter, int priority = 0)
+  virtual void registerFilter(DmpServerFilter *filter, int priority = 0)
   {
      this->get_override("register_filter")();
   }
-  virtual DmpServerManager *ServerManager()
-  {
-    return this->get_override("server_manager")();
-  }
+  // virtual DmpServerManager *ServerManager()
+  // {
+  //   return this->get_override("server_manager")();
+  // }
 };
 
 BOOST_PYTHON_MODULE(dmap_server)
@@ -220,12 +220,12 @@ BOOST_PYTHON_MODULE(dmap_server)
       .def("append_body", &DmpRequestHandler::AppendBody);
 
   class_<DmpServerFilterWrap, boost::noncopyable>("DmpServerFilter",init<DmpServerInterface*>())
-      .def("request_ready", &DmpServerFilterWrap::RequestReady, &DmpServerFilterWrap::RequestReadyDefault)
-      .def("response_complete", &DmpServerFilterWrap::ResponseComplete)
-      .def("send_response", &DmpServerFilterWrap::SendResponse)
-      .def("server_interface", &DmpServerFilterWrap::server_interface, return_internal_reference<>());
+      .def("request_ready", &DmpServerFilterWrap::requestReady, &DmpServerFilterWrap::requestReadyDefault)
+      .def("response_complete", &DmpServerFilterWrap::responseComplete)
+      .def("send_response", &DmpServerFilterWrap::sendResponse)
+      .def("server_interface", &DmpServerFilterWrap::serverInterface, return_internal_reference<>());
 
   class_<DmpServerInterfaceWrap, boost::noncopyable>("DmpServerInterface")
-      .def("register_filter", pure_virtual(&DmpServerInterface::RegisterFilter))
-      .def("request_handler", pure_virtual(&DmpServerInterface::RequestHandler), return_internal_reference<>());
+      .def("register_filter", pure_virtual(&DmpServerInterface::registerFilter))
+      .def("request_handler", pure_virtual(&DmpServerInterface::requestHandler), return_internal_reference<>());
 }
\ No newline at end of file