命名修改

@@ -8,14 +8,14 @@
 
     DmpPgsqlUtils::DmpPgsqlUtils()
     {}
-    DmpPgsqlUtils::DmpPgsqlUtils( const char* strConn_,std::string& Msg_)
+    DmpPgsqlUtils::DmpPgsqlUtils( const char* strConn,std::string& Msg)
     {
         //std::string strconn_="hostaddr=172.26.99.160 prot=5432 dbname='DmapServer' user='postgres' password='chinadci'";
-        conn_=strConn_;   
+        conn_=strConn;   
         basepconn_=PQconnectdb(conn_);
         if(PQstatus(basepconn_)!=CONNECTION_OK)
         {
-            Msg_= (std::string)PQerrorMessage(basepconn_);          
+            Msg= (std::string)PQerrorMessage(basepconn_);          
         }
     }
     DmpPgsqlUtils::~DmpPgsqlUtils()
@@ -32,9 +32,9 @@
         exit(1);  
     }  
 
-    bool DmpPgsqlUtils::GetDMapServices(std::map<int,DMapService> &dmapServices_,std::string& Msg_)
+    bool DmpPgsqlUtils::GetDMapServices(std::map<int,DMapService> &dmapServices,std::string& Msg)
     {
-        PGresult *res_;
+        PGresult *res;
         const char* strsql="SELECT  name, title, state::character, create_time, update_time, description, node::character, overview, type, service_guid, catalog_guid FROM public.dmap_service where type='WMTS'";
         //char* conn_="hostaddr=172.26.60.100 port=5432 dbname=dmap_manager_test user=postgres password=chinadci";     
         //PGconn* pconn_=PQconnectdb(conn_);
@@ -44,26 +44,26 @@
             PQfinish(basepconn_);
             return false;
         }        
-        res_ = PQexec(basepconn_,strsql);
-        int tuple_num=PQntuples(res_);
-        int field_num=PQnfields(res_);
+        res = PQexec(basepconn_,strsql);
+        int tuple_num=PQntuples(res);
+        int field_num=PQnfields(res);
         if(tuple_num>0)
         {
             for(int i=0;i<tuple_num;i++)
             {
-                std::string name_=PQgetvalue(res_,i,0);
-                std::string state_=PQgetvalue(res_,i,2);
-                std::string createtime_=PQgetvalue(res_,i,3);
-                std::string type_=PQgetvalue(res_,i,8);
-                std::string serviceguid_=PQgetvalue(res_,i,9);
+                std::string name=PQgetvalue(res,i,0);
+                std::string state=PQgetvalue(res,i,2);
+                std::string createtime=PQgetvalue(res,i,3);
+                std::string type=PQgetvalue(res,i,8);
+                std::string serviceguid=PQgetvalue(res,i,9);
                 DMapService service{
-                    .name=name_,
-                    .state=state_,
-                    .create_time=createtime_,
-                    .type=type_,
-                    .service_guid=serviceguid_
+                    .name=name,
+                    .state=state,
+                    .create_time=createtime,
+                    .type=type,
+                    .service_guid=serviceguid
                 };
-                dmapServices_[i]=service;
+                dmapServices[i]=service;
             }
             
         }   
@@ -71,170 +71,170 @@
         {
             return false;
         }
-        PQclear(res_);   
+        PQclear(res);   
         return true; 
     }
-    bool DmpPgsqlUtils::GetDMapService(DMapService &dmapService_,const std::string& servicename_,std::string& Msg_)
+    bool DmpPgsqlUtils::GetDMapService(DMapService &dmapService,const std::string& servicename,std::string& Msg)
     {
-        PGresult *res_;
-        std::string strsql_="SELECT  name, title, state::character, create_time, update_time, description, node::character, overview, type, service_guid, catalog_guid FROM public.dmap_service where name='"+servicename_+"'";
-        const char* csql_=strsql_.c_str();
+        PGresult *res;
+        std::string strsql="SELECT  name, title, state::character, create_time, update_time, description, node::character, overview, type, service_guid, catalog_guid FROM public.dmap_service where name='"+servicename+"'";
+        const char* csql=strsql.c_str();
         if(PQstatus(basepconn_)!=CONNECTION_OK)
         {
-            std::string Msg_= (std::string)PQerrorMessage(basepconn_);
+            std::string Msg= (std::string)PQerrorMessage(basepconn_);
             PQfinish(basepconn_);
             return false;
         }        
-        res_ = PQexec(basepconn_,csql_);
-        int tuple_num=PQntuples(res_);
-        int field_num=PQnfields(res_);
+        res = PQexec(basepconn_,csql);
+        int tuple_num=PQntuples(res);
+        int field_num=PQnfields(res);
         if(tuple_num==1)
         {           
-            std::string name_=PQgetvalue(res_,0,0);
-            std::string state_=PQgetvalue(res_,0,2);
-            std::string createtime_=PQgetvalue(res_,0,3);
-            std::string type_=PQgetvalue(res_,0,8);
-            std::string serviceguid_=PQgetvalue(res_,0,9);
+            std::string name=PQgetvalue(res,0,0);
+            std::string state=PQgetvalue(res,0,2);
+            std::string createtime=PQgetvalue(res,0,3);
+            std::string type=PQgetvalue(res,0,8);
+            std::string serviceguid=PQgetvalue(res,0,9);
             DMapService service{
-                .name=name_,
-                .state=state_,
-                .create_time=createtime_,
-                .type=type_,
-                .service_guid=serviceguid_
+                .name=name,
+                .state=state,
+                .create_time=createtime,
+                .type=type,
+                .service_guid=serviceguid
             };
-            dmapService_=service;           
+            dmapService=service;           
         }  
         else
         {
             return false;
         }   
-        PQclear(res_);   
+        PQclear(res);   
         return true; 
     }
     
-    bool DmpPgsqlUtils::GetDMapwmts(const std::string& serviceGuid_,DMapWmtsService& resWmts_,std::string& Msg_)
+    bool DmpPgsqlUtils::GetDMapwmts(const std::string& serviceGuid,DMapWmtsService& resWmts,std::string& Msg)
     {
         //char* conn_="hostaddr=172.26.60.100 port=5432 dbname=dmap_manager_test user=postgres password=chinadci"; 
-        std::string strsql_="SELECT  name, wmts_type, vendor, create_time::character, crs, datasource, metadata_url, scheme_guid	FROM public.dmap_wmts where guid='"+serviceGuid_+"'";
-        const char* csql_=strsql_.c_str();
+        std::string strsql="SELECT  name, wmts_type, vendor, create_time::character, crs, datasource, metadata_url, scheme_guid	FROM public.dmap_wmts where guid='"+serviceGuid+"'";
+        const char* csql=strsql.c_str();
             
         //PGconn* pconn_=PQconnectdb(conn_);
         if(PQstatus(basepconn_)!=CONNECTION_OK)
         {
-            std::string Msg_= (std::string)PQerrorMessage(basepconn_);
+            std::string Msg= (std::string)PQerrorMessage(basepconn_);
             PQfinish(basepconn_);
             return false;
         }        
-        PGresult *res_;
-        res_ = PQexec(basepconn_,csql_);
-        int tuple_num=PQntuples(res_);
-        int field_num=PQnfields(res_);
+        PGresult *res;
+        res = PQexec(basepconn_,csql);
+        int tuple_num=PQntuples(res);
+        int field_num=PQnfields(res);
         
         if(tuple_num>0)
         {            
-            resWmts_.name=PQgetvalue(res_,0,0);
-            resWmts_.type=PQgetvalue(res_,0,1);
-            std::string v=PQgetvalue(res_,0,2);            
-            resWmts_.vendor=StringToVendor(v);
-            resWmts_.create_time=PQgetvalue(res_,0,3);
-            resWmts_.crs=PQgetvalue(res_,0,4);
-            resWmts_.datasource=PQgetvalue(res_,0,5);
-            resWmts_.metadata_url=PQgetvalue(res_,0,6);
-            resWmts_.tile_id= PQgetvalue(res_,0,7);           
+            resWmts.name=PQgetvalue(res,0,0);
+            resWmts.type=PQgetvalue(res,0,1);
+            std::string v=PQgetvalue(res,0,2);            
+            resWmts.vendor=StringToVendor(v);
+            resWmts.create_time=PQgetvalue(res,0,3);
+            resWmts.crs=PQgetvalue(res,0,4);
+            resWmts.datasource=PQgetvalue(res,0,5);
+            resWmts.metadata_url=PQgetvalue(res,0,6);
+            resWmts.tile_id= PQgetvalue(res,0,7);           
         }
         else
         {
             return false;
         }
-        PQclear(res_);
+        PQclear(res);
         return true;
     }
-    bool DmpPgsqlUtils::GetDMapwmtsFromName(const std::string& serviceName_, DMapWmtsService& resWmts_,std::string& Msg_)
+    bool DmpPgsqlUtils::GetDMapwmtsFromName(const std::string& serviceName, DMapWmtsService& resWmts,std::string& Msg)
     {
-        std::string strsql_="SELECT  name, wmts_type, vendor, create_time::character, crs, datasource, metadata_url,layer_name, layer_alias, layer_title, layer_style, layer_format, layer_extent, scheme_guid	FROM public.dmap_wmts where name='"+serviceName_+"'";
-        const char* csql_=strsql_.c_str();
+        std::string strsql="SELECT  name, wmts_type, vendor, create_time::character, crs, datasource, metadata_url,layer_name, layer_alias, layer_title, layer_style, layer_format, layer_extent, scheme_guid	FROM public.dmap_wmts where name='"+serviceName+"'";
+        const char* csql=strsql.c_str();
             
         //PGconn* pconn_=PQconnectdb(conn_);
         if(PQstatus(basepconn_)!=CONNECTION_OK)
         {
-            std::string Msg_= (std::string)PQerrorMessage(basepconn_);
+            std::string Msg= (std::string)PQerrorMessage(basepconn_);
             PQfinish(basepconn_);
             return false;
         }        
-        PGresult *res_;
-        res_ = PQexec(basepconn_,csql_);
-        int tuple_num=PQntuples(res_);
-        int field_num=PQnfields(res_);
+        PGresult *res;
+        res = PQexec(basepconn_,csql);
+        int tuple_num=PQntuples(res);
+        int field_num=PQnfields(res);
         
         if(tuple_num>0)
         {            
-            resWmts_.name=PQgetvalue(res_,0,0);
-            resWmts_.type=PQgetvalue(res_,0,1);
-            std::string v=PQgetvalue(res_,0,2);            
-            resWmts_.vendor=StringToVendor(v);
-            resWmts_.create_time=PQgetvalue(res_,0,3);
-            resWmts_.crs=PQgetvalue(res_,0,4);
-            resWmts_.datasource=PQgetvalue(res_,0,5);
-            resWmts_.metadata_url=PQgetvalue(res_,0,6);
-            resWmts_.layername=PQgetvalue(res_,0,7);
-            resWmts_.layer_alias=PQgetvalue(res_,0,8);
-            resWmts_.layer_tile=PQgetvalue(res_,0,9);
-            resWmts_.layer_style=PQgetvalue(res_,0,10);
-            resWmts_.layer_format=PQgetvalue(res_,0,11);
-            resWmts_.layer_extent=PQgetvalue(res_,0,12);          
-            resWmts_.tile_id= PQgetvalue(res_,0,13);           
+            resWmts.name=PQgetvalue(res,0,0);
+            resWmts.type=PQgetvalue(res,0,1);
+            std::string v=PQgetvalue(res,0,2);            
+            resWmts.vendor=StringToVendor(v);
+            resWmts.create_time=PQgetvalue(res,0,3);
+            resWmts.crs=PQgetvalue(res,0,4);
+            resWmts.datasource=PQgetvalue(res,0,5);
+            resWmts.metadata_url=PQgetvalue(res,0,6);
+            resWmts.layername=PQgetvalue(res,0,7);
+            resWmts.layer_alias=PQgetvalue(res,0,8);
+            resWmts.layer_tile=PQgetvalue(res,0,9);
+            resWmts.layer_style=PQgetvalue(res,0,10);
+            resWmts.layer_format=PQgetvalue(res,0,11);
+            resWmts.layer_extent=PQgetvalue(res,0,12);          
+            resWmts.tile_id= PQgetvalue(res,0,13);           
         }
         else
         {
             return false;
         }
-        PQclear(res_);
+        PQclear(res);
         return true;
     }
-    bool DmpPgsqlUtils::GetTileScheme(const std::string& guid_,TileScheme& tileScheme_,std::string& Msg_)
+    bool DmpPgsqlUtils::GetTileScheme(const std::string& guid,TileScheme& tileScheme,std::string& Msg)
     {
-        std::string strsql_="SELECT guid, name, alias, description, crs, crs_wkt, extent, top_left, levels, dpi::character, rows::character, cols::character, update_time, parameter FROM public.dmap_tile_scheme where guid='"+guid_+"'";
-        const char* csql_=strsql_.c_str();
+        std::string strsql="SELECT guid, name, alias, description, crs, crs_wkt, extent, top_left, levels, dpi::character, rows::character, cols::character, update_time, parameter FROM public.dmap_tile_scheme where guid='"+guid+"'";
+        const char* csql=strsql.c_str();
             
         //PGconn* pconn_=PQconnectdb(conn_);
         if(PQstatus(basepconn_)!=CONNECTION_OK)
         {
-            std::string Msg_= (std::string)PQerrorMessage(basepconn_);
+            std::string Msg= (std::string)PQerrorMessage(basepconn_);
             PQfinish(basepconn_);
             return false;
         }        
-        PGresult *res_;
-        res_ = PQexec(basepconn_,csql_);
-        int tuple_num=PQntuples(res_);
-        int field_num=PQnfields(res_);
+        PGresult *res;
+        res = PQexec(basepconn_,csql);
+        int tuple_num=PQntuples(res);
+        int field_num=PQnfields(res);
         
         if(tuple_num>0)
         {            
-            tileScheme_.guid=PQgetvalue(res_,0,0);
-            tileScheme_.name=PQgetvalue(res_,0,1);
-            tileScheme_.crs=PQgetvalue(res_,0,4);
-            tileScheme_.wkt=PQgetvalue(res_,0,5);
-            tileScheme_.layer_extent=PQgetvalue(res_,0,6);
-            tileScheme_.top_left=PQgetvalue(res_,0,7);
-            tileScheme_.levels=PQgetvalue(res_,0,8);
-            tileScheme_.dpi=PQgetvalue(res_,0,9);
-            tileScheme_.rows=PQgetvalue(res_,0,10);
-            tileScheme_.cols=PQgetvalue(res_,0,11);
+            tileScheme.guid=PQgetvalue(res,0,0);
+            tileScheme.name=PQgetvalue(res,0,1);
+            tileScheme.crs=PQgetvalue(res,0,4);
+            tileScheme.wkt=PQgetvalue(res,0,5);
+            tileScheme.layer_extent=PQgetvalue(res,0,6);
+            tileScheme.top_left=PQgetvalue(res,0,7);
+            tileScheme.levels=PQgetvalue(res,0,8);
+            tileScheme.dpi=PQgetvalue(res,0,9);
+            tileScheme.rows=PQgetvalue(res,0,10);
+            tileScheme.cols=PQgetvalue(res,0,11);
         }
         else
         {
             return false;
         }
-        PQclear(res_);
+        PQclear(res);
         return true;
     }
-    bool DmpPgsqlUtils::CreatServerPTree(const DMapService &dmapServices_,const DMapWmtsService& resWmts_,boost::property_tree::ptree& pt_root)
+    bool DmpPgsqlUtils::CreatServerPTree(const DMapService &dmapServices,const DMapWmtsService& resWmts,boost::property_tree::ptree& pt_root)
     {
         boost::property_tree::ptree pt_properties;
-        pt_root.add("serviceName",dmapServices_.name);
-        pt_root.add("mapType",dmapServices_.type);
-        pt_root.add("state",dmapServices_.state);
-        pt_root.add("capabilities",dmapServices_.type+"Server");
+        pt_root.add("serviceName",dmapServices.name);
+        pt_root.add("mapType",dmapServices.type);
+        pt_root.add("state",dmapServices.state);
+        pt_root.add("capabilities",dmapServices.type+"Server");
         pt_root.add_child("properties",pt_properties);
         pt_properties.add("filePath","postgresql");
         pt_properties.add("maxScale","");
@@ -243,40 +243,40 @@
         //pt_service.add("typeName",atoi(dmpwmtsservices_.type.c_str()));
         pt_service.add("typeName",0);
         pt_service.add("enabled","true");
-        pt_service.add("properties.tileVersion",resWmts_.vendor);
-        pt_service.add("properties.tilePath",resWmts_.datasource);
+        pt_service.add("properties.tileVersion",resWmts.vendor);
+        pt_service.add("properties.tilePath",resWmts.datasource);
         pt_service.add("capabilities","");
         pt_services.push_back(std::make_pair("", pt_service)); 
         pt_root.put_child("services",pt_services);
         return true;
     }
-    bool DmpPgsqlUtils::GetDMapServices(DMapService &dmapService_,const std::string serviceName_,std::string& Msg_)
+    bool DmpPgsqlUtils::GetDMapServices(DMapService &dmapService,const std::string serviceName,std::string& Msg)
     {
-        PGresult *res_;
+        PGresult *res;
         const char* strsql="SELECT  name, title, state::character, create_time, update_time, description, node::character, overview, type, service_guid, catalog_guid FROM public.dmap_service where type='WMTS'";
         //char* conn_="hostaddr=172.26.60.100 port=5432 dbname=dmap_manager_test user=postgres password=chinadci";     
         //PGconn* pconn_=PQconnectdb(conn_);
         if(PQstatus(basepconn_)!=CONNECTION_OK)
         {
-            std::string Msg_= (std::string)PQerrorMessage(basepconn_);
+            std::string Msg= (std::string)PQerrorMessage(basepconn_);
             PQfinish(basepconn_);
             return false;
         }        
-        res_ = PQexec(basepconn_,strsql);
-        int tuple_num=PQntuples(res_);
+        res = PQexec(basepconn_,strsql);
+        int tuple_num=PQntuples(res);
         if(tuple_num>0)
         {
-            dmapService_.name=PQgetvalue(res_,0,0);
-            dmapService_.state=PQgetvalue(res_,0,2);
-            dmapService_.create_time=PQgetvalue(res_,0,3);
-            dmapService_.type=PQgetvalue(res_,0,8);
-            dmapService_.service_guid=PQgetvalue(res_,0,9);
+            dmapService.name=PQgetvalue(res,0,0);
+            dmapService.state=PQgetvalue(res,0,2);
+            dmapService.create_time=PQgetvalue(res,0,3);
+            dmapService.type=PQgetvalue(res,0,8);
+            dmapService.service_guid=PQgetvalue(res,0,9);
         }  
         else
         {
             return false;
         }   
-        PQclear(res_);   
+        PQclear(res);   
         return true; 
     }
 

@@ -68,15 +68,15 @@
         DmpPgsqlUtils();
         ~DmpPgsqlUtils();
         
-        void do_exit(PGconn *conn_);
+        void do_exit(PGconn *conn);
         //bool ExecuteQuery(const std::string& sqlstr,resMap& resMap_,std::string& Msg_);
-        bool GetDMapServices(std::map<int,DMapService> &dmapServices_,std::string& Msg_);
-        bool GetDMapService(DMapService &dmapService_,const std::string& servicename_,std::string& Msg_);
-        bool GetDMapwmts(const std::string& serviceGuid_, DMapWmtsService& resWmts_,std::string& Msg_);
-        bool GetDMapwmtsFromName(const std::string& serviceName_, DMapWmtsService& resWmts_,std::string& Msg_);
-        bool GetTileScheme(const std::string& guid_, TileScheme& tileScheme_,std::string& Msg_);
-        bool CreatServerPTree(const DMapService &dmapServices_,const DMapWmtsService& resWmts_,boost::property_tree::ptree& pt_root);
-        bool GetDMapServices(DMapService &dmapService_,const std::string serviceName_,std::string& Msg_);
+        bool GetDMapServices(std::map<int,DMapService> &dmapServices,std::string& Msg);
+        bool GetDMapService(DMapService &dmapService,const std::string& servicename,std::string& Msg);
+        bool GetDMapwmts(const std::string& serviceGuid, DMapWmtsService& resWmts,std::string& Msg);
+        bool GetDMapwmtsFromName(const std::string& serviceName, DMapWmtsService& resWmts,std::string& Msg);
+        bool GetTileScheme(const std::string& guid, TileScheme& tileScheme,std::string& Msg);
+        bool CreatServerPTree(const DMapService &dmapServices,const DMapWmtsService& resWmts,boost::property_tree::ptree& pt_root);
+        bool GetDMapServices(DMapService &dmapService,const std::string serviceName,std::string& Msg);
         std::string StringToVendor(const std::string str);
     };
     

@@ -145,11 +145,11 @@ bool DmpServerManager::stopService(const std::string &serverName, const std::str
 }
 bool DmpServerManager::LoadServices()
 {
-    boost::property_tree::ptree pt_,ptList_;
+    boost::property_tree::ptree pt,ptList;
 
-    const std::string url_="http://172.26.60.100:8841/API/Service/TileService/Reload";
-    std::string strContent_=DmpHttp::get(url_);
-    if(strContent_.length()==0)
+    const std::string url="http://172.26.60.100:8841/API/Service/TileService/Reload";
+    std::string strContent=DmpHttp::get(url);
+    if(strContent.length()==0)
     {
         return false;
     }
@@ -162,21 +162,21 @@ bool DmpServerManager::LoadServices()
     // }
     //boost::property_tree::read_json("./example.txt", pt_);
     
-    std::stringstream ssData_;
-    ssData_<<strContent_.c_str();
-    boost::property_tree::read_json(ssData_, pt_);
-    int iCount_ = std::atoi(pt_.get<std::string>("data.count").c_str());
-    if(iCount_>0)
+    std::stringstream ssData;
+    ssData<<strContent.c_str();
+    boost::property_tree::read_json(ssData, pt);
+    int iCount = std::atoi(pt.get<std::string>("data.count").c_str());
+    if(iCount>0)
     {
-        ptList_=pt_.get_child("data.list");
-        for (auto& e : ptList_) 
+        ptList=pt.get_child("data.list");
+        for (auto& e : ptList) 
         {
-            std::string name_=e.second.get<std::string>("name");
-            std::string title_ = e.second.get<std::string>("title");
-            std::string type_ = e.second.get<std::string>("type");
-            int capabilities_ =e.second.get<int>("capabilities");
-            std::string project_ = e.second.get<std::string>("project");
-            this->publish(type_,name_,capabilities_,project_);
+            std::string name = e.second.get<std::string>("name");
+            std::string title = e.second.get<std::string>("title");
+            std::string type = e.second.get<std::string>("type");
+            int capabilities =e.second.get<int>("capabilities");
+            std::string project = e.second.get<std::string>("project");
+            this->publish(type,name,capabilities,project);
         }
     }
     return true;

@@ -177,7 +177,7 @@ void DmpManagerApiHandler::startService(const DmpServerApiContext &context) cons
         }
         default:
         {
-       
+            
         }
     }
 }

@@ -35,38 +35,38 @@ namespace DmpTms
     
     if(context.request()->isRestful())
     {
-      std::string path_=context.request()->path();
-      std::vector<std::string> vec_;
-      boost::split(vec_,context.request()->path(),boost::is_any_of("/"),boost::token_compress_on);
-      int isize_=vec_.size();
-      if(isize_<4)
+      std::string path=context.request()->path();
+      std::vector<std::string> vec;
+      boost::split(vec,context.request()->path(),boost::is_any_of("/"),boost::token_compress_on);
+      int isize=vec.size();
+      if(isize<4)
       {
         context.response()->write("Tms,Operation is null");
         return;
       }
-      std::string::size_type idx0_,idx1_;
-      idx0_=vec_[isize_-1].find("png");
-      idx1_=vec_[isize_-1].find("jpg");
+      std::string::size_type idx0,idx1;
+      idx0=vec[isize-1].find("png");
+      idx1=vec[isize-1].find("jpg");
       
-      if((idx0_!=std::string::npos)||(idx1_!=std::string::npos))
+      if((idx0!=std::string::npos)||(idx1!=std::string::npos))
       {
-        std::vector<std::string> vec0_;
-        boost::split(vec0_,vec_[isize_-1],boost::is_any_of("."),boost::token_compress_on);
-        int tileCol_=atoi(vec0_[0].c_str());
-        int tileRow_=atoi(vec_[isize_-2].c_str());
-        int tileMatrix_=atoi(vec_[isize_-3].c_str());
+        std::vector<std::string> vec0;
+        boost::split(vec0,vec[isize-1],boost::is_any_of("."),boost::token_compress_on);
+        int tileCol=atoi(vec0[0].c_str());
+        int tileRow=atoi(vec[isize-2].c_str());
+        int tileMatrix=atoi(vec[isize-3].c_str());
         const DmpProject *project = context.project();
-        DmpTileLayer *tileLayer = static_cast<DmpTileLayer *>(project->getLayer("layer"));
-        std::string format_=vec0_[1].c_str();
-        std::string filePath_=tileLayer->getDataSource();
-        if(filePath_.empty())
+        DmpTileLayer *tileLayer = static_cast<DmpTileLayer *>(project->getLayer());
+        std::string format=vec0[1].c_str();
+        std::string filePath=tileLayer->getDataSource();
+        if(filePath.empty())
         {
           context.response()->write("Tms,Operation is null");
         }
         else
         {
-          DmpTmsTileProvider provider_=DmpTmsTileProvider(filePath_);
-          provider_.WriteTile(tileRow_, tileCol_, tileMatrix_, format_, *context.response()); 
+          DmpTmsTileProvider provider_=DmpTmsTileProvider(filePath);
+          provider_.WriteTile(tileRow, tileCol, tileMatrix, format, *context.response()); 
         }
       }
       else

@@ -12,11 +12,11 @@ namespace DmpTms
 {
     DmpTmsTileProvider::DmpTmsTileProvider(const std::string& root_path)
     {
-        file_rootPath=root_path;
+        file_rootPath_=root_path;
     }
     void DmpTmsTileProvider::WriteTile(const int row, const int col, const int level, const std::string& format, DmpServerResponse& response)
     {
-        std::string tile_path = file_rootPath+"/"+std::to_string(level)+"/"+std::to_string(row)+"/"+std::to_string(col)+"."+format;
+        std::string tile_path = file_rootPath_+"/"+std::to_string(level)+"/"+std::to_string(row)+"/"+std::to_string(col)+"."+format;
         std::ifstream fread(tile_path, std::ifstream::binary);
         if(!fread)
         {           

@@ -21,7 +21,7 @@ namespace DmpTms
       DmpTmsTileProvider(const std::string& root_path);
       void WriteTile(const int row, const int col, const int level, const std::string& format, DmpServerResponse& response) ;
     protected:
-      std::string file_rootPath;
+      std::string file_rootPath_;
   };
 }
 

@@ -52,56 +52,56 @@ namespace DmpWmts
         return;
       }
    }
-   void DmpCapabiliTilesOperation::WriteCapabilities(boost::property_tree::ptree& pt_,const std::string& host_,const std::string& servicename,DmpServerResponse& response)
+   void DmpCapabiliTilesOperation::WriteCapabilities(boost::property_tree::ptree& pt,const std::string& host,const std::string& servicename,DmpServerResponse& response)
    {
       //构建能力文档
-      boost::property_tree::ptree pt_root_,pt_TileMatrix_;
-      CreateGetCapabilitiesDocument(host_,servicename,pt_root_);
-      pt_root_.add("Capabilities.Contents.Layer.ows:Title",pt_.get<std::string>("Layer.ows:Title"));
-      pt_root_.add("Capabilities.Contents.Layer.ows:Abstract",pt_.get<std::string>("Layer.ows:Abstract"));
-      pt_root_.add("Capabilities.Contents.Layer.ows:Identifier",pt_.get<std::string>("Layer.ows:Identifier"));
+      boost::property_tree::ptree pt_root,pt_TileMatrix;
+      CreateGetCapabilitiesDocument(host,servicename,pt_root);
+      pt_root.add("Capabilities.Contents.Layer.ows:Title",pt.get<std::string>("Layer.ows:Title"));
+      pt_root.add("Capabilities.Contents.Layer.ows:Abstract",pt.get<std::string>("Layer.ows:Abstract"));
+      pt_root.add("Capabilities.Contents.Layer.ows:Identifier",pt.get<std::string>("Layer.ows:Identifier"));
       //pt_root_.add("Capabilities.Contents.Layer.Style.<xmlattr>.isDefault",pt_.get<std::string>("Layer.Style.<xmlattr>.isDefault"));
-      pt_root_.add("Capabilities.Contents.Layer.Style",pt_.get<std::string>("Layer.Style"));
-      pt_root_.add("Capabilities.Contents.Layer.Format",pt_.get<std::string>("Layer.Format"));
-      pt_root_.add("Capabilities.Contents.Layer.TileMatrixSetLink.TileMatrixSet",pt_.get<std::string>("Layer.TileMatrixSetLink.TileMatrixSet"));
+      pt_root.add("Capabilities.Contents.Layer.Style",pt.get<std::string>("Layer.Style"));
+      pt_root.add("Capabilities.Contents.Layer.Format",pt.get<std::string>("Layer.Format"));
+      pt_root.add("Capabilities.Contents.Layer.TileMatrixSetLink.TileMatrixSet",pt.get<std::string>("Layer.TileMatrixSetLink.TileMatrixSet"));
       
-      boost::property_tree::ptree pt_TileMatrixSet_;
-      pt_TileMatrixSet_.add("ows:Identifier",pt_.get<std::string>("TileMatrixSet.ows:Identifier"));
-      pt_TileMatrixSet_.add("ows:SupportedCRS",pt_.get<std::string>("TileMatrixSet.ows:SupportedCRS"));
-      pt_TileMatrixSet_.add("TileWidth",pt_.get<std::string>("TileMatrixSet.TileWidth"));
-      pt_TileMatrixSet_.add("TileHeight",pt_.get<std::string>("TileMatrixSet.TileHeight"));
-      pt_TileMatrixSet_.add("TopLeftCorner",pt_.get<std::string>("TileMatrixSet.TopLeftCorner"));
-      pt_TileMatrixSet_.add("Dpi",pt_.get<std::string>("TileMatrixSet.DPI"));
+      boost::property_tree::ptree pt_TileMatrixSet;
+      pt_TileMatrixSet.add("ows:Identifier",pt.get<std::string>("TileMatrixSet.ows:Identifier"));
+      pt_TileMatrixSet.add("ows:SupportedCRS",pt.get<std::string>("TileMatrixSet.ows:SupportedCRS"));
+      pt_TileMatrixSet.add("TileWidth",pt.get<std::string>("TileMatrixSet.TileWidth"));
+      pt_TileMatrixSet.add("TileHeight",pt.get<std::string>("TileMatrixSet.TileHeight"));
+      pt_TileMatrixSet.add("TopLeftCorner",pt.get<std::string>("TileMatrixSet.TopLeftCorner"));
+      pt_TileMatrixSet.add("Dpi",pt.get<std::string>("TileMatrixSet.DPI"));
      
       //pt_TileMatrix_=pt_.get_child("TileMatrixSet.TileMatrix");
-      pt_TileMatrix_=pt_.get_child("TileMatrixSet.Levels");
-      int i=pt_TileMatrix_.size();
-      boost::property_tree::ptree::iterator pos_ = pt_TileMatrix_.begin();
-      for (; pos_ != pt_TileMatrix_.end(); ++pos_ )
+      pt_TileMatrix=pt.get_child("TileMatrixSet.Levels");
+      int i=pt_TileMatrix.size();
+      boost::property_tree::ptree::iterator pos = pt_TileMatrix.begin();
+      for (; pos != pt_TileMatrix.end(); ++pos )
       {
-            boost::property_tree::ptree pt_level_;
-            boost::property_tree::ptree ptTile_ = pos_->second;
-            std::string level_=ptTile_.get<std::string>("level");
-            std::string scale_=ptTile_.get<std::string>("scale");
-            std::string resolution_=ptTile_.get<std::string>("resolution");
-            pt_level_.add("ows:Identifier",level_);
-            pt_level_.add("ows:ScaleDenominator",scale_);
-            pt_level_.add("ows:Resolution",resolution_);
+            boost::property_tree::ptree pt_level;
+            boost::property_tree::ptree ptTile = pos->second;
+            std::string level=ptTile.get<std::string>("level");
+            std::string scale=ptTile.get<std::string>("scale");
+            std::string resolution=ptTile.get<std::string>("resolution");
+            pt_level.add("ows:Identifier",level);
+            pt_level.add("ows:ScaleDenominator",scale);
+            pt_level.add("ows:Resolution",resolution);
             
-            pt_TileMatrixSet_.add_child("TileMatrix",pt_level_);
+            pt_TileMatrixSet.add_child("TileMatrix",pt_level);
       }
-      pt_root_.add_child("Capabilities.Contents.TileMatrixSet",pt_TileMatrixSet_);
+      pt_root.add_child("Capabilities.Contents.TileMatrixSet",pt_TileMatrixSet);
       //pt_root_.add("Capabilities.Contents.TileMatrixSet.TileMatrix.ows:Identifier",pt_.get<std::string>("TileMatrixSet.TileMatrix.ows:Identifier"));
       //pt_root_.add("Capabilities.Contents.TileMatrixSet.TileMatrix.TopLeftCorner",pt_.get<std::string>("TileMatrixSet.TileMatrix.TopLeftCorner"));
-      std::string http_cap0_="http://"+host_+"/DMap/Services/"+servicename+"/TileServer/WMTSService/1.0.0/WMTSCapabilities.xml";
-      pt_root_.add("Capabilities.ServiceMetadataURL.<xmlattr>.xlink:href",http_cap0_);
+      std::string http_cap0="http://"+host+"/DMap/Services/"+servicename+"/TileServer/WMTSService/1.0.0/WMTSCapabilities.xml";
+      pt_root.add("Capabilities.ServiceMetadataURL.<xmlattr>.xlink:href",http_cap0);
       
       //写入流
       std::stringstream ss;
-      boost::property_tree::write_xml(ss,pt_root_);
-      std::string strExtent_=ss.str();    
+      boost::property_tree::write_xml(ss,pt_root);
+      std::string strExtent=ss.str();    
       response.setHeader("Content-Type", "application/xml;charset=utf-8");
-      response.write(strExtent_);
+      response.write(strExtent);
       return;
       /*
       //文件流代换写入
@@ -138,7 +138,7 @@ namespace DmpWmts
    void DmpCapabiliTilesOperation::GetCapabilitiesDocument(DmpServerResponse& response)
    {    
    }
-   void DmpCapabiliTilesOperation::CreateGetCapabilitiesDocument(const std::string& host_,const std::string& servicename,boost::property_tree::ptree& pt)
+   void DmpCapabiliTilesOperation::CreateGetCapabilitiesDocument(const std::string& host,const std::string& servicename,boost::property_tree::ptree& pt)
    {
       pt.add("Capabilities.<xmlattr>.xmlns",WMTS_NAMESPACE);
       pt.add("Capabilities.<xmlattr>.xmlns:gml",GML_NAMESPACE);
@@ -153,7 +153,7 @@ namespace DmpWmts
       pt.add_child("Capabilities.ows:ServiceIdentification",pt_Identification);
       GetServiceProviderElement(pt_Provider);
       pt.add_child("Capabilities.ows:ServiceProvider",pt_Provider);
-      GetServiceMetadataElement(host_,servicename,pt_Metadata);
+      GetServiceMetadataElement(host,servicename,pt_Metadata);
       pt.add_child("Capabilities.ows:OperationsMetadata",pt_Metadata);
       //pt.add("Capabilities.Contents.Layer",servicename);
 
@@ -178,38 +178,38 @@ namespace DmpWmts
       pt.add("ows:ServiceContact.ows:ContactInfo.ows:Phone","020-87578877");
    }
 
-   void DmpCapabiliTilesOperation:: GetServiceMetadataElement(const std::string& host_,const std::string& servicename,boost::property_tree::ptree& pt)
+   void DmpCapabiliTilesOperation:: GetServiceMetadataElement(const std::string& host,const std::string& servicename,boost::property_tree::ptree& pt)
    {
       //localhost:8080/DMap/Services/GDWMTS/MapServer/WMTSServer?request=GetCapabilities
-      std::string http_cap0_="http://"+host_+"/DMap/Services/"+servicename+"/TileServer/WMTSService/1.0.0/WMTSCapabilities.xml";
-      std::string http_cap1_="http://"+host_+"/DMap/Services/"+servicename+"/TileServer/WMTSService?";
-      std::string http_cap2_="http://"+host_+"/DMap/Services/"+servicename+"/TileServer/WMTSService/1.0.0/";   
-      boost::property_tree::ptree pt_child0_,pt_child1_;
+      std::string http_cap0="http://"+host+"/DMap/Services/"+servicename+"/TileServer/WMTSService/1.0.0/WMTSCapabilities.xml";
+      std::string http_cap1="http://"+host+"/DMap/Services/"+servicename+"/TileServer/WMTSService?";
+      std::string http_cap2="http://"+host+"/DMap/Services/"+servicename+"/TileServer/WMTSService/1.0.0/";   
+      boost::property_tree::ptree pt_child0,pt_child1;
       
-      pt_child0_.add("<xmlattr>.name","GetCapabilities");
-      boost::property_tree::ptree pt_child00_,pt_child01_;
-      pt_child00_.add("ows:HTTP.ows:Get.<xmlattr>.xlink:href",http_cap0_);
-      pt_child00_.add("ows:HTTP.ows:Get.ows:Constraint.<xmlattr>.name","GetEncoding");
-      pt_child00_.add("ows:HTTP.ows:Get.ows:Constraint.ows:AllowedValues.ows:Value","RESTful");
-      pt_child0_.add_child("ows:DCP",pt_child00_);
+      pt_child0.add("<xmlattr>.name","GetCapabilities");
+      boost::property_tree::ptree pt_child00,pt_child01;
+      pt_child00.add("ows:HTTP.ows:Get.<xmlattr>.xlink:href",http_cap0);
+      pt_child00.add("ows:HTTP.ows:Get.ows:Constraint.<xmlattr>.name","GetEncoding");
+      pt_child00.add("ows:HTTP.ows:Get.ows:Constraint.ows:AllowedValues.ows:Value","RESTful");
+      pt_child0.add_child("ows:DCP",pt_child00);
 
-      pt_child01_.add("ows:HTTP.ows:Get.<xmlattr>.xlink:href",http_cap1_);
-      pt_child01_.add("ows:HTTP.ows:Get.ows:Constraint.<xmlattr>.name","GetEncoding");
-      pt_child01_.add("ows:HTTP.ows:Get.ows:Constraint.ows:AllowedValues.ows:Value","KVP");
-      pt_child0_.add_child("ows:DCP",pt_child01_);
-      pt.add_child("ows:Operation",pt_child0_);
+      pt_child01.add("ows:HTTP.ows:Get.<xmlattr>.xlink:href",http_cap1);
+      pt_child01.add("ows:HTTP.ows:Get.ows:Constraint.<xmlattr>.name","GetEncoding");
+      pt_child01.add("ows:HTTP.ows:Get.ows:Constraint.ows:AllowedValues.ows:Value","KVP");
+      pt_child0.add_child("ows:DCP",pt_child01);
+      pt.add_child("ows:Operation",pt_child0);
       
-      pt_child1_.add("<xmlattr>.name","GetTile");
-      boost::property_tree::ptree pt_child10_,pt_child11_;
-      pt_child10_.add("ows:HTTP.ows:Get.<xmlattr>.xlink:href",http_cap2_);
-      pt_child10_.add("ows:HTTP.ows:Get.ows:Constraint.<xmlattr>.name","GetEncoding");
-      pt_child10_.add("ows:HTTP.ows:Get.ows:Constraint.ows:AllowedValues.ows:Value","RESTful");
-      pt_child1_.add_child("ows:DCP",pt_child10_);
-      pt_child11_.add("ows:HTTP.ows:Get.<xmlattr>.xlink:href",http_cap1_);
-      pt_child11_.add("ows:HTTP.ows:Get.ows:Constraint.<xmlattr>.name","GetEncoding");
-      pt_child11_.add("ows:HTTP.ows:Get.ows:Constraint.ows:AllowedValues.ows:Value","KVP");
-      pt_child1_.add_child("ows:DCP",pt_child11_);
-      pt.add_child("ows:Operation",pt_child1_);    
+      pt_child1.add("<xmlattr>.name","GetTile");
+      boost::property_tree::ptree pt_child10,pt_child11;
+      pt_child10.add("ows:HTTP.ows:Get.<xmlattr>.xlink:href",http_cap2);
+      pt_child10.add("ows:HTTP.ows:Get.ows:Constraint.<xmlattr>.name","GetEncoding");
+      pt_child10.add("ows:HTTP.ows:Get.ows:Constraint.ows:AllowedValues.ows:Value","RESTful");
+      pt_child1.add_child("ows:DCP",pt_child10);
+      pt_child11.add("ows:HTTP.ows:Get.<xmlattr>.xlink:href",http_cap1);
+      pt_child11.add("ows:HTTP.ows:Get.ows:Constraint.<xmlattr>.name","GetEncoding");
+      pt_child11.add("ows:HTTP.ows:Get.ows:Constraint.ows:AllowedValues.ows:Value","KVP");
+      pt_child1.add_child("ows:DCP",pt_child11);
+      pt.add_child("ows:Operation",pt_child1);    
    }
    void GetServiceTileMatrixSetElement(const std::string& servicename,boost::property_tree::ptree& pt)
    {

@@ -29,22 +29,22 @@ namespace DmpWmts
     std::shared_ptr<DmpTileProvider> provider;
     try
     {
-      std::string tileVersion_= dmpTileLayer->getVector();
-      std::string tilePath_=dmpTileLayer->getDataSource();
+      std::string tileVersion= dmpTileLayer->getVector();
+      std::string tilePath=dmpTileLayer->getDataSource();
       //std::string tilePath_ = "/mnt/d/Code/tiles/gdmap/_alllayers";
       //std::string tileVersion_ = "ESRI_V1";
-      int iver_=StringToVector(tileVersion_);    
-      Vector version = (Vector)boost::lexical_cast<int>(iver_);
+      int iver=StringToVector(tileVersion);    
+      Vector version = (Vector)boost::lexical_cast<int>(iver);
       switch(version)
 		  {
 			  case Vector::ESRI_V0: 
-          provider = std::make_shared<DmpEsriTileProvider>(tilePath_);
+          provider = std::make_shared<DmpEsriTileProvider>(tilePath);
 				  break;
     	  case Vector::ESRI_V1:
-          provider = std::make_shared<DmpEsriBundleV1Provider>(tilePath_);
+          provider = std::make_shared<DmpEsriBundleV1Provider>(tilePath);
 				  break;
         case Vector::ESRI_V2: 
-          provider = std::make_shared<DmpEsriBundleV2Provider>(tilePath_);
+          provider = std::make_shared<DmpEsriBundleV2Provider>(tilePath);
 				  break;
 			  default:
           provider = nullptr;
@@ -60,24 +60,24 @@ namespace DmpWmts
   }
   int TileProviderFactory::StringToVector(std::string& strVector)
   {
-        int iVector_=-1;
+        int iVector=-1;
         if(std::strcmp(strVector.c_str(),"ESRI_V0")==0)
         {
-            iVector_=0;
+            iVector=0;
         }
         else if(std::strcmp(strVector.c_str(),"ESRI_V1")==0)
         {
-            iVector_=1;
+            iVector=1;
         }    
         else if(std::strcmp(strVector.c_str(),"ESRI_V2")==0)
         {
-            iVector_=2;
+            iVector=2;
         } 
         else
         {
-            iVector_=3;
+            iVector=3;
         }        
-        return iVector_;
+        return iVector;
   } 
   // CapabiliTileProviderFactory::CapabiliTileProviderFactory()
   // {

@@ -82,8 +82,8 @@ namespace DmpWmts
     }
     else if (boost::iequals(req, "GetCapabilities"))
     {
-      const std::string host_=context.request()->domain()+":"+context.request()->port();;
-      const std::string servicename_=context.request()->serviceName();
+      const std::string host=context.request()->domain()+":"+context.request()->port();;
+      const std::string servicename=context.request()->serviceName();
       
       boost::property_tree::ptree pt;
       pt.add("Layer.ows:Title",tileLayer->title());
@@ -100,18 +100,18 @@ namespace DmpWmts
       {
         pt.add("Layer.TileMatrixSetLink.TileMatrixSet",(*iter)->id());
         
-        boost::property_tree::ptree ptLevels_;
-        std::vector<TileLevel*> tileLevels_=(*iter)->tileLevels();
-        for(auto leviter=tileLevels_.cbegin();leviter!=tileLevels_.cend();leviter++)
+        boost::property_tree::ptree ptLevels;
+        std::vector<TileLevel*> tileLevels=(*iter)->tileLevels();
+        for(auto leviter=tileLevels.cbegin();leviter!=tileLevels.cend();leviter++)
         {
-          boost::property_tree::ptree pt_level_;
+          boost::property_tree::ptree pt_level;
         
-          pt_level_.add("level",(*leviter)->id);
-          pt_level_.add("scale",(*leviter)->scaleDenominator);
-          pt_level_.add("resolution",(*leviter)->resolution);
-          ptLevels_.add_child("TileMatrix",pt_level_);
+          pt_level.add("level",(*leviter)->id);
+          pt_level.add("scale",(*leviter)->scaleDenominator);
+          pt_level.add("resolution",(*leviter)->resolution);
+          ptLevels.add_child("TileMatrix",pt_level);
         }
-        pt.add_child("TileMatrixSet.Levels",ptLevels_); 
+        pt.add_child("TileMatrixSet.Levels",ptLevels); 
         pt.add("TileMatrixSet.ows:Identifier",(*iter)->id());
         pt.add("TileMatrixSet.ows:SupportedCRS",(*iter)->crs());
         pt.add("TileMatrixSet.TileWidth",(*iter)->tileCols());
@@ -122,7 +122,7 @@ namespace DmpWmts
       //boost::property_tree::write_json("/mnt/d/json.txt",pt);
 
       DmpCapabiliTilesOperation capOper;
-      capOper.WriteCapabilities(pt,host_,servicename_,*context.response());
+      capOper.WriteCapabilities(pt,host,servicename,*context.response());
 
     }
   }