Maid 843 integration with crux

include/maidsafe/routing/source_address.h

@@ -86,6 +86,23 @@ inline bool operator>=(const SourceAddress& lhs, const SourceAddress& rhs) {
   return !operator<(lhs, rhs);
 }
 
+inline std::ostream& operator<<(std::ostream& os, const SourceAddress& addr) {
+  os << "(SourceAddress node:" << reinterpret_cast<const Address&>(addr.node_address) << ", ";
+  if (addr.group_address) {
+    os << "group:" << reinterpret_cast<const Address&>(*addr.group_address);
+  }
+  else {
+    os << "group:none";
+  }
+  if (addr.reply_to_address) {
+    os << ", reply_to:" << reinterpret_cast<const Address&>(*addr.reply_to_address);
+  }
+  else {
+    os << ", reply_to:none";
+  }
+  return os << ")";
+}
+
 }  // namespace routing
 
 }  // namespace maidsafe

include/maidsafe/routing/types.h

@@ -48,7 +48,7 @@ namespace routing {
 static const size_t GroupSize = 23;
 static const size_t QuorumSize = 19;
 
-enum class FromType : int32_t {
+enum class FromType : std::int32_t {
   client_manager,
   nae_manager,
   node_manager,
@@ -58,7 +58,7 @@ enum class FromType : int32_t {
   node
 };
 
-enum class Authority : int32_t {
+enum class Authority : std::int32_t {
   client_manager,
   nae_manager,
   node_manager,
@@ -68,7 +68,7 @@ enum class Authority : int32_t {
 };
 
 using Address = Identity;
-using MessageId = uint32_t;
+using MessageId = std::uint32_t;
 using Destination = TaggedValue<Address, struct DestinationTag>;
 using ReplyToAddress = TaggedValue<Address, struct ReplytoTag>;
 using DestinationAddress = std::pair<Destination, boost::optional<ReplyToAddress>>;
@@ -89,15 +89,23 @@ using HandleGetReturn =
                     maidsafe_error>;
 using HandlePutPostReturn = boost::expected<std::vector<DestinationAddress>, maidsafe_error>;
 using HandlePostReturn =
-    boost::expected<std::pair<std::vector<DestinationAddress>, std::vector<byte>>,
-                    maidsafe_error>;
+    boost::expected<std::pair<std::vector<DestinationAddress>, std::vector<byte>>, maidsafe_error>;
 
 using Endpoint = asio::ip::udp::endpoint;
-using Port = uint16_t;
+using Port = std::uint16_t;
 using SerialisedMessage = std::vector<byte>;
 using CloseGroupDifference = std::pair<std::vector<Address>, std::vector<Address>>;
 using PublicKeyId = std::pair<Address, asymm::PublicKey>;
 
+template <typename CompletionToken, typename... Args>
+using AsyncResultHandler = typename asio::handler_type<typename std::decay<CompletionToken>::type,
+                                                       void(asio::error_code, Args...)>::type;
+
+template <typename CompletionToken, typename... Args>
+using AsyncResultReturn =
+    typename asio::async_result<AsyncResultHandler<CompletionToken, Args...>>::type;
+
+// FIXME: All the below handlers and results can be implemented using the above two.
 template <typename CompletionToken>
 using BootstrapHandlerHandler =
     typename asio::handler_type<CompletionToken, void(asio::error_code, Contact)>::type;

src/maidsafe/routing/apply_tuple.h

@@ -0,0 +1,59 @@
+/*  Copyright 2015 MaidSafe.net limited
+
+    This MaidSafe Software is licensed to you under (1) the MaidSafe.net Commercial License,
+    version 1.0 or later, or (2) The General Public License (GPL), version 3, depending on which
+    licence you accepted on initial access to the Software (the "Licences").
+
+    By contributing code to the MaidSafe Software, or to this project generally, you agree to be
+    bound by the terms of the MaidSafe Contributor Agreement, version 1.0, found in the root
+    directory of this project at LICENSE, COPYING and CONTRIBUTOR respectively and also
+    available at: http://www.maidsafe.net/licenses
+
+    Unless required by applicable law or agreed to in writing, the MaidSafe Software distributed
+    under the GPL Licence is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS
+    OF ANY KIND, either express or implied.
+
+    See the Licences for the specific language governing permissions and limitations relating to
+    use of the MaidSafe Software.                                                                 */
+
+#ifndef MAIDSAFE_ROUTING_APPLY_TUPLE_H_
+#define MAIDSAFE_ROUTING_APPLY_TUPLE_H_
+
+#include <tuple>
+
+namespace maidsafe {
+
+namespace routing {
+
+namespace helper {
+
+template <int... Is>
+struct Index {};
+
+template <int N, int... Is>
+struct GeneratedSequence : GeneratedSequence<N - 1, N - 1, Is...> {};
+
+template <int... Is>
+struct GeneratedSequence<0, Is...> : Index<Is...> {};
+
+template <class F, typename... Args, int... Is>
+inline MAIDSAFE_CONSTEXPR auto ApplyTuple(F&& f, const std::tuple<Args...>& tup,
+                                          helper::Index<Is...>)
+    -> decltype(f(std::get<Is>(tup)...)) {
+  return f(std::get<Is>(tup)...);
+}
+
+}  // namespace helper
+
+template <class F, typename... Args>
+inline MAIDSAFE_CONSTEXPR auto ApplyTuple(F&& f, const std::tuple<Args...>& tup)
+    -> decltype(helper::ApplyTuple(std::forward<F>(f), tup,
+                                   helper::GeneratedSequence<sizeof...(Args)>{})) {
+  return helper::ApplyTuple(std::forward<F>(f), tup, helper::GeneratedSequence<sizeof...(Args)>{});
+}
+
+}  // namespace routing
+
+}  // namespace maidsafe
+
+#endif  // MAIDSAFE_ROUTING_APPLY_TUPLE_H_

src/maidsafe/routing/async_exchange.h

@@ -46,7 +46,7 @@ void AsyncExchange(crux::socket& socket, SerialisedMessage our_data, Handler han
   state->tx_buffer = std::move(our_data);
 
   socket.async_send(boost::asio::buffer(state->tx_buffer),
-                    [state, handler](boost::system::error_code error, std::size_t) {
+                    [state, handler](boost::system::error_code error, std::size_t) mutable {
     if (state->first_error) {
       if (*state->first_error) {
         return handler(*state->first_error, SerialisedMessage());
@@ -61,7 +61,7 @@ void AsyncExchange(crux::socket& socket, SerialisedMessage our_data, Handler han
   });
 
   socket.async_receive(boost::asio::buffer(state->rx_buffer),
-                       [state, handler](boost::system::error_code error, std::size_t size) {
+                       [state, handler](boost::system::error_code error, std::size_t size) mutable {
     if (state->first_error) {
       if (*state->first_error) {
         return handler(*state->first_error, SerialisedMessage());

src/maidsafe/routing/async_queue.h

@@ -26,41 +26,12 @@
 #include "asio/async_result.hpp"
 
 #include "maidsafe/common/config.h"
+#include "maidsafe/routing/apply_tuple.h"
 
 namespace maidsafe {
 
 namespace routing {
 
-namespace detail {
-
-namespace helper {
-
-template <int... Is>
-struct Index {};
-
-template <int N, int... Is>
-struct GeneratedSequence : GeneratedSequence<N - 1, N - 1, Is...> {};
-
-template <int... Is>
-struct GeneratedSequence<0, Is...> : Index<Is...> {};
-
-}  // namespace helper
-
-template <class F, typename... Args, int... Is>
-inline MAIDSAFE_CONSTEXPR auto ApplyTuple(F&& f, const std::tuple<Args...>& tup,
-                                          helper::Index<Is...>)
-    -> decltype(f(std::get<Is>(tup)...)) {
-  return f(std::get<Is>(tup)...);
-}
-
-template <class F, typename... Args>
-inline MAIDSAFE_CONSTEXPR auto ApplyTuple(F&& f, const std::tuple<Args...>& tup)
-    -> decltype(ApplyTuple(f, tup, helper::GeneratedSequence<sizeof...(Args)>{})) {
-  return ApplyTuple(std::forward<F>(f), tup, helper::GeneratedSequence<sizeof...(Args)>{});
-}
-
-}  // namespace detail
-
 template <class... Args>
 class AsyncQueue {
  private:
@@ -111,7 +82,7 @@ class AsyncQueue {
       values.pop();
     }
 
-    detail::ApplyTuple(std::move(handler), tuple);
+    detail::ApplyTuple(handler, std::move(tuple));
 
     return result.get();
   }