1:remove http_server

2:add threading_pool
3:optimize code

Author: invxp

brink.vcxproj

@@ -11,7 +11,6 @@
     </ProjectConfiguration>
   </ItemGroup>
   <ItemGroup>
-    <ClCompile Include="tcp\http\http_server.cpp" />
     <ClCompile Include="tcp\protobuf\include\pbuf.cc" />
     <ClCompile Include="tcp\protobuf\protobuf_server.cpp" />
     <ClCompile Include="tcp\tcp_socket.cpp" />
@@ -26,7 +25,6 @@
     <ClInclude Include="include\pool\pool.hpp" />
     <ClInclude Include="include\brink_handler.h" />
     <ClInclude Include="include\pool\thread.hpp" />
-    <ClInclude Include="tcp\http\http_server.h" />
     <ClInclude Include="tcp\protobuf\include\pbuf.h" />
     <ClInclude Include="tcp\protobuf\protobuf_server.h" />
     <ClInclude Include="tcp\tcp_socket.h" />
@@ -94,11 +92,11 @@
       <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
       <AdditionalIncludeDirectories>.\include;.\3rd\protobuf-2.6.0\include</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <DebugInformationFormat>None</DebugInformationFormat>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
       <AdditionalOptions>-D_WIN32_WINNT=0x0501 %(AdditionalOptions)</AdditionalOptions>
     </ClCompile>
     <Link>
-      <GenerateDebugInformation>false</GenerateDebugInformation>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
       <EnableCOMDATFolding>true</EnableCOMDATFolding>
       <OptimizeReferences>true</OptimizeReferences>
       <AdditionalLibraryDirectories>.\3rd\protobuf-2.6.0\vsprojects\Release;</AdditionalLibraryDirectories>

brink.vcxproj.filters

@@ -14,9 +14,6 @@
     <ClCompile Include="tcp\protobuf\include\pbuf.cc">
       <Filter>tcp\protobuf_server\include</Filter>
     </ClCompile>
-    <ClCompile Include="tcp\http\http_server.cpp">
-      <Filter>tcp\http_server</Filter>
-    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <Filter Include="include">
@@ -31,15 +28,9 @@
     <Filter Include="tcp\protobuf_server">
       <UniqueIdentifier>{1192bbfd-4bf3-41ed-af22-e17b73978737}</UniqueIdentifier>
     </Filter>
-    <Filter Include="tcp\http_server">
-      <UniqueIdentifier>{235f06e1-9cba-4d67-b034-e5785efa9902}</UniqueIdentifier>
-    </Filter>
     <Filter Include="tcp\protobuf_server\include">
       <UniqueIdentifier>{e794f17b-e8d2-4864-8f2d-b87cd4800a81}</UniqueIdentifier>
     </Filter>
-    <Filter Include="tcp\http_server\include">
-      <UniqueIdentifier>{23150904-5b35-402c-ac59-bda06dae60b8}</UniqueIdentifier>
-    </Filter>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="include\brink_defines.h">
@@ -63,9 +54,6 @@
     <ClInclude Include="tcp\protobuf\include\pbuf.h">
       <Filter>tcp\protobuf_server\include</Filter>
     </ClInclude>
-    <ClInclude Include="tcp\http\http_server.h">
-      <Filter>tcp\http_server</Filter>
-    </ClInclude>
     <ClInclude Include="include\brink_param.h">
       <Filter>include</Filter>
     </ClInclude>

include/brink_utils.h

@@ -94,7 +94,7 @@ namespace BrinK
             if (file_size == std::string::npos)
                 return false;
 
-            std::unique_ptr <char[]> read_buf = std::make_unique < char[] >(file_size + sizeof(char));
+            std::unique_ptr < char[] > read_buf = std::make_unique < char[] >(file_size + sizeof(char));
 
             ifs.seekg(0);
 

include/pool/pool.hpp

@@ -38,6 +38,7 @@ namespace BrinK
                 busy_list_.clear();
                 free_list_.clear();
             }
+
         public:
             void get(const std::function < void(const T& t) >& op = [](const T&){})
             {
@@ -47,8 +48,9 @@ namespace BrinK
                     op(*busy_list_.emplace(new_()).first);
                 else
                 {
-                    op(*busy_list_.emplace(*free_list_.begin()).first);
+                    auto p = busy_list_.emplace(*std::move(free_list_.begin()));
                     free_list_.erase(free_list_.begin());
+                    op(*p.first);
                 }
             }
 
@@ -57,53 +59,21 @@ namespace BrinK
                 std::lock_guard < std::mutex > lock(mutex_);
 
                 auto it = busy_list_.find(t);
-                if (it != busy_list_.end())
-                {
-                    free_list_.emplace(t);
-                    busy_list_.erase(it);
-                    op(t);
-                }
-            }
-
-        public:
-            size_t busy_size()
-            {
-                std::lock_guard < std::mutex > lock(mutex_);
-
-                return busy_list_.size();
-            }
-
-            size_t free_size()
-            {
-                std::lock_guard < std::mutex > lock(mutex_);
+                if (it == busy_list_.end())
+                    return;
 
-                return free_list_.size();
+                free_list_.emplace(t);
+                busy_list_.erase(it);
+                op(t);
             }
 
-        public:
             void each(const std::function < void(const T& t) >& op = [](const T&){})
             {
                 std::lock_guard < std::mutex > lock(mutex_);
 
                 std::for_each(busy_list_.begin(), busy_list_.end(), [&op](const T& t){ op(t); });
             }
 
-            void each_free(const std::function < void(const T& t) >& op = [](const T&){})
-            {
-                std::lock_guard < std::mutex > lock(mutex_);
-
-                std::for_each(free_list_.begin(), free_list_.end(), [&op](const T& t){ op(t); });
-            }
-
-            void clear(const std::function < void(const T& t) >& op = [](const T&){})
-            {
-                std::lock_guard < std::mutex > lock(mutex_);
-
-                std::for_each(busy_list_.begin(), busy_list_.end(), [&op](const T& t){ op(t); });
-                std::copy(busy_list_.begin(), busy_list_.end(), std::back_inserter(free_list_));
-                busy_list_.clear();
-            }
-
         private:
             std::mutex                                  mutex_;
             std::set< T >                               busy_list_;

include/pool/thread.hpp

@@ -56,14 +56,14 @@ namespace BrinK
                 return wait_(wait_one_mutex_, wait_one_condition_);
             }
 
-            bool start(const unsigned int& pool_size = std::thread::hardware_concurrency())
+            bool start(const unsigned int& thread_count = std::thread::hardware_concurrency())
             {
                 std::lock_guard < std::mutex > lock(mutex_);
 
                 if (started_)
                     return false;
 
-                create_threads_(pool_size);
+                create_threads_(thread_count);
 
                 started_ = true;
 
@@ -73,14 +73,17 @@ namespace BrinK
             bool stop()
             {
                 std::lock_guard < std::mutex > lock(mutex_);
-                std::unique_lock < std::mutex > lock_task(tasks_mutex_);
 
-                if (!started_)
-                    return false;
+                {
+                    std::unique_lock < std::mutex > lock_task(tasks_mutex_);
 
-                stop_ = true;
+                    if (!started_)
+                        return false;
+
+                    stop_ = true;
 
-                awake_condition(lock_task, tasks_condition_);
+                    awake_condition(lock_task, tasks_condition_);
+                }
 
                 remove_threads_();