Merge pull request #26 from SylvainCorlay/update-steppers

JohanMabille · web-flow · commit 5547cc25f51d · 2017-02-12T21:37:49.000+01:00
Update iterator types
diff --git a/.appveyor.yml b/.appveyor.yml
@@ -24,7 +24,7 @@ install:
   - conda info -a
   - conda install pytest -c conda-forge
   - cd test
-  - conda install xtensor==0.3.0 pytest numpy pybind11==2.0.0 -c conda-forge
+  - conda install xtensor==0.5.0 pytest numpy pybind11==2.0.1 -c conda-forge
   - xcopy /S %APPVEYOR_BUILD_FOLDER%\include %MINICONDA%\include
 
 build_script:
diff --git a/.travis.yml b/.travis.yml
@@ -59,7 +59,7 @@ install:
     # Useful for debugging any issues with conda
     - conda info -a
     - cd test
-    - conda install xtensor==0.3.0 pytest numpy pybind11==2.0.0 -c conda-forge
+    - conda install xtensor==0.5.0 pytest numpy pybind11==2.0.1 -c conda-forge
     - cp -r $TRAVIS_BUILD_DIR/include/* $HOME/miniconda/include/
 
 script:
diff --git a/README.md b/README.md
@@ -29,7 +29,8 @@ conda install -c conda-forge xtensor-python
 
 | `xtensor-python`  | `xtensor`  |  `pybind11` |
 |-------------------|------------|-------------|
-| master            |  master    | ^2.0.0      |
+| master            |   0.5.0    | ^2.0.0      |
+| 0.3.0             |  ^0.4.1    | ^2.0.0      |
 | 0.2.0             |  ^0.2.1    | ^1.8.1      |
 | 0.1.0             |  ^0.1.1    | ^1.8.1      |
 
diff --git a/include/xtensor-python/pyarray.hpp b/include/xtensor-python/pyarray.hpp
@@ -18,6 +18,7 @@
 #include "xtensor/xexpression.hpp"
 #include "xtensor/xsemantic.hpp"
 #include "xtensor/xiterator.hpp"
+#include "xtensor/xcontainer.hpp"
 
 namespace xt
 {
@@ -110,17 +111,17 @@ namespace xt
         using size_type = std::size_t;
         using difference_type = std::ptrdiff_t;
 
-        using storage_iterator = T*;
-        using const_storage_iterator = const T*;
+        using iterator = T*;
+        using const_iterator = const T*;
 
         using shape_type = std::vector<size_type>;
         using strides_type = std::vector<size_type>;
         using backstrides_type = pyarray_backstrides<self_type>;
         
         using stepper = xstepper<self_type>;
         using const_stepper = xstepper<const self_type>;
-        using iterator = xiterator<stepper, shape_type>;
-        using const_iterator = xiterator<const_stepper, shape_type>;
+        using broadcast_iterator = xiterator<stepper, shape_type*>;
+        using const_broadcast_iterator = xiterator<const_stepper, shape_type*>;
 
         using closure_type = const self_type&;
 
@@ -173,13 +174,13 @@ namespace xt
         template <class S>
         bool is_trivial_broadcast(const S& strides) const;
 
-        iterator begin();
-        iterator end();
+        broadcast_iterator xbegin();
+        broadcast_iterator xend();
 
-        const_iterator begin() const;
-        const_iterator end() const;
-        const_iterator cbegin() const;
-        const_iterator cend() const;
+        const_broadcast_iterator xbegin() const;
+        const_broadcast_iterator xend() const;
+        const_broadcast_iterator cxbegin() const;
+        const_broadcast_iterator cxend() const;
 
         template <class S>
         xiterator<stepper, S> xbegin(const S& shape);
@@ -204,12 +205,12 @@ namespace xt
         template <class S>
         const_stepper stepper_end(const S& shape) const;
 
-        storage_iterator storage_begin();
-        storage_iterator storage_end();
-        const_storage_iterator storage_begin() const;
-        const_storage_iterator storage_end() const;
-        const_storage_iterator storage_cbegin() const;
-        const_storage_iterator storage_cend() const;
+        iterator begin();
+        iterator end();
+        const_iterator begin() const;
+        const_iterator end() const;
+        const_iterator cbegin() const;
+        const_iterator cend() const;
 
         template <class E>
         pyarray(const xexpression<E>& e);
@@ -444,67 +445,67 @@ namespace xt
     }
 
     template <class T, int ExtraFlags>
-    inline auto pyarray<T, ExtraFlags>::begin() -> iterator
+    inline auto pyarray<T, ExtraFlags>::xbegin() -> broadcast_iterator
     {
-        return xbegin(shape());
+        return broadcast_iterator(stepper_begin(m_shape), &m_shape);
     }
 
     template <class T, int ExtraFlags>
-    inline auto pyarray<T, ExtraFlags>::end() -> iterator
+    inline auto pyarray<T, ExtraFlags>::xend() -> broadcast_iterator
     {
-        return xend(shape());
+        return broadcast_iterator(stepper_end(m_shape), &m_shape);
     }
 
     template <class T, int ExtraFlags>
-    inline auto pyarray<T, ExtraFlags>::begin() const -> const_iterator
+    inline auto pyarray<T, ExtraFlags>::xbegin() const -> const_broadcast_iterator
     {
-        return xbegin(shape());
+        return const_broadcast_iterator(stepper_begin(m_shape), &m_shape);
     }
 
     template <class T, int ExtraFlags>
-    inline auto pyarray<T, ExtraFlags>::end() const -> const_iterator
+    inline auto pyarray<T, ExtraFlags>::xend() const -> const_broadcast_iterator
     {
-        return xend(shape());
+        return const_broadcast_iterator(stepper_end(m_shape), &m_shape);
     }
 
     template <class T, int ExtraFlags>
-    inline auto pyarray<T, ExtraFlags>::cbegin() const -> const_iterator
+    inline auto pyarray<T, ExtraFlags>::cxbegin() const -> const_broadcast_iterator
     {
-        return begin();
+        return xbegin();
     }
 
     template <class T, int ExtraFlags>
-    inline auto pyarray<T, ExtraFlags>::cend() const -> const_iterator
+    inline auto pyarray<T, ExtraFlags>::cxend() const -> const_broadcast_iterator
     {
-        return end();
+        return xend();
     }
 
     template <class T, int ExtraFlags>
     template <class S>
     inline auto pyarray<T, ExtraFlags>::xbegin(const S& shape) -> xiterator<stepper, S>
     {
-        return xiterator<stepper, S>(stepper_begin(shape), shape);
+        return xiterator<stepper, S>(stepper_begin(shape), &shape);
     }
 
     template <class T, int ExtraFlags>
     template <class S>
     inline auto pyarray<T, ExtraFlags>::xend(const S& shape) -> xiterator<stepper, S>
     {
-        return xiterator<stepper, S>(stepper_end(shape), shape);
+        return xiterator<stepper, S>(stepper_end(shape), &shape);
     }
 
     template <class T, int ExtraFlags>
     template <class S>
     inline auto pyarray<T, ExtraFlags>::xbegin(const S& shape) const -> xiterator<const_stepper, S>
     {
-        return xiterator<const_stepper, S>(stepper_begin(shape), shape);
+        return xiterator<const_stepper, S>(stepper_begin(shape), &shape);
     }
 
     template <class T, int ExtraFlags>
     template <class S>
     inline auto pyarray<T, ExtraFlags>::xend(const S& shape) const -> xiterator<const_stepper, S>
     {
-        return xiterator<const_stepper, S>(stepper_end(shape), shape);
+        return xiterator<const_stepper, S>(stepper_end(shape), &shape);
     }
 
     template <class T, int ExtraFlags>
@@ -526,67 +527,67 @@ namespace xt
     inline auto pyarray<T, ExtraFlags>::stepper_begin(const S& shape) -> stepper
     {
         size_type offset = shape.size() - dimension();
-        return stepper(this, storage_begin(), offset);
+        return stepper(this, begin(), offset);
     }
 
     template <class T, int ExtraFlags>
     template <class S>
     inline auto pyarray<T, ExtraFlags>::stepper_end(const S& shape) -> stepper
     {
         size_type offset = shape.size() - dimension();
-        return stepper(this, storage_end(), offset);
+        return stepper(this, end(), offset);
     }
 
     template <class T, int ExtraFlags>
     template <class S>
     inline auto pyarray<T, ExtraFlags>::stepper_begin(const S& shape) const -> const_stepper
     {
         size_type offset = shape.size() - dimension();
-        return const_stepper(this, storage_begin(), offset);
+        return const_stepper(this, begin(), offset);
     }
 
     template <class T, int ExtraFlags>
     template <class S>
     inline auto pyarray<T, ExtraFlags>::stepper_end(const S& shape) const -> const_stepper
     {
         size_type offset = shape.size() - dimension();
-        return const_stepper(this, storage_end(), offset);
+        return const_stepper(this, end(), offset);
     }
 
     template <class T, int ExtraFlags>
-    inline auto pyarray<T, ExtraFlags>::storage_begin() -> storage_iterator
+    inline auto pyarray<T, ExtraFlags>::begin() -> iterator
     {
-        return reinterpret_cast<storage_iterator>(pybind11::detail::array_proxy(m_ptr)->data);
+        return reinterpret_cast<iterator>(pybind11::detail::array_proxy(m_ptr)->data);
     }
 
     template <class T, int ExtraFlags>
-    inline auto pyarray<T, ExtraFlags>::storage_end() -> storage_iterator
+    inline auto pyarray<T, ExtraFlags>::end() -> iterator
     {
-        return storage_begin() + pybind_array::size();
+        return begin() + pybind_array::size();
     }
 
     template <class T, int ExtraFlags>
-    inline auto pyarray<T, ExtraFlags>::storage_begin() const -> const_storage_iterator
+    inline auto pyarray<T, ExtraFlags>::begin() const -> const_iterator
     {
-        return reinterpret_cast<const_storage_iterator>(pybind11::detail::array_proxy(m_ptr)->data);
+        return reinterpret_cast<const_iterator>(pybind11::detail::array_proxy(m_ptr)->data);
     }
 
     template <class T, int ExtraFlags>
-    inline auto pyarray<T, ExtraFlags>::storage_end() const -> const_storage_iterator
+    inline auto pyarray<T, ExtraFlags>::end() const -> const_iterator
     {
-        return storage_begin() + pybind_array::size();
+        return begin() + pybind_array::size();
     }
 
     template <class T, int ExtraFlags>
-    inline auto pyarray<T, ExtraFlags>::storage_cbegin() const -> const_storage_iterator
+    inline auto pyarray<T, ExtraFlags>::cbegin() const -> const_iterator
     {
-        return reinterpret_cast<const_storage_iterator>(pybind11::detail::array_proxy(m_ptr)->data);
+        return reinterpret_cast<const_iterator>(pybind11::detail::array_proxy(m_ptr)->data);
     }
 
     template <class T, int ExtraFlags>
-    inline auto pyarray<T, ExtraFlags>::storage_cend() const -> const_storage_iterator
+    inline auto pyarray<T, ExtraFlags>::cend() const -> const_iterator
     {
-        return storage_begin() + pybind_array::size();
+        return begin() + pybind_array::size();
     }
 
     template <class T, int ExtraFlags>
diff --git a/test/setup.py b/test/setup.py
@@ -30,7 +30,8 @@ def __str__(self):
             # Path to pybind11 headers
             get_pybind_include(),
             get_pybind_include(user=True),
-            os.path.join(sys.prefix, 'include')
+            os.path.join(sys.prefix, 'include'),
+            os.path.join(sys.prefix, 'Library', 'include')
         ],
         language='c++'
     ),

Original file line number	Diff line number	Diff line change
`@@ -18,6 +18,7 @@`
`18`	`18`	`#include "xtensor/xexpression.hpp"`
`19`	`19`	`#include "xtensor/xsemantic.hpp"`
`20`	`20`	`#include "xtensor/xiterator.hpp"`
	`21`	`+#include "xtensor/xcontainer.hpp"`
`21`	`22`
`22`	`23`	`namespace xt`
`23`	`24`	`{`
`@@ -110,17 +111,17 @@ namespace xt`
`110`	`111`	`using size_type = std::size_t;`
`111`	`112`	`using difference_type = std::ptrdiff_t;`
`112`	`113`
`113`		`- using storage_iterator = T*;`
`114`		`- using const_storage_iterator = const T*;`
	`114`	`+ using iterator = T*;`
	`115`	`+ using const_iterator = const T*;`
`115`	`116`
`116`	`117`	`using shape_type = std::vector<size_type>;`
`117`	`118`	`using strides_type = std::vector<size_type>;`
`118`	`119`	`using backstrides_type = pyarray_backstrides<self_type>;`
`119`	`120`
`120`	`121`	`using stepper = xstepper<self_type>;`
`121`	`122`	`using const_stepper = xstepper<const self_type>;`
`122`		`- using iterator = xiterator<stepper, shape_type>;`
`123`		`- using const_iterator = xiterator<const_stepper, shape_type>;`
	`123`	`+ using broadcast_iterator = xiterator<stepper, shape_type*>;`
	`124`	`+ using const_broadcast_iterator = xiterator<const_stepper, shape_type*>;`
`124`	`125`
`125`	`126`	`using closure_type = const self_type&;`
`126`	`127`
`@@ -173,13 +174,13 @@ namespace xt`
`173`	`174`	`template <class S>`
`174`	`175`	`bool is_trivial_broadcast(const S& strides) const;`
`175`	`176`
`176`		`- iterator begin();`
`177`		`- iterator end();`
	`177`	`+ broadcast_iterator xbegin();`
	`178`	`+ broadcast_iterator xend();`
`178`	`179`
`179`		`- const_iterator begin() const;`
`180`		`- const_iterator end() const;`
`181`		`- const_iterator cbegin() const;`
`182`		`- const_iterator cend() const;`
	`180`	`+ const_broadcast_iterator xbegin() const;`
	`181`	`+ const_broadcast_iterator xend() const;`
	`182`	`+ const_broadcast_iterator cxbegin() const;`
	`183`	`+ const_broadcast_iterator cxend() const;`
`183`	`184`
`184`	`185`	`template <class S>`
`185`	`186`	`xiterator<stepper, S> xbegin(const S& shape);`
`@@ -204,12 +205,12 @@ namespace xt`
`204`	`205`	`template <class S>`
`205`	`206`	`const_stepper stepper_end(const S& shape) const;`
`206`	`207`
`207`		`- storage_iterator storage_begin();`
`208`		`- storage_iterator storage_end();`
`209`		`- const_storage_iterator storage_begin() const;`
`210`		`- const_storage_iterator storage_end() const;`
`211`		`- const_storage_iterator storage_cbegin() const;`
`212`		`- const_storage_iterator storage_cend() const;`
	`208`	`+ iterator begin();`
	`209`	`+ iterator end();`
	`210`	`+ const_iterator begin() const;`
	`211`	`+ const_iterator end() const;`
	`212`	`+ const_iterator cbegin() const;`
	`213`	`+ const_iterator cend() const;`
`213`	`214`
`214`	`215`	`template <class E>`
`215`	`216`	`pyarray(const xexpression<E>& e);`
`@@ -444,67 +445,67 @@ namespace xt`
`444`	`445`	`}`
`445`	`446`
`446`	`447`	`template <class T, int ExtraFlags>`
`447`		`- inline auto pyarray<T, ExtraFlags>::begin() -> iterator`
	`448`	`+ inline auto pyarray<T, ExtraFlags>::xbegin() -> broadcast_iterator`
`448`	`449`	`{`
`449`		`- return xbegin(shape());`
	`450`	`+ return broadcast_iterator(stepper_begin(m_shape), &m_shape);`
`450`	`451`	`}`
`451`	`452`
`452`	`453`	`template <class T, int ExtraFlags>`
`453`		`- inline auto pyarray<T, ExtraFlags>::end() -> iterator`
	`454`	`+ inline auto pyarray<T, ExtraFlags>::xend() -> broadcast_iterator`
`454`	`455`	`{`
`455`		`- return xend(shape());`
	`456`	`+ return broadcast_iterator(stepper_end(m_shape), &m_shape);`
`456`	`457`	`}`
`457`	`458`
`458`	`459`	`template <class T, int ExtraFlags>`
`459`		`- inline auto pyarray<T, ExtraFlags>::begin() const -> const_iterator`
	`460`	`+ inline auto pyarray<T, ExtraFlags>::xbegin() const -> const_broadcast_iterator`
`460`	`461`	`{`
`461`		`- return xbegin(shape());`
	`462`	`+ return const_broadcast_iterator(stepper_begin(m_shape), &m_shape);`
`462`	`463`	`}`
`463`	`464`
`464`	`465`	`template <class T, int ExtraFlags>`
`465`		`- inline auto pyarray<T, ExtraFlags>::end() const -> const_iterator`
	`466`	`+ inline auto pyarray<T, ExtraFlags>::xend() const -> const_broadcast_iterator`
`466`	`467`	`{`
`467`		`- return xend(shape());`
	`468`	`+ return const_broadcast_iterator(stepper_end(m_shape), &m_shape);`
`468`	`469`	`}`
`469`	`470`
`470`	`471`	`template <class T, int ExtraFlags>`
`471`		`- inline auto pyarray<T, ExtraFlags>::cbegin() const -> const_iterator`
	`472`	`+ inline auto pyarray<T, ExtraFlags>::cxbegin() const -> const_broadcast_iterator`
`472`	`473`	`{`
`473`		`- return begin();`
	`474`	`+ return xbegin();`
`474`	`475`	`}`
`475`	`476`
`476`	`477`	`template <class T, int ExtraFlags>`
`477`		`- inline auto pyarray<T, ExtraFlags>::cend() const -> const_iterator`
	`478`	`+ inline auto pyarray<T, ExtraFlags>::cxend() const -> const_broadcast_iterator`
`478`	`479`	`{`
`479`		`- return end();`
	`480`	`+ return xend();`
`480`	`481`	`}`
`481`	`482`
`482`	`483`	`template <class T, int ExtraFlags>`
`483`	`484`	`template <class S>`
`484`	`485`	`inline auto pyarray<T, ExtraFlags>::xbegin(const S& shape) -> xiterator<stepper, S>`
`485`	`486`	`{`
`486`		`- return xiterator<stepper, S>(stepper_begin(shape), shape);`
	`487`	`+ return xiterator<stepper, S>(stepper_begin(shape), &shape);`
`487`	`488`	`}`
`488`	`489`
`489`	`490`	`template <class T, int ExtraFlags>`
`490`	`491`	`template <class S>`
`491`	`492`	`inline auto pyarray<T, ExtraFlags>::xend(const S& shape) -> xiterator<stepper, S>`
`492`	`493`	`{`
`493`		`- return xiterator<stepper, S>(stepper_end(shape), shape);`
	`494`	`+ return xiterator<stepper, S>(stepper_end(shape), &shape);`
`494`	`495`	`}`
`495`	`496`
`496`	`497`	`template <class T, int ExtraFlags>`
`497`	`498`	`template <class S>`
`498`	`499`	`inline auto pyarray<T, ExtraFlags>::xbegin(const S& shape) const -> xiterator<const_stepper, S>`
`499`	`500`	`{`
`500`		`- return xiterator<const_stepper, S>(stepper_begin(shape), shape);`
	`501`	`+ return xiterator<const_stepper, S>(stepper_begin(shape), &shape);`
`501`	`502`	`}`
`502`	`503`
`503`	`504`	`template <class T, int ExtraFlags>`
`504`	`505`	`template <class S>`
`505`	`506`	`inline auto pyarray<T, ExtraFlags>::xend(const S& shape) const -> xiterator<const_stepper, S>`
`506`	`507`	`{`
`507`		`- return xiterator<const_stepper, S>(stepper_end(shape), shape);`
	`508`	`+ return xiterator<const_stepper, S>(stepper_end(shape), &shape);`
`508`	`509`	`}`
`509`	`510`
`510`	`511`	`template <class T, int ExtraFlags>`
`@@ -526,67 +527,67 @@ namespace xt`
`526`	`527`	`inline auto pyarray<T, ExtraFlags>::stepper_begin(const S& shape) -> stepper`
`527`	`528`	`{`
`528`	`529`	`size_type offset = shape.size() - dimension();`
`529`		`- return stepper(this, storage_begin(), offset);`
	`530`	`+ return stepper(this, begin(), offset);`
`530`	`531`	`}`
`531`	`532`
`532`	`533`	`template <class T, int ExtraFlags>`
`533`	`534`	`template <class S>`
`534`	`535`	`inline auto pyarray<T, ExtraFlags>::stepper_end(const S& shape) -> stepper`
`535`	`536`	`{`
`536`	`537`	`size_type offset = shape.size() - dimension();`
`537`		`- return stepper(this, storage_end(), offset);`
	`538`	`+ return stepper(this, end(), offset);`
`538`	`539`	`}`
`539`	`540`
`540`	`541`	`template <class T, int ExtraFlags>`
`541`	`542`	`template <class S>`
`542`	`543`	`inline auto pyarray<T, ExtraFlags>::stepper_begin(const S& shape) const -> const_stepper`
`543`	`544`	`{`
`544`	`545`	`size_type offset = shape.size() - dimension();`
`545`		`- return const_stepper(this, storage_begin(), offset);`
	`546`	`+ return const_stepper(this, begin(), offset);`
`546`	`547`	`}`
`547`	`548`
`548`	`549`	`template <class T, int ExtraFlags>`
`549`	`550`	`template <class S>`
`550`	`551`	`inline auto pyarray<T, ExtraFlags>::stepper_end(const S& shape) const -> const_stepper`
`551`	`552`	`{`
`552`	`553`	`size_type offset = shape.size() - dimension();`
`553`		`- return const_stepper(this, storage_end(), offset);`
	`554`	`+ return const_stepper(this, end(), offset);`
`554`	`555`	`}`
`555`	`556`
`556`	`557`	`template <class T, int ExtraFlags>`
`557`		`- inline auto pyarray<T, ExtraFlags>::storage_begin() -> storage_iterator`
	`558`	`+ inline auto pyarray<T, ExtraFlags>::begin() -> iterator`
`558`	`559`	`{`
`559`		`- return reinterpret_cast<storage_iterator>(pybind11::detail::array_proxy(m_ptr)->data);`
	`560`	`+ return reinterpret_cast<iterator>(pybind11::detail::array_proxy(m_ptr)->data);`
`560`	`561`	`}`
`561`	`562`
`562`	`563`	`template <class T, int ExtraFlags>`
`563`		`- inline auto pyarray<T, ExtraFlags>::storage_end() -> storage_iterator`
	`564`	`+ inline auto pyarray<T, ExtraFlags>::end() -> iterator`
`564`	`565`	`{`
`565`		`- return storage_begin() + pybind_array::size();`
	`566`	`+ return begin() + pybind_array::size();`
`566`	`567`	`}`
`567`	`568`
`568`	`569`	`template <class T, int ExtraFlags>`
`569`		`- inline auto pyarray<T, ExtraFlags>::storage_begin() const -> const_storage_iterator`
	`570`	`+ inline auto pyarray<T, ExtraFlags>::begin() const -> const_iterator`
`570`	`571`	`{`
`571`		`- return reinterpret_cast<const_storage_iterator>(pybind11::detail::array_proxy(m_ptr)->data);`
	`572`	`+ return reinterpret_cast<const_iterator>(pybind11::detail::array_proxy(m_ptr)->data);`
`572`	`573`	`}`
`573`	`574`
`574`	`575`	`template <class T, int ExtraFlags>`
`575`		`- inline auto pyarray<T, ExtraFlags>::storage_end() const -> const_storage_iterator`
	`576`	`+ inline auto pyarray<T, ExtraFlags>::end() const -> const_iterator`
`576`	`577`	`{`
`577`		`- return storage_begin() + pybind_array::size();`
	`578`	`+ return begin() + pybind_array::size();`
`578`	`579`	`}`
`579`	`580`
`580`	`581`	`template <class T, int ExtraFlags>`
`581`		`- inline auto pyarray<T, ExtraFlags>::storage_cbegin() const -> const_storage_iterator`
	`582`	`+ inline auto pyarray<T, ExtraFlags>::cbegin() const -> const_iterator`
`582`	`583`	`{`
`583`		`- return reinterpret_cast<const_storage_iterator>(pybind11::detail::array_proxy(m_ptr)->data);`
	`584`	`+ return reinterpret_cast<const_iterator>(pybind11::detail::array_proxy(m_ptr)->data);`
`584`	`585`	`}`
`585`	`586`
`586`	`587`	`template <class T, int ExtraFlags>`
`587`		`- inline auto pyarray<T, ExtraFlags>::storage_cend() const -> const_storage_iterator`
	`588`	`+ inline auto pyarray<T, ExtraFlags>::cend() const -> const_iterator`
`588`	`589`	`{`
`589`		`- return storage_begin() + pybind_array::size();`
	`590`	`+ return begin() + pybind_array::size();`
`590`	`591`	`}`
`591`	`592`
`592`	`593`	`template <class T, int ExtraFlags>`