Remove all boost:: namespace prefix for uint32_t, int32_t etc. (fixed-width types)

- Also removes all references to boost/cstdint.hpp and replaces it with
  stdint.h (The 'correct' replacement would be <cstdint>, but not all of our
  compilers support that).

7 files changed, 61 insertions, 61 deletions

diff --git a/host/lib/usrp_clock/multi_usrp_clock.cpp b/host/lib/usrp_clock/multi_usrp_clock.cpp
index 4d3e526d6..71521190e 100644
--- a/host/lib/usrp_clock/multi_usrp_clock.cpp
+++ b/host/lib/usrp_clock/multi_usrp_clock.cpp
@@ -61,10 +61,10 @@ public:
         return _tree->list("/mboards").size();
     }
 
-    boost::uint32_t get_time(size_t board){
+    uint32_t get_time(size_t board){
         std::string board_str = str(boost::format("/mboards/%d") % board);
 
-        return _tree->access<boost::uint32_t>(board_str / "time").get();
+        return _tree->access<uint32_t>(board_str / "time").get();
     }
 
     sensor_value_t get_sensor(const std::string &name, size_t board){
diff --git a/host/lib/usrp_clock/octoclock/octoclock_eeprom.cpp b/host/lib/usrp_clock/octoclock/octoclock_eeprom.cpp
index b39bc4b52..b0d24deec 100644
--- a/host/lib/usrp_clock/octoclock/octoclock_eeprom.cpp
+++ b/host/lib/usrp_clock/octoclock/octoclock_eeprom.cpp
@@ -41,13 +41,13 @@ using namespace uhd::transport;
  * Implementation
  **********************************************************************/
 void octoclock_eeprom_t::_load(){
-    boost::uint8_t octoclock_data[udp_simple::mtu];
+    uint8_t octoclock_data[udp_simple::mtu];
     const octoclock_packet_t *pkt_in = reinterpret_cast<const octoclock_packet_t*>(octoclock_data);
     const octoclock_fw_eeprom_t *eeprom_in = reinterpret_cast<const octoclock_fw_eeprom_t*>(pkt_in->data);
 
     octoclock_packet_t pkt_out;
     // To avoid replicating sequence numbers between sessions
-    pkt_out.sequence = boost::uint32_t(std::rand());
+    pkt_out.sequence = uint32_t(std::rand());
     size_t len = 0;
 
     UHD_OCTOCLOCK_SEND_AND_RECV(xport, _proto_ver, SEND_EEPROM_CMD, pkt_out, len, octoclock_data);
@@ -57,19 +57,19 @@ void octoclock_eeprom_t::_load(){
         (*this)["mac-addr"] = mac_addr_t::from_bytes(mac_bytes).to_string();
 
         //IP address
-        boost::uint32_t ip_addr = uhd::htonx<boost::uint32_t>(eeprom_in->ip_addr);
+        uint32_t ip_addr = uhd::htonx<uint32_t>(eeprom_in->ip_addr);
         ip_v4::bytes_type ip_addr_bytes;
         memcpy(&ip_addr_bytes, &ip_addr, 4);
         (*this)["ip-addr"] = ip_v4(ip_addr_bytes).to_string();
 
         //Default router
-        boost::uint32_t dr_addr = uhd::htonx<boost::uint32_t>(eeprom_in->dr_addr);
+        uint32_t dr_addr = uhd::htonx<uint32_t>(eeprom_in->dr_addr);
         ip_v4::bytes_type dr_addr_bytes;
         memcpy(&dr_addr_bytes, &dr_addr, 4);
         (*this)["gateway"] = ip_v4(dr_addr_bytes).to_string();
 
         //Netmask
-        boost::uint32_t netmask = uhd::htonx<boost::uint32_t>(eeprom_in->netmask);
+        uint32_t netmask = uhd::htonx<uint32_t>(eeprom_in->netmask);
         ip_v4::bytes_type netmask_bytes;
         memcpy(&netmask_bytes, &netmask, 4);
         (*this)["netmask"] = ip_v4(netmask_bytes).to_string();
@@ -91,12 +91,12 @@ void octoclock_eeprom_t::_load(){
 }
 
 void octoclock_eeprom_t::_store() const {
-    boost::uint8_t octoclock_data[udp_simple::mtu];
+    uint8_t octoclock_data[udp_simple::mtu];
     const octoclock_packet_t *pkt_in = reinterpret_cast<const octoclock_packet_t *>(octoclock_data);
 
     octoclock_packet_t pkt_out;
     // To avoid replicating sequence numbers between sessions
-    pkt_out.sequence = boost::uint32_t(std::rand());
+    pkt_out.sequence = uint32_t(std::rand());
     pkt_out.len = sizeof(octoclock_fw_eeprom_t);
     size_t len = 0;
 
@@ -112,21 +112,21 @@ void octoclock_eeprom_t::_store() const {
     if((*this).has_key("ip-addr")){
         ip_v4::bytes_type ip_addr_bytes = ip_v4::from_string((*this)["ip-addr"]).to_bytes();
         memcpy(&eeprom_out->ip_addr, &ip_addr_bytes, 4);
-        eeprom_out->ip_addr = uhd::htonx<boost::uint32_t>(eeprom_out->ip_addr);
+        eeprom_out->ip_addr = uhd::htonx<uint32_t>(eeprom_out->ip_addr);
     }
 
     //Default router
     if((*this).has_key("gateway")){
         ip_v4::bytes_type dr_addr_bytes = ip_v4::from_string((*this)["gateway"]).to_bytes();
         memcpy(&eeprom_out->dr_addr, &dr_addr_bytes, 4);
-        eeprom_out->dr_addr = uhd::htonx<boost::uint32_t>(eeprom_out->dr_addr);
+        eeprom_out->dr_addr = uhd::htonx<uint32_t>(eeprom_out->dr_addr);
     }
 
     //Netmask
     if((*this).has_key("netmask")){
         ip_v4::bytes_type netmask_bytes = ip_v4::from_string((*this)["netmask"]).to_bytes();
         memcpy(&eeprom_out->netmask, &netmask_bytes, 4);
-        eeprom_out->netmask = uhd::htonx<boost::uint32_t>(eeprom_out->netmask);
+        eeprom_out->netmask = uhd::htonx<uint32_t>(eeprom_out->netmask);
     }
 
     //Serial
diff --git a/host/lib/usrp_clock/octoclock/octoclock_image_loader.cpp b/host/lib/usrp_clock/octoclock/octoclock_image_loader.cpp
index 3f89a9263..d3502113e 100644
--- a/host/lib/usrp_clock/octoclock/octoclock_image_loader.cpp
+++ b/host/lib/usrp_clock/octoclock/octoclock_image_loader.cpp
@@ -28,7 +28,7 @@
 #include <uhd/utils/paths.hpp>
 #include <uhd/utils/static.hpp>
 
-#include <boost/cstdint.hpp>
+#include <stdint.h>
 #include <boost/filesystem.hpp>
 #include <boost/format.hpp>
 #include <boost/lexical_cast.hpp>
@@ -57,14 +57,14 @@ typedef struct {
     bool                        found;
     uhd::device_addr_t          dev_addr;
     std::string                 image_filepath;
-    boost::uint16_t             crc;
-    boost::uint16_t             num_blocks;
-    boost::uint32_t             sequence;
+    uint16_t             crc;
+    uint16_t             num_blocks;
+    uint32_t             sequence;
     udp_simple::sptr            ctrl_xport;
     udp_simple::sptr            fw_xport;
-    boost::uint8_t              data_in[udp_simple::mtu];
-    boost::uint32_t             starting_firmware_version;
-    std::vector<boost::uint8_t> image;
+    uint8_t              data_in[udp_simple::mtu];
+    uint32_t             starting_firmware_version;
+    std::vector<uint8_t> image;
 } octoclock_session_t;
 
 static void octoclock_calculate_crc(octoclock_session_t &session){
@@ -72,7 +72,7 @@ static void octoclock_calculate_crc(octoclock_session_t &session){
     for(size_t i = 0; i < session.image.size(); i++)
     {
         session.crc ^= session.image[i];
-        for(boost::uint8_t j = 0; j < 8; ++j){
+        for(uint8_t j = 0; j < 8; ++j){
             if(session.crc & 1) session.crc = (session.crc >> 1) ^ 0xA001;
             else session.crc = (session.crc >> 1);
         }
@@ -172,7 +172,7 @@ static void octoclock_setup_session(octoclock_session_t &session,
     session.fw_xport   = udp_simple::make_connected(session.dev_addr["addr"],
                                                     BOOST_STRINGIZE(OCTOCLOCK_UDP_FW_PORT));
     // To avoid replicating sequence numbers between sessions
-    session.sequence   = boost::uint32_t(std::rand());
+    session.sequence   = uint32_t(std::rand());
 
     // Query OctoClock again to get compat number
     octoclock_packet_t pkt_out;
@@ -180,7 +180,7 @@ static void octoclock_setup_session(octoclock_session_t &session,
     size_t len = 0;
     UHD_OCTOCLOCK_SEND_AND_RECV(session.ctrl_xport, OCTOCLOCK_FW_COMPAT_NUM, OCTOCLOCK_QUERY_CMD, pkt_out, len, session.data_in);
     if(UHD_OCTOCLOCK_PACKET_MATCHES(OCTOCLOCK_QUERY_ACK, pkt_out, pkt_in, len)){
-        session.starting_firmware_version = uhd::htonx<boost::uint32_t>(pkt_in->proto_ver);
+        session.starting_firmware_version = uhd::htonx<uint32_t>(pkt_in->proto_ver);
     } else {
         throw uhd::runtime_error("Failed to communicate with OctoClock.");
     }
@@ -194,8 +194,8 @@ static void octoclock_reset_into_bootloader(octoclock_session_t &session){
 
     // Force compat num to device's current, works around old firmware bug
     octoclock_packet_t pkt_out;
-    pkt_out.sequence = uhd::htonx<boost::uint32_t>(++session.sequence);
-    pkt_out.proto_ver = uhd::htonx<boost::uint32_t>(session.starting_firmware_version);
+    pkt_out.sequence = uhd::htonx<uint32_t>(++session.sequence);
+    pkt_out.proto_ver = uhd::htonx<uint32_t>(session.starting_firmware_version);
     pkt_out.code = RESET_CMD;
 
     std::cout << " -- Resetting into bootloader..." << std::flush;
@@ -235,11 +235,11 @@ static void octoclock_burn(octoclock_session_t &session){
     octoclock_reset_into_bootloader(session);
 
     octoclock_packet_t pkt_out;
-    pkt_out.sequence = uhd::htonx<boost::uint32_t>(++session.sequence);
+    pkt_out.sequence = uhd::htonx<uint32_t>(++session.sequence);
     const octoclock_packet_t* pkt_in = reinterpret_cast<const octoclock_packet_t*>(session.data_in);
 
     // Tell OctoClock to prepare for burn
-    pkt_out.len = htonx<boost::uint16_t>(session.image.size());
+    pkt_out.len = htonx<uint16_t>(session.image.size());
     size_t len = 0;
     std::cout << " -- Preparing OctoClock for firmware load..." << std::flush;
     pkt_out.len = session.image.size();
@@ -255,7 +255,7 @@ static void octoclock_burn(octoclock_session_t &session){
 
     // Start burning
     for(size_t i = 0; i < session.num_blocks; i++){
-        pkt_out.sequence = uhd::htonx<boost::uint32_t>(++session.sequence);
+        pkt_out.sequence = uhd::htonx<uint32_t>(++session.sequence);
         pkt_out.addr = i * OCTOCLOCK_BLOCK_SIZE;
 
         std::cout << str(boost::format("\r -- Loading firmware: %d%% (%d/%d blocks)")
@@ -280,14 +280,14 @@ static void octoclock_burn(octoclock_session_t &session){
 static void octoclock_verify(octoclock_session_t &session){
 
     octoclock_packet_t pkt_out;
-    pkt_out.sequence = uhd::htonx<boost::uint32_t>(++session.sequence);
+    pkt_out.sequence = uhd::htonx<uint32_t>(++session.sequence);
     const octoclock_packet_t* pkt_in = reinterpret_cast<const octoclock_packet_t*>(session.data_in);
     size_t len = 0;
 
-    boost::uint8_t image_part[OCTOCLOCK_BLOCK_SIZE];
-    boost::uint16_t cmp_len = 0;
+    uint8_t image_part[OCTOCLOCK_BLOCK_SIZE];
+    uint16_t cmp_len = 0;
     for(size_t i = 0; i < session.num_blocks; i++){
-        pkt_out.sequence = uhd::htonx<boost::uint32_t>(++session.sequence);
+        pkt_out.sequence = uhd::htonx<uint32_t>(++session.sequence);
         pkt_out.addr = i * OCTOCLOCK_BLOCK_SIZE;
 
         std::cout << str(boost::format("\r -- Verifying firmware load: %d%% (%d/%d blocks)")
@@ -320,7 +320,7 @@ static void octoclock_verify(octoclock_session_t &session){
 static void octoclock_finalize(octoclock_session_t &session){
 
     octoclock_packet_t pkt_out;
-    pkt_out.sequence = uhd::htonx<boost::uint32_t>(++session.sequence);
+    pkt_out.sequence = uhd::htonx<uint32_t>(++session.sequence);
     const octoclock_packet_t* pkt_in = reinterpret_cast<const octoclock_packet_t*>(session.data_in);
     size_t len = 0;
 
diff --git a/host/lib/usrp_clock/octoclock/octoclock_impl.cpp b/host/lib/usrp_clock/octoclock/octoclock_impl.cpp
index 297983c15..4da9db19f 100644
--- a/host/lib/usrp_clock/octoclock/octoclock_impl.cpp
+++ b/host/lib/usrp_clock/octoclock/octoclock_impl.cpp
@@ -19,7 +19,7 @@
 
 #include <boost/asio.hpp>
 #include <boost/assign.hpp>
-#include <boost/cstdint.hpp>
+#include <stdint.h>
 #include <boost/filesystem.hpp>
 #include <boost/foreach.hpp>
 #include <boost/format.hpp>
@@ -111,7 +111,7 @@ device_addrs_t octoclock_find(const device_addr_t &hint){
     octoclock_packet_t pkt_out;
     pkt_out.proto_ver = OCTOCLOCK_FW_COMPAT_NUM;
     // To avoid replicating sequence numbers between sessions
-    pkt_out.sequence = boost::uint32_t(std::rand());
+    pkt_out.sequence = uint32_t(std::rand());
     pkt_out.len = 0;
     pkt_out.code = OCTOCLOCK_QUERY_CMD;
     try{
@@ -124,7 +124,7 @@ device_addrs_t octoclock_find(const device_addr_t &hint){
         UHD_MSG(error) << "OctoClock network discovery unknown error" << std::endl;
     }
 
-    boost::uint8_t octoclock_data[udp_simple::mtu];
+    uint8_t octoclock_data[udp_simple::mtu];
     const octoclock_packet_t *pkt_in = reinterpret_cast<octoclock_packet_t*>(octoclock_data);
 
     while(true){
@@ -191,7 +191,7 @@ octoclock_impl::octoclock_impl(const device_addr_t &_device_addr){
     _type = device::CLOCK;
     device_addrs_t device_args = separate_device_addr(_device_addr);
     // To avoid replicating sequence numbers between sessions
-    _sequence = boost::uint32_t(std::rand());
+    _sequence = uint32_t(std::rand());
 
     ////////////////////////////////////////////////////////////////////
     // Initialize the property tree
@@ -248,7 +248,7 @@ octoclock_impl::octoclock_impl(const device_addr_t &_device_addr){
         ////////////////////////////////////////////////////////////////////
         // Initialize non-GPSDO sensors
         ////////////////////////////////////////////////////////////////////
-        _tree->create<boost::uint32_t>(oc_path / "time")
+        _tree->create<uint32_t>(oc_path / "time")
             .set_publisher(boost::bind(&octoclock_impl::_get_time, this, oc));
         _tree->create<sensor_value_t>(oc_path / "sensors/ext_ref_detected")
             .set_publisher(boost::bind(&octoclock_impl::_ext_ref_detected, this, oc));
@@ -330,13 +330,13 @@ void octoclock_impl::_set_eeprom(const std::string &oc, const octoclock_eeprom_t
     _oc_dict[oc].eeprom.commit();
 }
 
-boost::uint32_t octoclock_impl::_get_fw_version(const std::string &oc){
+uint32_t octoclock_impl::_get_fw_version(const std::string &oc){
     octoclock_packet_t pkt_out;
-    pkt_out.sequence = uhd::htonx<boost::uint32_t>(++_sequence);
+    pkt_out.sequence = uhd::htonx<uint32_t>(++_sequence);
     pkt_out.len = 0;
     size_t len;
 
-    boost::uint8_t octoclock_data[udp_simple::mtu];
+    uint8_t octoclock_data[udp_simple::mtu];
     const octoclock_packet_t *pkt_in = reinterpret_cast<octoclock_packet_t*>(octoclock_data);
 
     UHD_OCTOCLOCK_SEND_AND_RECV(_oc_dict[oc].ctrl_xport, OCTOCLOCK_FW_COMPAT_NUM, OCTOCLOCK_QUERY_CMD, pkt_out, len, octoclock_data);
@@ -348,11 +348,11 @@ boost::uint32_t octoclock_impl::_get_fw_version(const std::string &oc){
 
 void octoclock_impl::_get_state(const std::string &oc){
     octoclock_packet_t pkt_out;
-    pkt_out.sequence = uhd::htonx<boost::uint32_t>(++_sequence);
+    pkt_out.sequence = uhd::htonx<uint32_t>(++_sequence);
     pkt_out.len = 0;
     size_t len = 0;
 
-    boost::uint8_t octoclock_data[udp_simple::mtu];
+    uint8_t octoclock_data[udp_simple::mtu];
     const octoclock_packet_t *pkt_in = reinterpret_cast<octoclock_packet_t*>(octoclock_data);
 
     UHD_OCTOCLOCK_SEND_AND_RECV(_oc_dict[oc].ctrl_xport, _proto_ver, SEND_STATE_CMD, pkt_out, len, octoclock_data);
@@ -408,10 +408,10 @@ sensor_value_t octoclock_impl::_switch_pos(const std::string &oc){
     return sensor_value_t("Switch position", _switch_pos_strings[switch_pos_t(_oc_dict[oc].state.switch_pos)], "");
 }
 
-boost::uint32_t octoclock_impl::_get_time(const std::string &oc){
+uint32_t octoclock_impl::_get_time(const std::string &oc){
     if(_oc_dict[oc].state.gps_detected){
         std::string time_str = _oc_dict[oc].gps->get_sensor("gps_time").value;
-        return boost::lexical_cast<boost::uint32_t>(time_str);
+        return boost::lexical_cast<uint32_t>(time_str);
     }
     else throw uhd::runtime_error("This device cannot return a time.");
 }
diff --git a/host/lib/usrp_clock/octoclock/octoclock_impl.hpp b/host/lib/usrp_clock/octoclock/octoclock_impl.hpp
index 2c74b9b03..1cb3b60e1 100644
--- a/host/lib/usrp_clock/octoclock/octoclock_impl.hpp
+++ b/host/lib/usrp_clock/octoclock/octoclock_impl.hpp
@@ -56,12 +56,12 @@ private:
         uhd::gps_ctrl::sptr gps;
     };
     uhd::dict<std::string, oc_container_type> _oc_dict;
-    boost::uint32_t _sequence;
-	boost::uint32_t _proto_ver;
+    uint32_t _sequence;
+	uint32_t _proto_ver;
 
     void _set_eeprom(const std::string &oc, const uhd::usrp_clock::octoclock_eeprom_t &oc_eeprom);
 
-    boost::uint32_t _get_fw_version(const std::string &oc);
+    uint32_t _get_fw_version(const std::string &oc);
 
     void _get_state(const std::string &oc);
 
@@ -73,7 +73,7 @@ private:
 
     uhd::sensor_value_t _switch_pos(const std::string &oc);
 
-    boost::uint32_t _get_time(const std::string &oc);
+    uint32_t _get_time(const std::string &oc);
 
     std::string _get_images_help_message(const std::string &addr);
 
diff --git a/host/lib/usrp_clock/octoclock/octoclock_uart.cpp b/host/lib/usrp_clock/octoclock/octoclock_uart.cpp
index 0b5b840d3..0def2fdba 100644
--- a/host/lib/usrp_clock/octoclock/octoclock_uart.cpp
+++ b/host/lib/usrp_clock/octoclock/octoclock_uart.cpp
@@ -21,7 +21,7 @@
 
 #include <boost/algorithm/string.hpp>
 #include <boost/asio.hpp>
-#include <boost/cstdint.hpp>
+#include <stdint.h>
 #include <boost/format.hpp>
 #include <boost/thread/thread.hpp>
 
@@ -48,15 +48,15 @@ namespace uhd{
         _device_state.pos = 0;
         _proto_ver = proto_ver;
         // To avoid replicating sequence numbers between sessions
-        _sequence = boost::uint32_t(std::rand());
+        _sequence = uint32_t(std::rand());
         size_t len = 0;
 
         //Get pool size from device
         octoclock_packet_t pkt_out;
-        pkt_out.sequence = uhd::htonx<boost::uint32_t>(_sequence);
+        pkt_out.sequence = uhd::htonx<uint32_t>(_sequence);
         pkt_out.len = 0;
 
-        boost::uint8_t octoclock_data[udp_simple::mtu];
+        uint8_t octoclock_data[udp_simple::mtu];
         const octoclock_packet_t *pkt_in = reinterpret_cast<octoclock_packet_t*>(octoclock_data);
 
         UHD_OCTOCLOCK_SEND_AND_RECV(_udp, _proto_ver, SEND_POOLSIZE_CMD, pkt_out, len, octoclock_data);
@@ -71,11 +71,11 @@ namespace uhd{
         size_t len = 0;
 
         octoclock_packet_t pkt_out;
-        pkt_out.sequence = uhd::htonx<boost::uint32_t>(++_sequence);
+        pkt_out.sequence = uhd::htonx<uint32_t>(++_sequence);
         pkt_out.len = buf.size();
         memcpy(pkt_out.data, buf.c_str(), buf.size());
 
-        boost::uint8_t octoclock_data[udp_simple::mtu];
+        uint8_t octoclock_data[udp_simple::mtu];
         const octoclock_packet_t *pkt_in = reinterpret_cast<octoclock_packet_t*>(octoclock_data);
 
         UHD_OCTOCLOCK_SEND_AND_RECV(_udp, _proto_ver, HOST_SEND_TO_GPSDO_CMD, pkt_out, len, octoclock_data);
@@ -116,7 +116,7 @@ namespace uhd{
         pkt_out.len = 0;
         size_t len = 0;
 
-        boost::uint8_t octoclock_data[udp_simple::mtu];
+        uint8_t octoclock_data[udp_simple::mtu];
         const octoclock_packet_t *pkt_in = reinterpret_cast<octoclock_packet_t*>(octoclock_data);
 
         if(STATES_EQUAL){
@@ -124,7 +124,7 @@ namespace uhd{
             boost::posix_time::time_duration age = time - _last_cache_update;
             bool cache_expired = (age > boost::posix_time::seconds(MAX_CACHE_AGE));
 
-            pkt_out.sequence = uhd::htonx<boost::uint32_t>(++_sequence);
+            pkt_out.sequence = uhd::htonx<uint32_t>(++_sequence);
             UHD_OCTOCLOCK_SEND_AND_RECV(_udp, _proto_ver, SEND_GPSDO_CACHE_CMD, pkt_out, len, octoclock_data);
             if(UHD_OCTOCLOCK_PACKET_MATCHES(SEND_GPSDO_CACHE_ACK, pkt_out, pkt_in, len)){
                 memcpy(&_cache[0], pkt_in->data, _poolsize);
@@ -132,7 +132,7 @@ namespace uhd{
                 _last_cache_update = time;
             }
 
-            boost::uint8_t delta_wraps = (_device_state.num_wraps - _state.num_wraps);
+            uint8_t delta_wraps = (_device_state.num_wraps - _state.num_wraps);
             if(cache_expired or delta_wraps > 1 or
                ((delta_wraps == 1) and (_device_state.pos > _state.pos))){
 
diff --git a/host/lib/usrp_clock/octoclock/octoclock_uart.hpp b/host/lib/usrp_clock/octoclock/octoclock_uart.hpp
index d3a9738c4..390c202fe 100644
--- a/host/lib/usrp_clock/octoclock/octoclock_uart.hpp
+++ b/host/lib/usrp_clock/octoclock/octoclock_uart.hpp
@@ -40,13 +40,13 @@ public:
 private:
     uhd::transport::udp_simple::sptr _udp;
 
-    boost::uint16_t _poolsize;
+    uint16_t _poolsize;
     gpsdo_cache_state_t _state;
     gpsdo_cache_state_t _device_state;
-    std::vector<boost::uint8_t> _cache;
+    std::vector<uint8_t> _cache;
     std::string _rxbuff;
-    boost::uint32_t _sequence;
-	boost::uint32_t _proto_ver;
+    uint32_t _sequence;
+	uint32_t _proto_ver;
     boost::system_time _last_cache_update;
 
     void _update_cache();