rroonga 5.1.1-x86-mingw32 → 6.0.0-x86-mingw32

data/vendor/local/include/msgpack/adaptor/msgpack_tuple.hpp

@@ -3,17 +3,9 @@
 //
 // Copyright (C) 2008-2014 FURUHASHI Sadayuki and KONDO Takatoshi
 //
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
+//    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)
 //
 #ifndef MSGPACK_MSGPACK_TUPLE_HPP
 #define MSGPACK_MSGPACK_TUPLE_HPP

data/vendor/local/include/msgpack/adaptor/nil.hpp

@@ -3,56 +3,70 @@
 //
 // Copyright (C) 2008-2009 FURUHASHI Sadayuki
 //
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
+//    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)
 //
 #ifndef MSGPACK_TYPE_NIL_HPP
 #define MSGPACK_TYPE_NIL_HPP
 
 #include "msgpack/versioning.hpp"
-#include "msgpack/object_fwd.hpp"
+#include "msgpack/adaptor/adaptor_base.hpp"
 
 namespace msgpack {
 
+/// @cond
 MSGPACK_API_VERSION_NAMESPACE(v1) {
+/// @endcond
 
 namespace type {
 
 struct nil { };
 
+inline bool operator<(nil const& lhs, nil const& rhs) {
+    return &lhs < &rhs;
+}
+
+inline bool operator==(nil const& lhs, nil const& rhs) {
+    return &lhs == &rhs;
+}
+
 }  // namespace type
 
+namespace adaptor {
 
-inline msgpack::object const& operator>> (msgpack::object const& o, type::nil&)
-{
-    if(o.type != msgpack::type::NIL) { throw msgpack::type_error(); }
-    return o;
-}
+template <>
+struct convert<type::nil> {
+    msgpack::object const& operator()(msgpack::object const& o, type::nil&) const {
+        if(o.type != msgpack::type::NIL) { throw msgpack::type_error(); }
+        return o;
+    }
+};
 
-template <typename Stream>
-inline msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, const type::nil&)
-{
-    o.pack_nil();
-    return o;
-}
+template <>
+struct pack<type::nil> {
+    template <typename Stream>
+    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const type::nil&) const {
+        o.pack_nil();
+        return o;
+    }
+};
 
-inline void operator<< (msgpack::object& o, type::nil)
-{
-    o.type = msgpack::type::NIL;
-}
+template <>
+struct object<type::nil> {
+    void operator()(msgpack::object& o, type::nil) const {
+        o.type = msgpack::type::NIL;
+    }
+};
 
-inline void operator<< (msgpack::object::with_zone& o, type::nil v)
-    { static_cast<msgpack::object&>(o) << v; }
+template <>
+struct object_with_zone<type::nil> {
+    void operator()(msgpack::object::with_zone& o, type::nil v) const {
+        static_cast<msgpack::object&>(o) << v;
+    }
+};
 
+} // namespace adaptor
 
 template <>
 inline void msgpack::object::as<void>() const
@@ -61,7 +75,9 @@ inline void msgpack::object::as<void>() const
     convert(v);
 }
 
+/// @cond
 }  // MSGPACK_API_VERSION_NAMESPACE(v1)
+/// @endcond
 
 }  // namespace msgpack
 

data/vendor/local/include/msgpack/adaptor/pair.hpp

@@ -3,60 +3,80 @@
 //
 // Copyright (C) 2008-2009 FURUHASHI Sadayuki
 //
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
+//    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)
 //
 #ifndef MSGPACK_TYPE_PAIR_HPP
 #define MSGPACK_TYPE_PAIR_HPP
 
 #include "msgpack/versioning.hpp"
-#include "msgpack/object_fwd.hpp"
+#include "msgpack/adaptor/adaptor_base.hpp"
+#include "msgpack/meta.hpp"
+
 #include <utility>
 
 namespace msgpack {
 
+/// @cond
 MSGPACK_API_VERSION_NAMESPACE(v1) {
+/// @endcond
+
+namespace adaptor {
+
+#if !defined(MSGPACK_USE_CPP03)
 
 template <typename T1, typename T2>
-inline msgpack::object const& operator>> (msgpack::object const& o, std::pair<T1, T2>& v)
-{
-    if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
-    if(o.via.array.size != 2) { throw msgpack::type_error(); }
-    o.via.array.ptr[0].convert(v.first);
-    o.via.array.ptr[1].convert(v.second);
-    return o;
-}
-
-template <typename Stream, typename T1, typename T2>
-inline msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, const std::pair<T1, T2>& v)
-{
-    o.pack_array(2);
-    o.pack(v.first);
-    o.pack(v.second);
-    return o;
-}
+struct as<std::pair<T1, T2>,
+          typename std::enable_if<msgpack::all_of<msgpack::has_as, T1, T2>::value>::type> {
+    std::pair<T1, T2> operator()(msgpack::object const& o) const {
+        if (o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
+        if (o.via.array.size != 2) { throw msgpack::type_error(); }
+        return std::make_pair(o.via.array.ptr[0].as<T1>(), o.via.array.ptr[1].as<T2>());
+    }
+};
+
+#endif // !defined(MSGPACK_USE_CPP03)
 
 template <typename T1, typename T2>
-inline void operator<< (msgpack::object::with_zone& o, const std::pair<T1, T2>& v)
-{
-    o.type = msgpack::type::ARRAY;
-    msgpack::object* p = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*2));
-    o.via.array.ptr = p;
-    o.via.array.size = 2;
-    p[0] = msgpack::object(v.first, o.zone);
-    p[1] = msgpack::object(v.second, o.zone);
-}
+struct convert<std::pair<T1, T2> > {
+    msgpack::object const& operator()(msgpack::object const& o, std::pair<T1, T2>& v) const {
+        if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
+        if(o.via.array.size != 2) { throw msgpack::type_error(); }
+        o.via.array.ptr[0].convert(v.first);
+        o.via.array.ptr[1].convert(v.second);
+        return o;
+    }
+};
+
+template <typename T1, typename T2>
+struct pack<std::pair<T1, T2> > {
+    template <typename Stream>
+    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const std::pair<T1, T2>& v) const {
+        o.pack_array(2);
+        o.pack(v.first);
+        o.pack(v.second);
+        return o;
+    }
+};
+
+template <typename T1, typename T2>
+struct object_with_zone<std::pair<T1, T2> > {
+    void operator()(msgpack::object::with_zone& o, const std::pair<T1, T2>& v) const {
+        o.type = msgpack::type::ARRAY;
+        msgpack::object* p = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*2));
+        o.via.array.ptr = p;
+        o.via.array.size = 2;
+        p[0] = msgpack::object(v.first, o.zone);
+        p[1] = msgpack::object(v.second, o.zone);
+    }
+};
+
+} // namespace adaptor
 
+/// @cond
 }  // MSGPACK_API_VERSION_NAMESPACE(v1)
+/// @endcond
 
 }  // namespace msgpack
 

data/vendor/local/include/msgpack/adaptor/raw.hpp

@@ -3,29 +3,23 @@
 //
 // Copyright (C) 2008-2009 FURUHASHI Sadayuki
 //
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
+//    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)
 //
 #ifndef MSGPACK_TYPE_RAW_HPP
 #define MSGPACK_TYPE_RAW_HPP
 
 #include "msgpack/versioning.hpp"
-#include "msgpack/object_fwd.hpp"
-#include <string.h>
+#include "msgpack/adaptor/adaptor_base.hpp"
+#include <cstring>
 #include <string>
 
 namespace msgpack {
 
+/// @cond
 MSGPACK_API_VERSION_NAMESPACE(v1) {
+/// @endcond
 
 namespace type {
 
@@ -45,7 +39,7 @@ struct raw_ref {
 
     bool operator!= (const raw_ref& x) const
     {
-        return !(*this != x);
+        return !(*this == x);
     }
 
     bool operator< (const raw_ref& x) const
@@ -61,38 +55,52 @@ struct raw_ref {
     }
 };
 
-}  // namespace type
+} // namespace type
 
+namespace adaptor {
 
-inline msgpack::object const& operator>> (msgpack::object const& o, msgpack::type::raw_ref& v)
-{
-    if(o.type != msgpack::type::BIN) { throw msgpack::type_error(); }
-    v.ptr  = o.via.bin.ptr;
-    v.size = o.via.bin.size;
-    return o;
-}
+template <>
+struct convert<msgpack::type::raw_ref> {
+    msgpack::object const& operator()(msgpack::object const& o, msgpack::type::raw_ref& v) const {
+        if(o.type != msgpack::type::BIN) { throw msgpack::type_error(); }
+        v.ptr  = o.via.bin.ptr;
+        v.size = o.via.bin.size;
+        return o;
+    }
+};
 
-template <typename Stream>
-inline msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, const msgpack::type::raw_ref& v)
-{
-    o.pack_bin(v.size);
-    o.pack_bin_body(v.ptr, v.size);
-    return o;
-}
+template <>
+struct pack<msgpack::type::raw_ref> {
+    template <typename Stream>
+    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const msgpack::type::raw_ref& v) const {
+        o.pack_bin(v.size);
+        o.pack_bin_body(v.ptr, v.size);
+        return o;
+    }
+};
 
-inline void operator<< (msgpack::object& o, const msgpack::type::raw_ref& v)
-{
-    o.type = msgpack::type::BIN;
-    o.via.bin.ptr = v.ptr;
-    o.via.bin.size = v.size;
-}
+template <>
+struct object<msgpack::type::raw_ref> {
+    void operator()(msgpack::object& o, const msgpack::type::raw_ref& v) const {
+        o.type = msgpack::type::BIN;
+        o.via.bin.ptr = v.ptr;
+        o.via.bin.size = v.size;
+    }
+};
 
-inline void operator<< (msgpack::object::with_zone& o, const msgpack::type::raw_ref& v)
-    { static_cast<msgpack::object&>(o) << v; }
+template <>
+struct object_with_zone<msgpack::type::raw_ref> {
+    void operator()(msgpack::object::with_zone& o, const msgpack::type::raw_ref& v) const {
+        static_cast<msgpack::object&>(o) << v;
+    }
+};
 
+} // namespace adaptor
 
-}  // MSGPACK_API_VERSION_NAMESPACE(v1)
+/// @cond
+} // MSGPACK_API_VERSION_NAMESPACE(v1)
+/// @endcond
 
-}  // namespace msgpack
+} // namespace msgpack
 
 #endif // MSGPACK_TYPE_RAW_HPP

data/vendor/local/include/msgpack/adaptor/set.hpp

@@ -3,131 +3,185 @@
 //
 // Copyright (C) 2008-2015 FURUHASHI Sadayuki
 //
-//    Licensed under the Apache License, Version 2.0 (the "License");
-//    you may not use this file except in compliance with the License.
-//    You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//    Unless required by applicable law or agreed to in writing, software
-//    distributed under the License is distributed on an "AS IS" BASIS,
-//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//    See the License for the specific language governing permissions and
-//    limitations under the License.
+//    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)
 //
 #ifndef MSGPACK_TYPE_SET_HPP
 #define MSGPACK_TYPE_SET_HPP
 
 #include "msgpack/versioning.hpp"
-#include "msgpack/object_fwd.hpp"
+#include "msgpack/adaptor/adaptor_base.hpp"
 #include "msgpack/adaptor/check_container_size.hpp"
 
 #include <set>
 
 namespace msgpack {
 
+/// @cond
 MSGPACK_API_VERSION_NAMESPACE(v1) {
+/// @endcond
+
+namespace adaptor {
 
-template <typename T>
-inline msgpack::object const& operator>> (msgpack::object const& o, std::set<T>& v)
-{
-    if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
-    msgpack::object* p = o.via.array.ptr + o.via.array.size;
-    msgpack::object* const pbegin = o.via.array.ptr;
-    std::set<T> tmp;
-    while(p > pbegin) {
-        --p;
-        tmp.insert(p->as<T>());
+#if !defined(MSGPACK_USE_CPP03)
+
+template <typename T, typename Compare, typename Alloc>
+struct as<std::set<T, Compare, Alloc>, typename std::enable_if<msgpack::has_as<T>::value>::type> {
+    std::set<T, Compare, Alloc> operator()(msgpack::object const& o) const {
+        if (o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
+        msgpack::object* p = o.via.array.ptr + o.via.array.size;
+        msgpack::object* const pbegin = o.via.array.ptr;
+        std::set<T, Compare, Alloc> v;
+        while (p > pbegin) {
+            --p;
+            v.insert(p->as<T>());
+        }
+        return v;
     }
-    tmp.swap(v);
-    return o;
-}
-
-template <typename Stream, typename T>
-inline msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, const std::set<T>& v)
-{
-    uint32_t size = checked_get_container_size(v.size());
-    o.pack_array(size);
-    for(typename std::set<T>::const_iterator it(v.begin()), it_end(v.end());
-        it != it_end; ++it) {
-        o.pack(*it);
+};
+
+#endif // !defined(MSGPACK_USE_CPP03)
+
+template <typename T, typename Compare, typename Alloc>
+struct convert<std::set<T, Compare, Alloc> > {
+    msgpack::object const& operator()(msgpack::object const& o, std::set<T, Compare, Alloc>& v) const {
+        if (o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
+        msgpack::object* p = o.via.array.ptr + o.via.array.size;
+        msgpack::object* const pbegin = o.via.array.ptr;
+        std::set<T, Compare, Alloc> tmp;
+        while (p > pbegin) {
+            --p;
+            tmp.insert(p->as<T>());
+        }
+#if __cplusplus >= 201103L
+        v = std::move(tmp);
+#else
+        tmp.swap(v);
+#endif
+        return o;
     }
-    return o;
-}
-
-template <typename T>
-inline void operator<< (msgpack::object::with_zone& o, const std::set<T>& v)
-{
-    o.type = msgpack::type::ARRAY;
-    if(v.empty()) {
-        o.via.array.ptr = nullptr;
-        o.via.array.size = 0;
-    } else {
+};
+
+template <typename T, typename Compare, typename Alloc>
+struct pack<std::set<T, Compare, Alloc> > {
+    template <typename Stream>
+    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const std::set<T, Compare, Alloc>& v) const {
         uint32_t size = checked_get_container_size(v.size());
-        msgpack::object* p = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*size));
-        msgpack::object* const pend = p + size;
-        o.via.array.ptr = p;
-        o.via.array.size = size;
-        typename std::set<T>::const_iterator it(v.begin());
-        do {
-            *p = msgpack::object(*it, o.zone);
-            ++p;
-            ++it;
-        } while(p < pend);
+        o.pack_array(size);
+        for (typename std::set<T, Compare, Alloc>::const_iterator it(v.begin()), it_end(v.end());
+            it != it_end; ++it) {
+            o.pack(*it);
+        }
+        return o;
     }
-}
-
-
-template <typename T>
-inline msgpack::object const& operator>> (msgpack::object const& o, std::multiset<T>& v)
-{
-    if(o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
-    msgpack::object* p = o.via.array.ptr + o.via.array.size;
-    msgpack::object* const pbegin = o.via.array.ptr;
-    std::multiset<T> tmp;
-    while(p > pbegin) {
-        --p;
-        tmp.insert(p->as<T>());
+};
+
+template <typename T, typename Compare, typename Alloc>
+struct object_with_zone<std::set<T, Compare, Alloc> > {
+    void operator()(msgpack::object::with_zone& o, const std::set<T, Compare, Alloc>& v) const {
+        o.type = msgpack::type::ARRAY;
+        if (v.empty()) {
+            o.via.array.ptr = nullptr;
+            o.via.array.size = 0;
+        }
+        else {
+            uint32_t size = checked_get_container_size(v.size());
+            msgpack::object* p = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*size));
+            msgpack::object* const pend = p + size;
+            o.via.array.ptr = p;
+            o.via.array.size = size;
+            typename std::set<T, Compare, Alloc>::const_iterator it(v.begin());
+            do {
+                *p = msgpack::object(*it, o.zone);
+                ++p;
+                ++it;
+            } while(p < pend);
+        }
     }
-    tmp.swap(v);
-    return o;
-}
-
-template <typename Stream, typename T>
-inline msgpack::packer<Stream>& operator<< (msgpack::packer<Stream>& o, const std::multiset<T>& v)
-{
-    uint32_t size = checked_get_container_size(v.size());
-    o.pack_array(size);
-    for(typename std::multiset<T>::const_iterator it(v.begin()), it_end(v.end());
-        it != it_end; ++it) {
-        o.pack(*it);
+};
+
+#if !defined(MSGPACK_USE_CPP03)
+
+template <typename T, typename Compare, typename Alloc>
+struct as<std::multiset<T, Compare, Alloc>, typename std::enable_if<msgpack::has_as<T>::value>::type> {
+    std::multiset<T, Compare, Alloc> operator()(msgpack::object const& o) const {
+        if (o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
+        msgpack::object* p = o.via.array.ptr + o.via.array.size;
+        msgpack::object* const pbegin = o.via.array.ptr;
+        std::multiset<T, Compare, Alloc> v;
+        while (p > pbegin) {
+            --p;
+            v.insert(p->as<T>());
+        }
+        return v;
+    }
+};
+
+#endif // !defined(MSGPACK_USE_CPP03)
+
+template <typename T, typename Compare, typename Alloc>
+struct convert<std::multiset<T, Compare, Alloc> > {
+    msgpack::object const& operator()(msgpack::object const& o, std::multiset<T, Compare, Alloc>& v) const {
+        if (o.type != msgpack::type::ARRAY) { throw msgpack::type_error(); }
+        msgpack::object* p = o.via.array.ptr + o.via.array.size;
+        msgpack::object* const pbegin = o.via.array.ptr;
+        std::multiset<T, Compare, Alloc> tmp;
+        while (p > pbegin) {
+            --p;
+            tmp.insert(p->as<T>());
+        }
+#if __cplusplus >= 201103L
+        v = std::move(tmp);
+#else
+        tmp.swap(v);
+#endif
+        return o;
     }
-    return o;
-}
-
-template <typename T>
-inline void operator<< (msgpack::object::with_zone& o, const std::multiset<T>& v)
-{
-    o.type = msgpack::type::ARRAY;
-    if(v.empty()) {
-        o.via.array.ptr = nullptr;
-        o.via.array.size = 0;
-    } else {
+};
+
+template <typename T, typename Compare, typename Alloc>
+struct pack<std::multiset<T, Compare, Alloc> > {
+    template <typename Stream>
+    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const std::multiset<T, Compare, Alloc>& v) const {
         uint32_t size = checked_get_container_size(v.size());
-        msgpack::object* p = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*size));
-        msgpack::object* const pend = p + size;
-        o.via.array.ptr = p;
-        o.via.array.size = size;
-        typename std::multiset<T>::const_iterator it(v.begin());
-        do {
-            *p = msgpack::object(*it, o.zone);
-            ++p;
-            ++it;
-        } while(p < pend);
+        o.pack_array(size);
+        for (typename std::multiset<T, Compare, Alloc>::const_iterator it(v.begin()), it_end(v.end());
+            it != it_end; ++it) {
+            o.pack(*it);
+        }
+        return o;
+    }
+};
+
+template <typename T, typename Compare, typename Alloc>
+struct object_with_zone<std::multiset<T, Compare, Alloc> > {
+    void operator()(msgpack::object::with_zone& o, const std::multiset<T, Compare, Alloc>& v) const {
+        o.type = msgpack::type::ARRAY;
+        if (v.empty()) {
+            o.via.array.ptr = nullptr;
+            o.via.array.size = 0;
+        } else {
+            uint32_t size = checked_get_container_size(v.size());
+            msgpack::object* p = static_cast<msgpack::object*>(o.zone.allocate_align(sizeof(msgpack::object)*size));
+            msgpack::object* const pend = p + size;
+            o.via.array.ptr = p;
+            o.via.array.size = size;
+            typename std::multiset<T, Compare, Alloc>::const_iterator it(v.begin());
+            do {
+                *p = msgpack::object(*it, o.zone);
+                ++p;
+                ++it;
+            } while(p < pend);
+        }
     }
-}
+};
+
+} // namespace adaptor
 
+/// @cond
 }  // MSGPACK_API_VERSION_NAMESPACE(v1)
+/// @endcond
 
 }  // namespace msgpack