[string] Add a conversion from a Constant holding a char const*

Closes #347

Author: ldionne

example/string/from_c_str.cpp

@@ -0,0 +1,20 @@
+// Copyright Louis Dionne 2013-2017
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
+
+#include <boost/hana/assert.hpp>
+#include <boost/hana/core/to.hpp>
+#include <boost/hana/equal.hpp>
+#include <boost/hana/integral_constant.hpp>
+#include <boost/hana/string.hpp>
+namespace hana = boost::hana;
+
+
+constexpr char const hello[] = "hello";
+auto hello_constant = hana::integral_constant<char const*, hello>{};
+
+BOOST_HANA_CONSTANT_CHECK(
+    hana::to_string(hello_constant) == hana::string_c<'h', 'e', 'l', 'l', 'o'>
+);
+
+int main() { }

include/boost/hana/fwd/string.hpp

@@ -12,6 +12,7 @@ Distributed under the Boost Software License, Version 1.0.
 
 #include <boost/hana/config.hpp>
 #include <boost/hana/fwd/core/make.hpp>
+#include <boost/hana/fwd/core/to.hpp>
 
 
 BOOST_HANA_NAMESPACE_BEGIN
@@ -94,16 +95,23 @@ BOOST_HANA_NAMESPACE_BEGIN
     //! concepts as `hana::string` does.
     //! @include example/string/to.cpp
     //!
+    //! Conversion from any Constant holding a `char const*`
+    //! ----------------------------------------------------
+    //! A `hana::string` can be created from any `Constant` whose underlying
+    //! value is convertible to a `char const*` by using `hana::to`. The
+    //! contents of the `char const*` are used to build the content of the
+    //! `hana::string`.
+    //! @include example/string/from_c_str.cpp
     //!
-    //! > #### Rationale for `hana::string` not being a `Constant`
-    //! > The underlying type held by a `hana::string` could be either
-    //! > `char const*` or some other constexpr-enabled string-like container.
-    //! > In the first case, `hana::string` can not be a `Constant` because
-    //! > the models of several concepts would not be respected by the
-    //! > underlying type, causing `value` not to be structure-preserving.
-    //! > Providing an underlying value of constexpr-enabled string-like
-    //! > container type like `std::string_view` would be great, but that's
-    //! > a bit complicated for the time being.
+    //! Rationale for `hana::string` not being a `Constant` itself
+    //! ----------------------------------------------------------
+    //! The underlying type held by a `hana::string` could be either `char const*`
+    //! or some other constexpr-enabled string-like container. In the first case,
+    //! `hana::string` can not be a `Constant` because the models of several
+    //! concepts would not be respected by the underlying type, causing `value`
+    //! not to be structure-preserving. Providing an underlying value of
+    //! constexpr-enabled string-like container type like `std::string_view`
+    //! would be great, but that's a bit complicated for the time being.
     template <typename implementation_defined>
     struct string {
         // Default-construct a `hana::string`; no-op since `hana::string` is stateless.
@@ -180,6 +188,10 @@ BOOST_HANA_NAMESPACE_BEGIN
     //! @relates hana::string
     constexpr auto make_string = make<string_tag>;
 
+    //! Equivalent to `to<string_tag>`; provided for convenience.
+    //! @relates hana::string
+    constexpr auto to_string = to<string_tag>;
+
     //! Create a compile-time string from a parameter pack of characters.
     //! @relates hana::string
     //!

include/boost/hana/string.hpp

@@ -13,6 +13,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/hana/fwd/string.hpp>
 
 #include <boost/hana/bool.hpp>
+#include <boost/hana/concept/constant.hpp>
 #include <boost/hana/config.hpp>
 #include <boost/hana/core/make.hpp>
 #include <boost/hana/detail/algorithm.hpp>
@@ -147,6 +148,35 @@ BOOST_HANA_NAMESPACE_BEGIN
         { return string<c...>::c_str(); }
     };
 
+    //////////////////////////////////////////////////////////////////////////
+    // to<string_tag>
+    //////////////////////////////////////////////////////////////////////////
+    namespace detail {
+        constexpr std::size_t cx_strlen(char const* s) {
+          std::size_t n = 0u;
+          while (*s != '\0')
+            ++s, ++n;
+          return n;
+        }
+
+        template <typename S, std::size_t ...I>
+        constexpr hana::string<hana::value<S>()[I]...> expand(std::index_sequence<I...>)
+        { return {}; }
+    }
+
+    template <typename IC>
+    struct to_impl<hana::string_tag, IC, hana::when<
+        hana::Constant<IC>::value &&
+        std::is_convertible<typename IC::value_type, char const*>::value
+    >> {
+        template <typename S>
+        static constexpr auto apply(S const&) {
+            constexpr char const* s = hana::value<S>();
+            constexpr std::size_t len = detail::cx_strlen(s);
+            return detail::expand<S>(std::make_index_sequence<len>{});
+        }
+    };
+
     //////////////////////////////////////////////////////////////////////////
     // Comparable
     //////////////////////////////////////////////////////////////////////////

test/string/cnstr.c_str.cpp

@@ -0,0 +1,59 @@
+// Copyright Louis Dionne 2013-2017
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
+
+#include <boost/hana/assert.hpp>
+#include <boost/hana/core/to.hpp>
+#include <boost/hana/equal.hpp>
+#include <boost/hana/ext/std/integral_constant.hpp>
+#include <boost/hana/integral_constant.hpp>
+#include <boost/hana/string.hpp>
+
+#include <type_traits>
+namespace hana = boost::hana;
+
+
+constexpr char const empty[] = "";
+constexpr char const a[] = "a";
+constexpr char const ab[] = "ab";
+constexpr char const abc[] = "abc";
+constexpr char const abcd[] = "abcd";
+
+int main() {
+    {
+        auto string = hana::to<hana::string_tag>(hana::integral_constant<char const*, empty>{});
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(string, hana::string_c<>));
+    }
+
+    {
+        auto string = hana::to<hana::string_tag>(hana::integral_constant<char const*, a>{});
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(string, hana::string_c<'a'>));
+    }
+
+    {
+        auto string = hana::to<hana::string_tag>(hana::integral_constant<char const*, ab>{});
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(string, hana::string_c<'a', 'b'>));
+    }
+
+    {
+        auto string = hana::to<hana::string_tag>(hana::integral_constant<char const*, abc>{});
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(string, hana::string_c<'a', 'b', 'c'>));
+    }
+
+    {
+        auto string = hana::to<hana::string_tag>(hana::integral_constant<char const*, abcd>{});
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(string, hana::string_c<'a', 'b', 'c', 'd'>));
+    }
+
+    // Make sure it also works with std::integral_constant, for example
+    {
+        auto string = hana::to<hana::string_tag>(std::integral_constant<char const*, abcd>{});
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(string, hana::string_c<'a', 'b', 'c', 'd'>));
+    }
+
+    // Make sure the `to_string` shortcut works
+    {
+        auto string = hana::to_string(hana::integral_constant<char const*, abcd>{});
+        BOOST_HANA_CONSTANT_CHECK(hana::equal(string, hana::string_c<'a', 'b', 'c', 'd'>));
+    }
+}