import new upstream nautilus stable release 14.2.8

[ceph.git] / ceph / src / boost / boost / beast / zlib / detail / window.hpp

diff --git a/ceph/src/boost/boost/beast/zlib/detail/window.hpp b/ceph/src/boost/boost/beast/zlib/detail/window.hpp
index f089649183497e8daf5e3702298b174dad79cf0a..44495de05effe5d214d4efd9f2e0e6bdaa587e91 100644 (file)
--- a/ceph/src/boost/boost/beast/zlib/detail/window.hpp
+++ b/ceph/src/boost/boost/beast/zlib/detail/window.hpp
@@ -1,5 +1,5 @@
 //
-// Copyright (c) 2016-2017 Vinnie Falco (vinnie dot falco at gmail dot com)
+// Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com)
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -76,88 +76,72 @@ public:
     }
 
     void
-    reset(int bits);
-
-    void
-    read(std::uint8_t* out, std::size_t pos, std::size_t n);
-
-    template<class = void>
-    void
-    write(std::uint8_t const* in, std::size_t n);
-};
-
-inline
-void
-window::
-reset(int bits)
-{
-    if(bits_ != bits)
-    {
-        p_.reset();
-        bits_ = static_cast<std::uint8_t>(bits);
-        capacity_ = 1U << bits_;
-    }
-    i_ = 0;
-    size_ = 0;
-}
-
-inline
-void
-window::
-read(std::uint8_t* out, std::size_t pos, std::size_t n)
-{
-    if(i_ >= size_)
-    {
-        // window is contiguous
-        std::memcpy(out, &p_[i_ - pos], n);
-        return;
-    }
-    auto i = ((i_ - pos) + capacity_) % capacity_;
-    auto m = capacity_ - i;
-    if(n <= m)
+    reset(int bits)
     {
-        std::memcpy(out, &p_[i], n);
-        return;
+        if(bits_ != bits)
+        {
+            p_.reset();
+            bits_ = static_cast<std::uint8_t>(bits);
+            capacity_ = 1U << bits_;
+        }
+        i_ = 0;
+        size_ = 0;
     }
-    std::memcpy(out, &p_[i], m);
-    out += m;
-    std::memcpy(out, &p_[0], n - m);
-}
-
-template<class>
-void
-window::
-write(std::uint8_t const* in, std::size_t n)
-{
-    if(! p_)
-        p_ = boost::make_unique<
-            std::uint8_t[]>(capacity_);
-    if(n >= capacity_)
+
+    void
+    read(std::uint8_t* out, std::size_t pos, std::size_t n)
     {
-        i_ = 0;
-        size_ = capacity_;
-        std::memcpy(&p_[0], in + (n - size_), size_);
-        return;
+        if(i_ >= size_)
+        {
+            // window is contiguous
+            std::memcpy(out, &p_[i_ - pos], n);
+            return;
+        }
+        auto i = ((i_ - pos) + capacity_) % capacity_;
+        auto m = capacity_ - i;
+        if(n <= m)
+        {
+            std::memcpy(out, &p_[i], n);
+            return;
+        }
+        std::memcpy(out, &p_[i], m);
+        out += m;
+        std::memcpy(out, &p_[0], n - m);
     }
-    if(i_ + n <= capacity_)
+
+    void
+    write(std::uint8_t const* in, std::size_t n)
     {
-        std::memcpy(&p_[i_], in, n);
-        if(size_ >= capacity_ - n)
+        if(! p_)
+            p_ = boost::make_unique<
+                std::uint8_t[]>(capacity_);
+        if(n >= capacity_)
+        {
+            i_ = 0;
             size_ = capacity_;
-        else
-            size_ = static_cast<std::uint16_t>(size_ + n);
-
-        i_ = static_cast<std::uint16_t>(
-            (i_ + n) % capacity_);
-        return;
+            std::memcpy(&p_[0], in + (n - size_), size_);
+            return;
+        }
+        if(i_ + n <= capacity_)
+        {
+            std::memcpy(&p_[i_], in, n);
+            if(size_ >= capacity_ - n)
+                size_ = capacity_;
+            else
+                size_ = static_cast<std::uint16_t>(size_ + n);
+
+            i_ = static_cast<std::uint16_t>(
+                (i_ + n) % capacity_);
+            return;
+        }
+        auto m = capacity_ - i_;
+        std::memcpy(&p_[i_], in, m);
+        in += m;
+        i_ = static_cast<std::uint16_t>(n - m);
+        std::memcpy(&p_[0], in, i_);
+        size_ = capacity_;
     }
-    auto m = capacity_ - i_;
-    std::memcpy(&p_[i_], in, m);
-    in += m;
-    i_ = static_cast<std::uint16_t>(n - m);
-    std::memcpy(&p_[0], in, i_);
-    size_ = capacity_;
-}
+};
 
 } // detail
 } // zlib