refact: drop header_storage_t usage

debian/changelog

@@ -495,7 +495,7 @@ cocaine-core (0.12.8.10+nmu1) unstable; urgency=low
 cocaine-core (0.12.8.9+nmu1) unstable; urgency=low
 
   * Non-maintainer upload.
-  * Hpack fix - proper ctor for header_storage_t
+  * Hpack fix - proper ctor for headers_t
 
  -- Anton Matveenko <antmat@me.com>  Thu, 28 Apr 2016 20:11:29 +0300
 

include/cocaine/forwards.hpp

@@ -126,8 +126,7 @@ class header_t;
 struct headers;
 struct header_static_table;
 
-// deprecated - use headers_t
-using header_storage_t = std::vector<header_t>;
+using header_storage_t __attribute__((deprecated("use `headers_t` instead"))) = std::vector<header_t>;
 using headers_t = std::vector<header_t>;
 
 }} // namespace cocaine::hpack

include/cocaine/hpack/header.hpp

@@ -153,7 +153,7 @@ class header_t {
     } data;
 };
 
-typedef std::vector<header_t> header_storage_t;
+typedef std::vector<header_t> headers_t;
 using headers_t = std::vector<header_t>;
 
 // Header static and dynamic table as described in http2

include/cocaine/rpc/asio/decoder.hpp

@@ -47,7 +47,7 @@ struct decoded_message_t {
     args() const -> const msgpack::object&;
 
     auto
-    headers() const -> const hpack::header_storage_t&;
+    headers() const -> const hpack::headers_t&;
 
     void
     clear();
@@ -56,7 +56,7 @@ struct decoded_message_t {
 
     // These objects keep references to message buffer in the Decoder.
     msgpack::object object;
-    hpack::header_storage_t metadata;
+    hpack::headers_t metadata;
 };
 
 } // namespace aux

include/cocaine/rpc/asio/encoder.hpp

@@ -102,7 +102,7 @@ struct encoder_t {
     template<class Event, class... Args>
     static inline
     aux::encoded_message_t
-    tether(encoder_t& encoder, uint64_t channel_id, const hpack::header_storage_t& headers, Args&... args) {
+    tether(encoder_t& encoder, uint64_t channel_id, const hpack::headers_t& headers, Args&... args) {
         aux::encoded_message_t message;
 
         packer_type packer(message.buffer);
@@ -127,7 +127,7 @@ struct encoder_t {
     encode(const message_type& message);
 
     void
-    pack_headers(packer_type& packer, const hpack::header_storage_t& headers);
+    pack_headers(packer_type& packer, const hpack::headers_t& headers);
 
 private:
     // HPACK HTTP/2.0 tables.
@@ -143,12 +143,12 @@ struct encoded:
     std::bind(&encoder_t::tether<Event, typename std::decay<Args>::type...>,
               std::placeholders::_1,
               channel_id,
-              hpack::header_storage_t(),
+              hpack::headers_t(),
               std::forward<Args>(args)...))
     { }
 
     template<class... Args>
-    encoded(uint64_t channel_id, hpack::header_storage_t headers, Args&&... args): unbound_message_t(
+    encoded(uint64_t channel_id, hpack::headers_t headers, Args&&... args): unbound_message_t(
         std::bind(&encoder_t::tether<Event, typename std::decay<Args>::type...>,
             std::placeholders::_1,
             channel_id,

include/cocaine/rpc/queue.hpp

@@ -41,7 +41,7 @@ struct frozen_visitor:
 {
     explicit
     frozen_visitor(const std::shared_ptr<basic_upstream_t>& upstream_,
-                   hpack::header_storage_t& headers_) :
+                   hpack::headers_t& headers_) :
         upstream(upstream_),
         headers(headers_)
     { }
@@ -55,15 +55,15 @@ struct frozen_visitor:
 
 private:
     const std::shared_ptr<basic_upstream_t>& upstream;
-    hpack::header_storage_t& headers;
+    hpack::headers_t& headers;
 };
 
 } // namespace aux
 
 template<class Tag>
 class message_queue {
     // Operation log.
-    std::vector<std::tuple<hpack::header_storage_t, typename make_frozen_over<Tag>::type>> m_operations;
+    std::vector<std::tuple<hpack::headers_t, typename make_frozen_over<Tag>::type>> m_operations;
 
     // The upstream might be attached during message invocation, so it has to be synchronized for
     // thread safety - the atomicity guarantee of the shared_ptr<T> is not enough.
@@ -72,7 +72,7 @@ class message_queue {
 public:
     template<class Event, class... Args>
     std::error_code
-    append(hpack::header_storage_t headers, Args&&... args) {
+    append(hpack::headers_t headers, Args&&... args) {
         static_assert(std::is_same<typename Event::tag, Tag>::value,
                       "message protocol is not compatible with this message queue");
 
@@ -96,7 +96,7 @@ class message_queue {
                       "message protocol is not compatible with this message queue");
 
         if(!m_upstream) {
-            m_operations.emplace_back(hpack::header_storage_t(), make_frozen<Event>(std::forward<Args>(args)...));
+            m_operations.emplace_back(hpack::headers_t(), make_frozen<Event>(std::forward<Args>(args)...));
             return {};
         }
 

include/cocaine/rpc/slot/deferred.hpp

@@ -116,7 +116,7 @@ struct deferred_base {
     }
 
     std::error_code
-    abort(hpack::header_storage_t headers, const std::error_code& ec, const std::string& reason) {
+    abort(hpack::headers_t headers, const std::error_code& ec, const std::string& reason) {
         return outbox->synchronize()->template append<typename protocol::error>(std::move(headers), ec, reason);
     }
 
@@ -128,7 +128,7 @@ struct deferred_base {
 
     template<class... Args>
     std::error_code
-    write(hpack::header_storage_t headers, Args&&... args) {
+    write(hpack::headers_t headers, Args&&... args) {
         return outbox->synchronize()->template append<typename protocol::value>(std::move(headers), std::forward<Args>(args)...);
     }
 

include/cocaine/rpc/slot/streamed.hpp

@@ -46,7 +46,7 @@ struct streamed {
         std::is_constructible<T, Args...>::value,
         std::error_code
     >::type
-    write(hpack::header_storage_t headers, Args&&... args) {
+    write(hpack::headers_t headers, Args&&... args) {
         auto d = data->synchronize();
         if (d->state == state_t::closed) {
             return make_error_code(error::protocol_errors::closed_upstream);
@@ -65,7 +65,7 @@ struct streamed {
     }
 
     std::error_code
-    abort(hpack::header_storage_t headers, const std::error_code& ec, const std::string& reason) {
+    abort(hpack::headers_t headers, const std::error_code& ec, const std::string& reason) {
         return data->apply([&](data_t& data) {
             if(utility::exchange(data.state, state_t::closed) == state_t::closed) {
                 return make_error_code(error::protocol_errors::closed_upstream);
@@ -81,7 +81,7 @@ struct streamed {
     }
 
     std::error_code
-    close(hpack::header_storage_t headers) {
+    close(hpack::headers_t headers) {
         return data->apply([&](data_t& data) {
             if (utility::exchange(data.state, state_t::closed) == state_t::closed) {
                 return make_error_code(error::protocol_errors::closed_upstream);

include/cocaine/rpc/upstream.hpp

@@ -73,7 +73,7 @@ class basic_upstream_t {
 
     template<class Event, class... Args>
     void
-    send(hpack::header_storage_t headers, Args&&... args) {
+    send(hpack::headers_t headers, Args&&... args) {
         send(encoded<Event>(m_channel_id, std::move(headers), std::forward<Args>(args)...));
     }
 };
@@ -109,7 +109,7 @@ class upstream {
 
     template<class Event, class... Args>
     upstream<typename io::event_traits<Event>::dispatch_type>
-    send(hpack::header_storage_t headers, Args&&... args) {
+    send(hpack::headers_t headers, Args&&... args) {
         static_assert(
             std::is_same<typename Event::tag, Tag>::value,
             "message protocol is not compatible with this upstream"

src/encoder.cpp

@@ -89,7 +89,7 @@ unbound_message_t::unbound_message_t(function_type&& bind_): bind(std::move(bind
 } //  namespace aux
 
 void
-encoder_t::pack_headers(packer_type& packer, const hpack::header_storage_t& headers) {
+encoder_t::pack_headers(packer_type& packer, const hpack::headers_t& headers) {
 
     size_t skip = 0;
     for (const auto& header: headers) {