Merge pull request #56 from LarsGullik/master

Use 'using' (and 'alias') instead of 'typedef'

Author: jwakely

src/async.tex

@@ -346,7 +346,7 @@
 class my_service : public execution_context::service
 {
 public:
-  typedef my_service key_type;
+  using key_type = my_service;
   explicit my_service(execution_context& ctx);
   my_service(execution_context& ctx, int some_value);
 private:
@@ -768,8 +768,8 @@
   class async_result
   {
   public:
-    typedef CompletionToken completion_handler_type;
-    typedef void return_type;
+    using completion_handler_type = CompletionToken;
+    using return_type = void;
 
     explicit async_result(completion_handler_type&) {}
     async_result(const async_result&) = delete;
@@ -841,9 +841,8 @@
   template<class CompletionToken, class Signature>
   struct async_completion
   {
-    typedef async_result<decay_t<CompletionToken>,
-      Signature>::completion_handler_type
-        completion_handler_type;
+    using completion_handler_type = async_result<decay_t<CompletionToken>,
+      Signature>::completion_handler_type;
 
     explicit async_completion(CompletionToken& t);
     async_completion(const async_completion&) = delete;
@@ -897,7 +896,7 @@
   template<class T, class ProtoAllocator = allocator<void>>
   struct associated_allocator
   {
-    typedef @\seebelow@ type;
+    using type = @\seebelow@;
 
     static type get(const T& t, const ProtoAllocator& a = ProtoAllocator()) noexcept;
   };
@@ -945,7 +944,7 @@
 \rSec2[async.assoc.alloc.members]{\tcode{associated_allocator} members}
 
 \begin{itemdecl}
-typedef @\seebelow@ type;
+using type = @\seebelow@;
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -1349,7 +1348,7 @@
   template<class T, class Executor = system_executor>
   struct associated_executor
   {
-    typedef @\seebelow@ type;
+    using type = @\seebelow@;
 
     static type get(const T& t, const Executor& e = Executor()) noexcept;
   };
@@ -1397,7 +1396,7 @@
 \rSec2[async.assoc.exec.members]{\tcode{associated_executor} members}
 
 \begin{itemdecl}
-typedef @\seebelow@ type;
+using type = @\seebelow@;
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -1478,8 +1477,8 @@
   public:
     // types:
 
-    typedef T target_type;
-    typedef Executor executor_type;
+    using target_type = T;
+    using executor_type = Executor;
 
     // construct / copy / destroy:
 
@@ -1657,10 +1656,10 @@
   class async_result<executor_binder<T, Executor>, Signature>
   {
   public:
-    typedef executor_binder<
+    using completion_handler_type = executor_binder<
       typename async_result<T, Signature>::completion_handler_type,
-        Executor> completion_handler_type;
-    typedef typename async_result<T, Signature>::return_type return_type;
+        Executor>;
+    using return_type = typename async_result<T, Signature>::return_type;
 
     explicit async_result(completion_handler_type& h);
     async_result(const async_result&) = delete;
@@ -1711,7 +1710,7 @@
   template<class T, class Executor, class ProtoAllocator>
     struct associated_allocator<executor_binder<T, Executor>, ProtoAllocator>
   {
-    typedef associated_allocator_t<T, ProtoAllocator> type;
+    using type = associated_allocator_t<T, ProtoAllocator>;
 
     static type get(const executor_binder<T, Executor>& b,
                     const ProtoAllocator& a = ProtoAllocator()) noexcept;
@@ -1748,7 +1747,7 @@
   template<class T, class Executor, class Executor1>
     struct associated_executor<executor_binder<T, Executor>, Executor1>
   {
-    typedef Executor type;
+    using type = Executor;
 
     static type get(const executor_binder<T, Executor>& b,
                     const Executor1& e = Executor1()) noexcept;
@@ -1822,7 +1821,7 @@
   public:
     // types:
 
-    typedef Executor executor_type;
+    using executor_type = Executor;
 
     // construct / copy / destroy:
 
@@ -2131,7 +2130,7 @@
   public:
     // types:
 
-    typedef system_executor executor_type;
+    using executor_type = system_executor;
 
     // construct / copy / destroy:
 
@@ -2990,7 +2989,7 @@
   public:
     // types:
 
-    typedef Executor inner_executor_type;
+    using inner_executor_type = Executor;
 
     // construct / copy / destroy:
 
@@ -3407,7 +3406,7 @@
   {
   public:
     // use_future_t types:
-    typedef ProtoAllocator allocator_type;
+    using allocator_type = ProtoAllocator;
 
     // use_future_t members:
     constexpr use_future_t() noexcept(noexcept(allocator_type()));
@@ -3493,9 +3492,9 @@
 The implementation provides a partial specialization \tcode{template <class Result, class... Args> async_result<T, Result(Args...)>} such that:
 \begin{itemize}
 \item
- the nested typedef \tcode{completion_handler_type} is a type \tcode{H};
+ the nested type \tcode{completion_handler_type} is a type \tcode{H};
 \item
- the nested typedef \tcode{return_type} is \tcode{future<result_of_t<FD(decay_t<Args>...)>>}; and
+ the nested type \tcode{return_type} is \tcode{future<result_of_t<FD(decay_t<Args>...)>>}; and
 \item
  when an object \tcode{r1} of type \tcode{async_result<T, Result(Args...)>} is constructed from \tcode{h}, the expression \tcode{r1.get()} returns a future with the same shared state as \tcode{h}.
 \end{itemize}
@@ -3515,8 +3514,8 @@
 template<class ProtoAllocator, class Result, class... Args>
 class async_result<use_future_t<ProtoAllocator>, Result(Args...)>
 {
-  typedef @\seebelow@ completion_handler_type;
-  typedef @\seebelow@ return_type;
+  using completion_handler_type = @\seebelow@;
+  using return_type =  @\seebelow@;
 
   explicit async_result(completion_handler_type& h);
   async_result(const async_result&) = delete;
@@ -3629,8 +3628,8 @@
   class async_result<packaged_task<Result(Args...)>, Signature>
   {
   public:
-    typedef packaged_task<Result(Args...)> completion_handler_type;
-    typedef future<Result> return_type;
+    using completion_handler_type = packaged_task<Result(Args...)>;
+    using return_type = future<Result>;
 
     explicit async_result(completion_handler_type& h);
     async_result(const async_result&) = delete;

src/basicioservices.tex

@@ -37,7 +37,7 @@
     // types:
 
     class executor_type;
-    typedef @\textit{implementation-defined}@ count_type;
+    using count_type = @\textit{implementation-defined}@;
 
     // construct / copy / destroy:
 

src/buffers.tex

@@ -1106,8 +1106,8 @@
   {
   public:
     // types:
-    typedef const_buffer const_buffers_type;
-    typedef mutable_buffer mutable_buffers_type;
+    using const_buffers_type = const_buffer;
+    using mutable_buffers_type = mutable_buffer;
 
     // constructors:
     explicit dynamic_vector_buffer(vector<T, Allocator>& vec) noexcept;
@@ -1272,8 +1272,8 @@
   {
   public:
     // types:
-    typedef const_buffer const_buffers_type;
-    typedef mutable_buffer mutable_buffers_type;
+    using const_buffers_type = const_buffer;
+    using mutable_buffers_type = mutable_buffer;
 
     // constructors:
     explicit dynamic_string_buffer(basic_string<CharT, Traits, Allocator>& str) noexcept;

src/forward.tex

@@ -27,9 +27,9 @@
   template<class Clock> struct wait_traits;
   template<class Clock, class WaitTraits = wait_traits<Clock>>
     class basic_waitable_timer;
-  typedef basic_waitable_timer<chrono::system_clock> system_timer;
-  typedef basic_waitable_timer<chrono::steady_clock> steady_timer;
-  typedef basic_waitable_timer<chrono::high_resolution_clock> high_resolution_timer;
+  using system_timer = basic_waitable_timer<chrono::system_clock>;
+  using steady_timer = basic_waitable_timer<chrono::steady_clock>;
+  using high_resolution_timer = basic_waitable_timer<chrono::high_resolution_clock>;
 
   template<class Protocol>
     class basic_socket;
@@ -53,12 +53,12 @@
     class address_v6;
     template<class Address>
       class basic_address_iterator;
-    typedef basic_address_iterator<address_v4> address_v4_iterator;
-    typedef basic_address_iterator<address_v6> address_v6_iterator;
+    using address_v4_iterator = basic_address_iterator<address_v4>;
+    using address_v6_iterator = basic_address_iterator<address_v6>;
     template<class Address>
       class basic_address_range;
-    typedef basic_address_range<address_v4> address_v4_range;
-    typedef basic_address_range<address_v6> address_v6_range;
+    using address_v4_range = basic_address_range<address_v4>;
+    using address_v6_range = basic_address_range<address_v6>;
     class network_v4;
     class network_v6;
     template<class InternetProtocol>