Release 1.43.0 beta 1

[SVN r61461]
Merge throw_exception use in unordered.
2026-08-07 14:14:07 +02:00 · 2010-04-21 14:13:35 +00:00 · 2010-04-05 08:08:25 +00:00 · 2010-03-31 21:39:07 +00:00 · 2010-03-17 00:34:26 +00:00 · 2010-02-25 19:05:01 +00:00
14 changed files with 193 additions and 61 deletions
@@ -8,10 +8,7 @@ path-constant admonishment_location : ../../../../doc/src/images ;

 xml unordered : unordered.qbk ;
 boostbook standalone : unordered :
-    <xsl:param>html.stylesheet=../../../../doc/html/boostbook.css
    <xsl:param>boost.root=../../../..
-    <xsl:param>boost.libraries=../../../libraries.htm
-    <xsl:param>navig.graphics=1

    <xsl:param>chunk.first.sections=1
    <xsl:param>chunk.section.depth=2
@@ -117,4 +117,15 @@ First official release.
  Add missing `std` qualifier to `ptrdiff_t`.
 * Some code formatting changes to fit almost all lines into 80 characters.

+
+[h2 Boost 1.43.0]
+
+* [@http://svn.boost.org/trac/boost/ticket/3966 Ticket 3966]:
+  `erase_return_void` is now `quick_erase`, which is the
+  [@http://home.roadrunner.com/~hinnant/issue_review/lwg-active.html#579
+  current forerunner for resolving the slow erase by iterator], although
+  there's a strong possibility that this may change in the future. The old
+  method name remains for backwards compatibility but is considered deprecated
+  and will be removed in a future release.
+
 [endsect]
@@ -464,8 +464,8 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
                  When the number of elements is a lot smaller than the number of buckets
                  this function can be very inefficient as it has to search through empty
                  buckets for the next element, in order to return the iterator.
-                  As a temporary workaround, the container has the method
-                  <methodname>erase_return_void</methodname> which will be faster.
+                  The method <methodname>quick_erase</methodname> is faster, but has yet
+                  to be standardized.
                </para>
              </notes>
            </method>
@@ -503,6 +503,30 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
                <para>In this implementation, this overload doesn't call either function object's methods so it is no throw, but this might not be true in other implementations.</para>
              </throws>
            </method>
+            <method name="quick_erase">
+              <parameter name="position">
+                <paramtype>const_iterator</paramtype>
+              </parameter>
+              <type>void</type>
+              <description>
+                <para>Erase the element pointed to by <code>position</code>.</para>
+              </description>
+              <throws>
+                <para>Only throws an exception if it is thrown by <code>hasher</code> or <code>key_equal</code>.</para>
+                <para>In this implementation, this overload doesn't call either function object's methods so it is no throw, but this might not be true in other implementations.</para>
+              </throws>
+              <notes>
+                <para>
+                  This method is faster than <methodname>erase</methodname> as
+                  it doesn't have to find the next element in the container -
+                  a potentially costly operation.
+                </para>
+                <para>
+                  As it hasn't been standardized, it's likely that this may
+                  change in the future.
+                </para>
+              </notes>
+            </method>
            <method name="erase_return_void">
              <parameter name="position">
                <paramtype>const_iterator</paramtype>
@@ -517,10 +541,10 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
              </throws>
              <notes>
                <para>
-                  This is a temporary workaround for the inefficient
-                  <methodname>erase</methodname> method. Hopefully, in a future
-                  version the signature of <methodname>erase</methodname> will
-                  be changed and this will be deprecated.
+                  This method is now deprecated, use
+                  <methodname>quick_return</methodname> instead. Although be
+                  warned that as that isn't standardized yet, it could also
+                  change.
                </para>
              </notes>
            </method>
@@ -1327,8 +1351,8 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
                  When the number of elements is a lot smaller than the number of buckets
                  this function can be very inefficient as it has to search through empty
                  buckets for the next element, in order to return the iterator.
-                  As a temporary workaround, the container has the method
-                  <methodname>erase_return_void</methodname> which will be faster.
+                  The method <methodname>quick_erase</methodname> is faster, but has yet
+                  to be standardized.
                </para>
              </notes>
            </method>
@@ -1366,6 +1390,30 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
                <para>In this implementation, this overload doesn't call either function object's methods so it is no throw, but this might not be true in other implementations.</para>
              </throws>
            </method>
+            <method name="quick_erase">
+              <parameter name="position">
+                <paramtype>const_iterator</paramtype>
+              </parameter>
+              <type>void</type>
+              <description>
+                <para>Erase the element pointed to by <code>position</code>.</para>
+              </description>
+              <throws>
+                <para>Only throws an exception if it is thrown by <code>hasher</code> or <code>key_equal</code>.</para>
+                <para>In this implementation, this overload doesn't call either function object's methods so it is no throw, but this might not be true in other implementations.</para>
+              </throws>
+              <notes>
+                <para>
+                  This method is faster than <methodname>erase</methodname> as
+                  it doesn't have to find the next element in the container -
+                  a potentially costly operation.
+                </para>
+                <para>
+                  As it hasn't been standardized, it's likely that this may
+                  change in the future.
+                </para>
+              </notes>
+            </method>
            <method name="erase_return_void">
              <parameter name="position">
                <paramtype>const_iterator</paramtype>
@@ -1380,10 +1428,10 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
              </throws>
              <notes>
                <para>
-                  This is a temporary workaround for the inefficient
-                  <methodname>erase</methodname> method. Hopefully, in a future
-                  version the signature of <methodname>erase</methodname> will
-                  be changed and this will be deprecated.
+                  This method is now deprecated, use
+                  <methodname>quick_return</methodname> instead. Although be
+                  warned that as that isn't standardized yet, it could also
+                  change.
                </para>
              </notes>
            </method>
@@ -2204,8 +2252,8 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
                  When the number of elements is a lot smaller than the number of buckets
                  this function can be very inefficient as it has to search through empty
                  buckets for the next element, in order to return the iterator.
-                  As a temporary workaround, the container has the method
-                  <methodname>erase_return_void</methodname> which will be faster.
+                  The method <methodname>quick_erase</methodname> is faster, but has yet
+                  to be standardized.
                </para>
              </notes>
            </method>
@@ -2243,6 +2291,30 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
                <para>In this implementation, this overload doesn't call either function object's methods so it is no throw, but this might not be true in other implementations.</para>
              </throws>
            </method>
+            <method name="quick_erase">
+              <parameter name="position">
+                <paramtype>const_iterator</paramtype>
+              </parameter>
+              <type>void</type>
+              <description>
+                <para>Erase the element pointed to by <code>position</code>.</para>
+              </description>
+              <throws>
+                <para>Only throws an exception if it is thrown by <code>hasher</code> or <code>key_equal</code>.</para>
+                <para>In this implementation, this overload doesn't call either function object's methods so it is no throw, but this might not be true in other implementations.</para>
+              </throws>
+              <notes>
+                <para>
+                  This method is faster than <methodname>erase</methodname> as
+                  it doesn't have to find the next element in the container -
+                  a potentially costly operation.
+                </para>
+                <para>
+                  As it hasn't been standardized, it's likely that this may
+                  change in the future.
+                </para>
+              </notes>
+            </method>
            <method name="erase_return_void">
              <parameter name="position">
                <paramtype>const_iterator</paramtype>
@@ -2257,10 +2329,10 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
              </throws>
              <notes>
                <para>
-                  This is a temporary workaround for the inefficient
-                  <methodname>erase</methodname> method. Hopefully, in a future
-                  version the signature of <methodname>erase</methodname> will
-                  be changed and this will be deprecated.
+                  This method is now deprecated, use
+                  <methodname>quick_return</methodname> instead. Although be
+                  warned that as that isn't standardized yet, it could also
+                  change.
                </para>
              </notes>
            </method>
@@ -3116,8 +3188,8 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
                  When the number of elements is a lot smaller than the number of buckets
                  this function can be very inefficient as it has to search through empty
                  buckets for the next element, in order to return the iterator.
-                  As a temporary workaround, the container has the method
-                  <methodname>erase_return_void</methodname> which will be faster.
+                  The method <methodname>quick_erase</methodname> is faster, but has yet
+                  to be standardized.
                </para>
              </notes>
            </method>
@@ -3155,6 +3227,30 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
                <para>In this implementation, this overload doesn't call either function object's methods so it is no throw, but this might not be true in other implementations.</para>
              </throws>
            </method>
+            <method name="quick_erase">
+              <parameter name="position">
+                <paramtype>const_iterator</paramtype>
+              </parameter>
+              <type>void</type>
+              <description>
+                <para>Erase the element pointed to by <code>position</code>.</para>
+              </description>
+              <throws>
+                <para>Only throws an exception if it is thrown by <code>hasher</code> or <code>key_equal</code>.</para>
+                <para>In this implementation, this overload doesn't call either function object's methods so it is no throw, but this might not be true in other implementations.</para>
+              </throws>
+              <notes>
+                <para>
+                  This method is faster than <methodname>erase</methodname> as
+                  it doesn't have to find the next element in the container -
+                  a potentially costly operation.
+                </para>
+                <para>
+                  As it hasn't been standardized, it's likely that this may
+                  change in the future.
+                </para>
+              </notes>
+            </method>
            <method name="erase_return_void">
              <parameter name="position">
                <paramtype>const_iterator</paramtype>
@@ -3169,10 +3265,10 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
              </throws>
              <notes>
                <para>
-                  This is a temporary workaround for the inefficient
-                  <methodname>erase</methodname> method. Hopefully, in a future
-                  version the signature of <methodname>erase</methodname> will
-                  be changed and this will be deprecated.
+                  This method is now deprecated, use
+                  <methodname>quick_return</methodname> instead. Although be
+                  warned that as that isn't standardized yet, it could also
+                  change.
                </para>
              </notes>
            </method>
@@ -31,7 +31,7 @@
 // G = Grouped/Ungrouped
 // E = Key Extractor

-#if defined(BOOST_HAS_RVALUE_REFS) && defined(BOOST_HAS_VARIADIC_TMPL)
+#if !defined(BOOST_NO_RVALUE_REFERENCES) && !defined(BOOST_NO_VARIADIC_TEMPLATES)
 #   if defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION)
        // STLport doesn't have std::forward.
 #   else
@@ -12,6 +12,7 @@
 #include <algorithm>
 #include <boost/config/no_tr1/cmath.hpp>
 #include <boost/iterator/iterator_categories.hpp>
+#include <boost/throw_exception.hpp>

 #include <boost/unordered/detail/buckets.hpp>

@@ -608,15 +609,15 @@ namespace boost { namespace unordered_detail {
        hash_table<T>::at(key_type const& k) const
    {
        if(!this->size_)
-            throw std::out_of_range("Unable to find key in unordered_map.");
+            boost::throw_exception(std::out_of_range("Unable to find key in unordered_map."));

        bucket_ptr bucket = this->get_bucket(this->bucket_index(k));
        node_ptr it = find_iterator(bucket, k);

-        if (BOOST_UNORDERED_BORLAND_BOOL(it))
-            return node::get_value(it);
-        else
-            throw std::out_of_range("Unable to find key in unordered_map.");
+        if (!it)
+            boost::throw_exception(std::out_of_range("Unable to find key in unordered_map."));
+
+        return node::get_value(it);
    }

    // equal_range
@@ -32,12 +32,6 @@ namespace boost { namespace unordered_detail {
    ////////////////////////////////////////////////////////////////////////////
    // primes

-    template<class T> struct prime_list_template
-    {
-        static std::size_t const value[];
-        static std::ptrdiff_t const length;
-    };
-
 #define BOOST_UNORDERED_PRIMES \
    (5ul)(11ul)(17ul)(29ul)(37ul)(53ul)(67ul)(79ul) \
    (97ul)(131ul)(193ul)(257ul)(389ul)(521ul)(769ul) \
@@ -47,14 +41,28 @@ namespace boost { namespace unordered_detail {
    (50331653ul)(100663319ul)(201326611ul)(402653189ul)(805306457ul) \
    (1610612741ul)(3221225473ul)(4294967291ul)

+    template<class T> struct prime_list_template
+    {
+        static std::size_t const value[];
+
+#if !defined(SUNPRO_CC)
+        static std::ptrdiff_t const length;
+#else
+        static std::ptrdiff_t const length
+            = BOOST_PP_SEQ_SIZE(BOOST_UNORDERED_PRIMES);
+#endif
+    };
+
    template<class T>
    std::size_t const prime_list_template<T>::value[] = {
        BOOST_PP_SEQ_ENUM(BOOST_UNORDERED_PRIMES)
    };

+#if !defined(SUNPRO_CC)
    template<class T>
    std::ptrdiff_t const prime_list_template<T>::length
        = BOOST_PP_SEQ_SIZE(BOOST_UNORDERED_PRIMES);
+#endif

 #undef BOOST_UNORDERED_PRIMES

@@ -19,7 +19,7 @@
 #include <boost/unordered/detail/equivalent.hpp>
 #include <boost/unordered/detail/unique.hpp>

-#if !defined(BOOST_HAS_RVALUE_REFS)
+#if defined(BOOST_NO_RVALUE_REFERENCES)
 #include <boost/unordered/detail/move.hpp>
 #endif

@@ -159,7 +159,7 @@ namespace boost

        ~unordered_map() {}

-#if defined(BOOST_HAS_RVALUE_REFS)
+#if !defined(BOOST_NO_RVALUE_REFERENCES)
        unordered_map(unordered_map&& other)
          : table_(other.table_, boost::unordered_detail::move_tag())
        {
@@ -369,6 +369,11 @@ namespace boost
            return iterator(table_.erase_range(get(first), get(last)));
        }

+        void quick_erase(const_iterator position)
+        {
+            table_.erase(get(position));
+        }
+
        void erase_return_void(const_iterator position)
        {
            table_.erase(get(position));
@@ -699,7 +704,7 @@ namespace boost

        ~unordered_multimap() {}

-#if defined(BOOST_HAS_RVALUE_REFS)
+#if !defined(BOOST_NO_RVALUE_REFERENCES)
        unordered_multimap(unordered_multimap&& other)
          : table_(other.table_, boost::unordered_detail::move_tag())
        {
@@ -907,6 +912,11 @@ namespace boost
            return iterator(table_.erase_range(get(first), get(last)));
        }

+        void quick_erase(const_iterator position)
+        {
+            table_.erase(get(position));
+        }
+
        void erase_return_void(const_iterator position)
        {
            table_.erase(get(position));
@@ -19,7 +19,7 @@
 #include <boost/unordered/detail/equivalent.hpp>
 #include <boost/unordered/detail/unique.hpp>

-#if !defined(BOOST_HAS_RVALUE_REFS)
+#if defined(BOOST_NO_RVALUE_REFERENCES)
 #include <boost/unordered/detail/move.hpp>
 #endif

@@ -153,7 +153,7 @@ namespace boost
        
        ~unordered_set() {}

-#if defined(BOOST_HAS_RVALUE_REFS)
+#if !defined(BOOST_NO_RVALUE_REFERENCES)
        unordered_set(unordered_set&& other)
          : table_(other.table_, boost::unordered_detail::move_tag())
        {
@@ -361,6 +361,11 @@ namespace boost
            return iterator(table_.erase_range(get(first), get(last)));
        }

+        void quick_erase(const_iterator position)
+        {
+            table_.erase(get(position));
+        }
+
        void erase_return_void(const_iterator position)
        {
            table_.erase(get(position));
@@ -645,7 +650,7 @@ namespace boost

        ~unordered_multiset() {}

-#if defined(BOOST_HAS_RVALUE_REFS)
+#if !defined(BOOST_NO_RVALUE_REFERENCES)
        unordered_multiset(unordered_multiset&& other)
          : table_(other.table_, boost::unordered_detail::move_tag())
        {
@@ -849,6 +854,11 @@ namespace boost
            return iterator(table_.erase_range(get(first), get(last)));
        }

+        void quick_erase(const_iterator position)
+        {
+            table_.erase(get(position));
+        }
+
        void erase_return_void(const_iterator position)
        {
            table_.erase(get(position));
@@ -39,7 +39,7 @@ struct insert_test_base : public test::exception_base
    }
 };

-#if defined(BOOST_HAS_RVALUE_REFS) && defined(BOOST_HAS_VARIADIC_TMPL)
+#if !defined(BOOST_NO_RVALUE_REFERENCES) && !defined(BOOST_NO_VARIADIC_TEMPLATES)

 template <class T>
 struct emplace_test1 : public insert_test_base<T>
@@ -238,7 +238,7 @@ struct insert_test_rehash3 : public insert_test_base<T>
    (insert_test1)(insert_test2)(insert_test3)(insert_test4) \
    (insert_test_rehash1)(insert_test_rehash2)(insert_test_rehash3)

-#if defined(BOOST_HAS_RVALUE_REFS) && defined(BOOST_HAS_VARIADIC_TMPL)
+#if !defined(BOOST_NO_RVALUE_REFERENCES) && !defined(BOOST_NO_VARIADIC_TEMPLATES)
 #define ALL_TESTS (emplace_test1)BASIC_TESTS
 #else
 #define ALL_TESTS BASIC_TESTS
@@ -116,7 +116,7 @@ void erase_tests1(Container*,
        BOOST_TEST(x.erase(x.begin(), x.end()) == x.begin());
    }

-    std::cerr<<"erase_return_void(begin()).\n";
+    std::cerr<<"quick_erase(begin()).\n";
    {
        test::random_values<Container> v(1000, generator);
        Container x(v.begin(), v.end());
@@ -126,7 +126,7 @@ void erase_tests1(Container*,
            BOOST_DEDUCED_TYPENAME Container::key_type
                key = test::get_key<Container>(*x.begin());
            std::size_t count = x.count(key);
-            x.erase_return_void(x.begin());
+            x.quick_erase(x.begin());
            --size;
            BOOST_TEST(x.count(key) == count - 1);
            BOOST_TEST(x.size() == size);
@@ -134,7 +134,7 @@ void erase_tests1(Container*,
        BOOST_TEST(x.empty());
    }

-    std::cerr<<"erase_return_void(random position).\n";
+    std::cerr<<"quick_erase(random position).\n";
    {
        test::random_values<Container> v(1000, generator);
        Container x(v.begin(), v.end());
@@ -155,7 +155,7 @@ void erase_tests1(Container*,
            BOOST_DEDUCED_TYPENAME Container::key_type
                key = test::get_key<Container>(*pos);
            std::size_t count = x.count(key);
-            x.erase_return_void(pos);
+            x.quick_erase(pos);
            --size;
            if(size > 0)
                BOOST_TEST(index == 0 ? next == x.begin() :
@@ -57,8 +57,7 @@ UNORDERED_AUTO_TEST(use_fwd_declared_trait) {
    boost::unordered_set<int> x;
    BOOST_TEST(sizeof(is_unordered_set_impl(&x)) == sizeof(true_type));

-    int dummy;
-    BOOST_TEST(sizeof(is_unordered_set_impl(&dummy)) == sizeof(false_type));
+    BOOST_TEST(sizeof(is_unordered_set_impl((int*) 0)) == sizeof(false_type));
 }

 UNORDERED_AUTO_TEST(use_set_fwd_declared_function) {
@@ -231,7 +231,7 @@ void insert_tests2(X*,
    }
 }

-#if defined(BOOST_HAS_RVALUE_REFS) && defined(BOOST_HAS_VARIADIC_TMPL)
+#if !defined(BOOST_NO_RVALUE_REFERENCES) && !defined(BOOST_NO_VARIADIC_TEMPLATES)

 template <class X>
 void unique_emplace_tests1(X*,
@@ -403,7 +403,7 @@ UNORDERED_TEST(insert_tests2,
    ((default_generator)(generate_collisions))
 )

-#if defined(BOOST_HAS_RVALUE_REFS) && defined(BOOST_HAS_VARIADIC_TMPL)
+#if !defined(BOOST_NO_RVALUE_REFERENCES) && !defined(BOOST_NO_VARIADIC_TEMPLATES)
 UNORDERED_TEST(unique_emplace_tests1,
    ((test_set)(test_map))
    ((default_generator)(generate_collisions))
@@ -134,7 +134,7 @@ namespace move_tests
        {
            test::random_values<T> v(25, generator);
            T y(create(v, count, hf, eq, al, 1.0), al);
-#if defined(BOOST_HAS_RVALUE_REFS)
+#if !defined(BOOST_NO_RVALUE_REFERENCES)
            BOOST_TEST(count == test::global_object_count);
 #else
            BOOST_TEST(
@@ -31,7 +31,7 @@ namespace unnecessary_copy_tests
            : tag_(x.tag_) { ++copies; }

        count_copies(count_copies const& x) : tag_(x.tag_) { ++copies; }
-#if defined(BOOST_HAS_RVALUE_REFS)
+#if !defined(BOOST_NO_RVALUE_REFERENCES)
        count_copies(count_copies&& x) : tag_(x.tag_) {
            x.tag_ = -1; ++moves;
        }
@@ -136,7 +136,7 @@ namespace unnecessary_copy_tests
        reset();
        T x;
        x.emplace(source<BOOST_DEDUCED_TYPENAME T::value_type>());
-#if defined(BOOST_HAS_RVALUE_REFS) && defined(BOOST_HAS_VARIADIC_TMPL)
+#if !defined(BOOST_NO_RVALUE_REFERENCES) && !defined(BOOST_NO_VARIADIC_TEMPLATES)
        COPY_COUNT(1);
 #else
        COPY_COUNT(2);
@@ -148,7 +148,7 @@ namespace unnecessary_copy_tests
    UNORDERED_TEST(unnecessary_copy_emplace_rvalue_test,
            ((set)(multiset)(map)(multimap)))

-#if defined(BOOST_HAS_RVALUE_REFS) && defined(BOOST_HAS_VARIADIC_TMPL)
+#if !defined(BOOST_NO_RVALUE_REFERENCES) && !defined(BOOST_NO_VARIADIC_TEMPLATES)
    template <class T>
    void unnecessary_copy_emplace_move_test(T*)
    {
@@ -199,7 +199,7 @@ namespace unnecessary_copy_tests
        x.emplace(source<count_copies>());
        COPY_COUNT(1); MOVE_COUNT(0);

-#if defined(BOOST_HAS_RVALUE_REFS)
+#if !defined(BOOST_NO_RVALUE_REFERENCES)
        // No move should take place.
        reset();
        x.emplace(std::move(a));
@@ -271,7 +271,7 @@ namespace unnecessary_copy_tests
        //x.emplace(a_ref);
        //COPY_COUNT(0); MOVE_COUNT(0);

-#if defined(BOOST_HAS_RVALUE_REFS)
+#if !defined(BOOST_NO_RVALUE_REFERENCES)
        // No move should take place.
        // (since a is already in the container)
        reset();
Author	SHA1	Message	Date
Beman Dawes	ef57a35001	Release 1.43.0 beta 1 [SVN r61461]	2010-04-21 14:13:35 +00:00
Daniel James	d3ca85bdbd	Merge throw_exception use in unordered. [SVN r61063]	2010-04-05 08:08:25 +00:00
Daniel James	fe2a6c521b	Merge from trunk. - Add `quick_erase` for unordered. `erase_return_void` is now deprecated. Fixes #3966 - Avoid collision between 0 and 0.5. Fixes #4038 [SVN r60980]	2010-03-31 21:39:07 +00:00
Daniel James	958738c7af	Merge a warning fix for unordered. [SVN r60668]	2010-03-17 00:34:26 +00:00
Daniel James	3fb7d15f5b	Merge hash and unordered from trunk. - Replace uses of deprecated C++0x macros - Set length of primes inside template on Sun C++. Fixes #3854 - Missing newline at end of file. [SVN r59911]	2010-02-25 19:05:01 +00:00