Merge branch 'support-for-mysql-56-57-plus-boost-to-std'

vozbu · vozbu · commit 375b0c495dfc · 2016-05-30T14:07:11.000+03:00
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -14,7 +14,7 @@ ENDIF (CMAKE_COMPILER_IS_GNUCC)
 
 FIND_PACKAGE (Boost REQUIRED)
 INCLUDE_DIRECTORIES (${Boost_INCLUDE_DIRS})
-FIND_PACKAGE (Boost 1.41.0 COMPONENTS unit_test_framework thread system)
+FIND_PACKAGE (Boost 1.41.0 COMPONENTS unit_test_framework system)
 
 INCLUDE (FindPackageHandleStandardArgs)
 FIND_PATH (IMYSQL mysql/mysql.h)
diff --git a/DefaultExtState.h b/DefaultExtState.h
@@ -1,99 +1,99 @@
 #ifndef __SLAVE_DEFAULTEXTSTATE_H_
 #define __SLAVE_DEFAULTEXTSTATE_H_
 
-#include "SlaveStats.h"
+#include <mutex>
 
-#include <boost/thread/mutex.hpp>
+#include "SlaveStats.h"
 
 namespace slave
 {
 class DefaultExtState: public ExtStateIface, protected State {
-    boost::mutex m_mutex;
+    std::mutex m_mutex;
 
 public:
     virtual State getState()
     {
-        boost::mutex::scoped_lock lock(m_mutex);
+        std::lock_guard<std::mutex> lock(m_mutex);
         return *this;
     }
     virtual void setConnecting()
     {
-        boost::mutex::scoped_lock lock(m_mutex);
+        std::lock_guard<std::mutex> lock(m_mutex);
         connect_time = ::time(NULL);
         ++connect_count;
     }
     virtual time_t getConnectTime()
     {
-        boost::mutex::scoped_lock lock(m_mutex);
+        std::lock_guard<std::mutex> lock(m_mutex);
         return connect_time;
     }
     virtual void setLastFilteredUpdateTime()
     {
-        boost::mutex::scoped_lock lock(m_mutex);
+        std::lock_guard<std::mutex> lock(m_mutex);
         last_filtered_update = ::time(NULL);
     }
     virtual time_t getLastFilteredUpdateTime()
     {
-        boost::mutex::scoped_lock lock(m_mutex);
+        std::lock_guard<std::mutex> lock(m_mutex);
         return last_filtered_update;
     }
     virtual void setLastEventTimePos(time_t t, unsigned long pos)
     {
-        boost::mutex::scoped_lock lock(m_mutex);
+        std::lock_guard<std::mutex> lock(m_mutex);
         last_event_time = t; intransaction_pos = pos; last_update = ::time(NULL);
     }
     virtual time_t getLastUpdateTime()
     {
-        boost::mutex::scoped_lock lock(m_mutex);
+        std::lock_guard<std::mutex> lock(m_mutex);
         return last_update;
     }
     virtual time_t getLastEventTime()
     {
-        boost::mutex::scoped_lock lock(m_mutex);
+        std::lock_guard<std::mutex> lock(m_mutex);
         return last_event_time;
     }
     virtual unsigned long getIntransactionPos()
     {
-        boost::mutex::scoped_lock lock(m_mutex);
+        std::lock_guard<std::mutex> lock(m_mutex);
         return intransaction_pos;
     }
     virtual void setMasterLogNamePos(const std::string& log_name, unsigned long pos)
     {
-        boost::mutex::scoped_lock lock(m_mutex);
+        std::lock_guard<std::mutex> lock(m_mutex);
         master_log_name = log_name; master_log_pos = pos;
         intransaction_pos = pos;
     }
     virtual unsigned long getMasterLogPos()
     {
-        boost::mutex::scoped_lock lock(m_mutex);
+        std::lock_guard<std::mutex> lock(m_mutex);
         return master_log_pos;
     }
     virtual std::string getMasterLogName()
     {
-        boost::mutex::scoped_lock lock(m_mutex);
+        std::lock_guard<std::mutex> lock(m_mutex);
         return master_log_name;
     }
     virtual void saveMasterInfo() {}
     virtual bool loadMasterInfo(std::string& logname, unsigned long& pos)
     {
-        boost::mutex::scoped_lock lock(m_mutex);
+        std::lock_guard<std::mutex> lock(m_mutex);
         logname.clear();
         pos = 0;
         return false;
     }
     virtual unsigned int getConnectCount()
     {
-        boost::mutex::scoped_lock lock(m_mutex);
+        std::lock_guard<std::mutex> lock(m_mutex);
         return connect_count;
     }
     virtual void setStateProcessing(bool _state)
     {
-        boost::mutex::scoped_lock lock(m_mutex);
+        std::lock_guard<std::mutex> lock(m_mutex);
         state_processing = _state;
     }
     virtual bool getStateProcessing()
     {
-        boost::mutex::scoped_lock lock(m_mutex);
+        std::lock_guard<std::mutex> lock(m_mutex);
         return state_processing;
     }
     virtual void initTableCount(const std::string& t) {}
diff --git a/README.md b/README.md
@@ -36,9 +36,8 @@ For building the library, you will need:
      into your mysql include directory.
 
  * The headers of the boost libraries (http://www.boost.org).
-   At the minimum, you will need at least the shared_ptr.hpp, function.hpp,
-   any.hpp and bind.hpp. If boost_unit_test_framework and boost_thread is
-   found, tests will be built.
+   At the minimum, you will need at least the any.hpp.
+   If boost_unit_test_framework is found, tests will be built.
 
  * You (likely) will need to review and edit the contents of Logging.h
    and SlaveStats.h
diff --git a/Slave.cpp b/Slave.cpp
@@ -149,7 +149,7 @@ void Slave::createTable(RelayLogInfo& rli,
     conn.query("SHOW FULL COLUMNS FROM " + tbl_name + " IN " + db_name);
     conn.store(res);
 
-    boost::shared_ptr<Table> table(new Table(db_name, tbl_name));
+    std::shared_ptr<Table> table(new Table(db_name, tbl_name));
 
 
     LOG_DEBUG(log, "Created new Table object: database:" << db_name << " table: " << tbl_name );
@@ -392,7 +392,7 @@ struct raii_mysql_connector
 }// anonymous-namespace
 
 
-void Slave::get_remote_binlog( const boost::function< bool() >& _interruptFlag)
+void Slave::get_remote_binlog(const std::function<bool()>& _interruptFlag)
 {
     int count_packet = 0;
 
diff --git a/Slave.h b/Slave.h
@@ -22,6 +22,7 @@
 #define __SLAVE_SLAVE_H_
 
 
+#include <functional>
 #include <string>
 #include <vector>
 #include <map>
@@ -64,7 +65,7 @@ class Slave
     callbacks_t m_callbacks;
     filters_t m_filters;
 
-    typedef boost::function<void (unsigned int)> xid_callback_t;
+    typedef std::function<void (unsigned int)> xid_callback_t;
     xid_callback_t m_xid_callback;
 
     RelayLogInfo m_rli;
@@ -112,7 +113,7 @@ class Slave
         m_xid_callback = _callback;
     }
 
-    void get_remote_binlog( const boost::function< bool() >& _interruptFlag = &Slave::falseFunction );
+    void get_remote_binlog(const std::function<bool()>& _interruptFlag = &Slave::falseFunction);
 
     void createDatabaseStructure() {
 
diff --git a/SlaveStats.h b/SlaveStats.h
@@ -27,7 +27,7 @@
  */
 
 
-#include <boost/shared_ptr.hpp>
+#include <memory>
 #include <string>
 #include <sys/time.h>
 
@@ -179,7 +179,7 @@ struct EmptyExtState: public ExtStateIface {
 // Saves ExtStateIface or it's descendants.
 // Used in singleton.
 struct StateHolder {
-    typedef boost::shared_ptr<ExtStateIface> PExtState;
+    typedef std::shared_ptr<ExtStateIface> PExtState;
     PExtState ext_state;
     StateHolder() :
         ext_state(new EmptyExtState)
diff --git a/nanomysql.h b/nanomysql.h
@@ -15,7 +15,6 @@
 #ifndef __NANOMYSQL_H
 #define __NANOMYSQL_H
 
-#include <boost/bind.hpp>
 #include <mysql/mysql.h>
 #include "nanofield.h"
 #include <stdexcept>
@@ -155,12 +154,7 @@ class Connection {
     typedef std::vector<fields_t> result_t;
 
     void store(result_t& out) {
-#ifndef __GXX_EXPERIMENTAL_CXX0X__
-        use(boost::bind(&result_t::push_back, &out, _1));
-#else
         use( [&out] (const std::map<std::string,field>& f) { out.push_back(f); } );
-#endif
-
     }
 };
 
diff --git a/relayloginfo.h b/relayloginfo.h
@@ -17,17 +17,16 @@
 
 #include "table.h"
 
-#include <boost/shared_ptr.hpp>
-
 #include <map>
+#include <memory>
 #include <string>
 
 
 
 namespace slave {
 
 
-typedef boost::shared_ptr<Table> PtrTable;
+typedef std::shared_ptr<Table> PtrTable;
 
 class RelayLogInfo {
 
@@ -61,14 +60,14 @@ class RelayLogInfo {
         }
     }
 
-    boost::shared_ptr<Table> getTable(const std::pair<std::string, std::string>& key) {
+    std::shared_ptr<Table> getTable(const std::pair<std::string, std::string>& key) {
         name_to_table_t::iterator p = m_table_map.find(key);
 
         if (p != m_table_map.end()) {
             return p->second;
 
         } else {
-            return boost::shared_ptr<Table>();
+            return std::shared_ptr<Table>();
         }
     }
 
diff --git a/slave_log_event.cpp b/slave_log_event.cpp
@@ -373,7 +373,7 @@ size_t n_set_bits(const std::vector<unsigned char>& b, unsigned int count) {
 }
 
 
-unsigned char* unpack_row(boost::shared_ptr<slave::Table> table,
+unsigned char* unpack_row(std::shared_ptr<slave::Table> table,
                           slave::Row& _row,
                           unsigned int colcnt,
                           unsigned char* row,
@@ -442,7 +442,7 @@ unsigned char* unpack_row(boost::shared_ptr<slave::Table> table,
 }
 
 
-unsigned char* do_writedelete_row(boost::shared_ptr<slave::Table> table,
+unsigned char* do_writedelete_row(std::shared_ptr<slave::Table> table,
                                   const Basic_event_info& bei,
                                   const Row_event_info& roi, 
                                   unsigned char* row_start,
@@ -467,7 +467,7 @@ unsigned char* do_writedelete_row(boost::shared_ptr<slave::Table> table,
     return t;
 }
 
-unsigned char* do_update_row(boost::shared_ptr<slave::Table> table,
+unsigned char* do_update_row(std::shared_ptr<slave::Table> table,
                              const Basic_event_info& bei,
                              const Row_event_info& roi, 
                              unsigned char* row_start,
@@ -532,7 +532,7 @@ void apply_row_event(slave::RelayLogInfo& rli, const Basic_event_info& bei, cons
 
     LOG_DEBUG(log, "applyRowEvent(): " << roi.m_table_id << " " << key.first << "." << key.second);
 
-    boost::shared_ptr<slave::Table> table = rli.getTable(key);
+    std::shared_ptr<slave::Table> table = rli.getTable(key);
 
     if (table) {
 
diff --git a/table.h b/table.h
@@ -16,12 +16,11 @@
 #define __SLAVE_TABLE_H_
 
 
+#include <functional>
 #include <string>
 #include <vector>
 #include <map>
-
-#include <boost/shared_ptr.hpp>
-#include <boost/function.hpp>
+#include <memory>
 
 #include "field.h"
 #include "recordset.h"
@@ -31,8 +30,8 @@
 namespace slave
 {
 
-typedef boost::shared_ptr<Field> PtrField;
-typedef boost::function<void (RecordSet&)> callback;
+typedef std::shared_ptr<Field> PtrField;
+typedef std::function<void (RecordSet&)> callback;
 typedef EventKind filter;
 
 
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
@@ -8,6 +8,6 @@ TARGET_LINK_LIBRARIES (db_filler slave_a -lz -ldl -lpthread -lrt)
 
 IF (Boost_FOUND)
     ADD_EXECUTABLE (unit_test unit_test.cpp)
-    TARGET_LINK_LIBRARIES (unit_test slave_a ${Boost_UNIT_TEST_FRAMEWORK_LIBRARY} ${Boost_THREAD_LIBRARY} ${Boost_SYSTEM_LIBRARY} -lz -ldl -lpthread -lrt)
+    TARGET_LINK_LIBRARIES (unit_test slave_a ${Boost_UNIT_TEST_FRAMEWORK_LIBRARY} ${Boost_SYSTEM_LIBRARY} -lz -ldl -lpthread -lrt)
     ADD_TEST (NAME unit_test COMMAND unit_test WORKING_DIRECTORY ${CMAKE_SOURCE_DIR})
 ENDIF (Boost_FOUND)
diff --git a/test/unit_test.cpp b/test/unit_test.cpp

Original file line number	Diff line number	Diff line change
`@@ -1,99 +1,99 @@`
`1`	`1`	`#ifndef __SLAVE_DEFAULTEXTSTATE_H_`
`2`	`2`	`#define __SLAVE_DEFAULTEXTSTATE_H_`
`3`	`3`
`4`		`-#include "SlaveStats.h"`
	`4`	`+#include <mutex>`
`5`	`5`
`6`		`-#include <boost/thread/mutex.hpp>`
	`6`	`+#include "SlaveStats.h"`
`7`	`7`
`8`	`8`	`namespace slave`
`9`	`9`	`{`
`10`	`10`	`class DefaultExtState: public ExtStateIface, protected State {`
`11`		`- boost::mutex m_mutex;`
	`11`	`+ std::mutex m_mutex;`
`12`	`12`
`13`	`13`	`public:`
`14`	`14`	`virtual State getState()`
`15`	`15`	`{`
`16`		`- boost::mutex::scoped_lock lock(m_mutex);`
	`16`	`+ std::lock_guard<std::mutex> lock(m_mutex);`
`17`	`17`	`return *this;`
`18`	`18`	`}`
`19`	`19`	`virtual void setConnecting()`
`20`	`20`	`{`
`21`		`- boost::mutex::scoped_lock lock(m_mutex);`
	`21`	`+ std::lock_guard<std::mutex> lock(m_mutex);`
`22`	`22`	`connect_time = ::time(NULL);`
`23`	`23`	`++connect_count;`
`24`	`24`	`}`
`25`	`25`	`virtual time_t getConnectTime()`
`26`	`26`	`{`
`27`		`- boost::mutex::scoped_lock lock(m_mutex);`
	`27`	`+ std::lock_guard<std::mutex> lock(m_mutex);`
`28`	`28`	`return connect_time;`
`29`	`29`	`}`
`30`	`30`	`virtual void setLastFilteredUpdateTime()`
`31`	`31`	`{`
`32`		`- boost::mutex::scoped_lock lock(m_mutex);`
	`32`	`+ std::lock_guard<std::mutex> lock(m_mutex);`
`33`	`33`	`last_filtered_update = ::time(NULL);`
`34`	`34`	`}`
`35`	`35`	`virtual time_t getLastFilteredUpdateTime()`
`36`	`36`	`{`
`37`		`- boost::mutex::scoped_lock lock(m_mutex);`
	`37`	`+ std::lock_guard<std::mutex> lock(m_mutex);`
`38`	`38`	`return last_filtered_update;`
`39`	`39`	`}`
`40`	`40`	`virtual void setLastEventTimePos(time_t t, unsigned long pos)`
`41`	`41`	`{`
`42`		`- boost::mutex::scoped_lock lock(m_mutex);`
	`42`	`+ std::lock_guard<std::mutex> lock(m_mutex);`
`43`	`43`	`last_event_time = t; intransaction_pos = pos; last_update = ::time(NULL);`
`44`	`44`	`}`
`45`	`45`	`virtual time_t getLastUpdateTime()`
`46`	`46`	`{`
`47`		`- boost::mutex::scoped_lock lock(m_mutex);`
	`47`	`+ std::lock_guard<std::mutex> lock(m_mutex);`
`48`	`48`	`return last_update;`
`49`	`49`	`}`
`50`	`50`	`virtual time_t getLastEventTime()`
`51`	`51`	`{`
`52`		`- boost::mutex::scoped_lock lock(m_mutex);`
	`52`	`+ std::lock_guard<std::mutex> lock(m_mutex);`
`53`	`53`	`return last_event_time;`
`54`	`54`	`}`
`55`	`55`	`virtual unsigned long getIntransactionPos()`
`56`	`56`	`{`
`57`		`- boost::mutex::scoped_lock lock(m_mutex);`
	`57`	`+ std::lock_guard<std::mutex> lock(m_mutex);`
`58`	`58`	`return intransaction_pos;`
`59`	`59`	`}`
`60`	`60`	`virtual void setMasterLogNamePos(const std::string& log_name, unsigned long pos)`
`61`	`61`	`{`
`62`		`- boost::mutex::scoped_lock lock(m_mutex);`
	`62`	`+ std::lock_guard<std::mutex> lock(m_mutex);`
`63`	`63`	`master_log_name = log_name; master_log_pos = pos;`
`64`	`64`	`intransaction_pos = pos;`
`65`	`65`	`}`
`66`	`66`	`virtual unsigned long getMasterLogPos()`
`67`	`67`	`{`
`68`		`- boost::mutex::scoped_lock lock(m_mutex);`
	`68`	`+ std::lock_guard<std::mutex> lock(m_mutex);`
`69`	`69`	`return master_log_pos;`
`70`	`70`	`}`
`71`	`71`	`virtual std::string getMasterLogName()`
`72`	`72`	`{`
`73`		`- boost::mutex::scoped_lock lock(m_mutex);`
	`73`	`+ std::lock_guard<std::mutex> lock(m_mutex);`
`74`	`74`	`return master_log_name;`
`75`	`75`	`}`
`76`	`76`	`virtual void saveMasterInfo() {}`
`77`	`77`	`virtual bool loadMasterInfo(std::string& logname, unsigned long& pos)`
`78`	`78`	`{`
`79`		`- boost::mutex::scoped_lock lock(m_mutex);`
	`79`	`+ std::lock_guard<std::mutex> lock(m_mutex);`
`80`	`80`	`logname.clear();`
`81`	`81`	`pos = 0;`
`82`	`82`	`return false;`
`83`	`83`	`}`
`84`	`84`	`virtual unsigned int getConnectCount()`
`85`	`85`	`{`
`86`		`- boost::mutex::scoped_lock lock(m_mutex);`
	`86`	`+ std::lock_guard<std::mutex> lock(m_mutex);`
`87`	`87`	`return connect_count;`
`88`	`88`	`}`
`89`	`89`	`virtual void setStateProcessing(bool _state)`
`90`	`90`	`{`
`91`		`- boost::mutex::scoped_lock lock(m_mutex);`
	`91`	`+ std::lock_guard<std::mutex> lock(m_mutex);`
`92`	`92`	`state_processing = _state;`
`93`	`93`	`}`
`94`	`94`	`virtual bool getStateProcessing()`
`95`	`95`	`{`
`96`		`- boost::mutex::scoped_lock lock(m_mutex);`
	`96`	`+ std::lock_guard<std::mutex> lock(m_mutex);`
`97`	`97`	`return state_processing;`
`98`	`98`	`}`
`99`	`99`	`virtual void initTableCount(const std::string& t) {}`
Original file line number	Diff line number	Diff line change
`@@ -17,17 +17,16 @@`
`17`	`17`
`18`	`18`	`#include "table.h"`
`19`	`19`
`20`		`-#include <boost/shared_ptr.hpp>`
`21`		`-`
`22`	`20`	`#include <map>`
	`21`	`+#include <memory>`
`23`	`22`	`#include <string>`
`24`	`23`
`25`	`24`
`26`	`25`
`27`	`26`	`namespace slave {`
`28`	`27`
`29`	`28`
`30`		`-typedef boost::shared_ptr<Table> PtrTable;`
	`29`	`+typedef std::shared_ptr<Table> PtrTable;`
`31`	`30`
`32`	`31`	`class RelayLogInfo {`
`33`	`32`
`@@ -61,14 +60,14 @@ class RelayLogInfo {`
`61`	`60`	`}`
`62`	`61`	`}`
`63`	`62`
`64`		`- boost::shared_ptr<Table> getTable(const std::pair<std::string, std::string>& key) {`
	`63`	`+ std::shared_ptr<Table> getTable(const std::pair<std::string, std::string>& key) {`
`65`	`64`	`name_to_table_t::iterator p = m_table_map.find(key);`
`66`	`65`
`67`	`66`	`if (p != m_table_map.end()) {`
`68`	`67`	`return p->second;`
`69`	`68`
`70`	`69`	`} else {`
`71`		`- return boost::shared_ptr<Table>();`
	`70`	`+ return std::shared_ptr<Table>();`
`72`	`71`	`}`
`73`	`72`	`}`
`74`	`73`