← Back
Editing: construct.hpp
/*============================================================================= Copyright (c) 2015 Paul Fultz II construct.h 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 BOOST_HOF_GUARD_CONSTRUCT_H #define BOOST_HOF_GUARD_CONSTRUCT_H /// construct /// ========= /// /// Description /// ----------- /// /// The `construct` function returns a function object that will construct the /// object when the called. A template can also be given, which it will deduce /// the parameters to the template. The `construct_meta` can be used to /// construct the object from a metafunction. /// /// Synopsis /// -------- /// /// // Construct by decaying each value /// template<class T> /// constexpr auto construct(); /// /// template<template<class...> class Template> /// constexpr auto construct(); /// /// // Construct by deducing lvalues by reference and rvalue reference by reference /// template<class T> /// constexpr auto construct_forward(); /// /// template<template<class...> class Template> /// constexpr auto construct_forward(); /// /// // Construct by deducing lvalues by reference and rvalues by value. /// template<class T> /// constexpr auto construct_basic(); /// /// template<template<class...> class Template> /// constexpr auto construct_basic(); /// /// // Construct by deducing the object from a metafunction /// template<class MetafunctionClass> /// constexpr auto construct_meta(); /// /// template<template<class...> class MetafunctionTemplate> /// constexpr auto construct_meta(); /// /// Semantics /// --------- /// /// assert(construct<T>()(xs...) == T(xs...)); /// assert(construct<Template>()(xs...) == Template<decltype(xs)...>(xs...)); /// assert(construct_meta<MetafunctionClass>()(xs...) == MetafunctionClass::apply<decltype(xs)...>(xs...)); /// assert(construct_meta<MetafunctionTemplate>()(xs...) == MetafunctionTemplate<decltype(xs)...>::type(xs...)); /// /// Requirements /// ------------ /// /// MetafunctionClass must be a: /// /// * [MetafunctionClass](MetafunctionClass) /// /// MetafunctionTemplate<Ts...> must be a: /// /// * [Metafunction](Metafunction) /// /// T, Template<Ts..>, MetafunctionClass::apply<Ts...>, and /// MetafunctionTemplate<Ts...>::type must be: /// /// * MoveConstructible /// /// Example /// ------- /// /// #include <boost/hof.hpp> /// #include <cassert> /// #include <vector> /// /// int main() { /// auto v = boost::hof::construct<std::vector<int>>()(5, 5); /// assert(v.size() == 5); /// } /// #include <boost/hof/detail/forward.hpp> #include <boost/hof/detail/move.hpp> #include <boost/hof/detail/delegate.hpp> #include <boost/hof/detail/join.hpp> #include <boost/hof/detail/remove_rvalue_reference.hpp> #include <boost/hof/decay.hpp> #include <initializer_list> namespace boost { namespace hof { namespace detail { template<class T, class=void> struct construct_f { typedef typename std::aligned_storage<sizeof(T)>::type storage; struct storage_holder { storage * s; storage_holder(storage* x) noexcept : s(x) {} T& data() noexcept { return *reinterpret_cast<T*>(s); } ~storage_holder() noexcept(noexcept(std::declval<T>().~T())) { this->data().~T(); } }; constexpr construct_f() noexcept {} template<class... Ts, BOOST_HOF_ENABLE_IF_CONSTRUCTIBLE(T, Ts...)> T operator()(Ts&&... xs) const BOOST_HOF_NOEXCEPT_CONSTRUCTIBLE(T, Ts&&...) { storage buffer{}; new(&buffer) T(BOOST_HOF_FORWARD(Ts)(xs)...); storage_holder h(&buffer); return boost::hof::move(h.data()); } template<class X, BOOST_HOF_ENABLE_IF_CONSTRUCTIBLE(T, std::initializer_list<X>&&)> T operator()(std::initializer_list<X>&& x) const BOOST_HOF_NOEXCEPT_CONSTRUCTIBLE(T, std::initializer_list<X>&&) { storage buffer{}; new(&buffer) T(static_cast<std::initializer_list<X>&&>(x)); storage_holder h(&buffer); return h.data(); } template<class X, BOOST_HOF_ENABLE_IF_CONSTRUCTIBLE(T, std::initializer_list<X>&)> T operator()(std::initializer_list<X>& x) const BOOST_HOF_NOEXCEPT_CONSTRUCTIBLE(T, std::initializer_list<X>&) { storage buffer{}; new(&buffer) T(x); storage_holder h(&buffer); return h.data(); } template<class X, BOOST_HOF_ENABLE_IF_CONSTRUCTIBLE(T, const std::initializer_list<X>&)> T operator()(const std::initializer_list<X>& x) const BOOST_HOF_NOEXCEPT_CONSTRUCTIBLE(T, const std::initializer_list<X>&) { storage buffer{}; new(&buffer) T(x); storage_holder h(&buffer); return h.data(); } }; template<class T> struct construct_f<T, typename std::enable_if<BOOST_HOF_IS_LITERAL(T)>::type> { constexpr construct_f() noexcept {} template<class... Ts, BOOST_HOF_ENABLE_IF_CONSTRUCTIBLE(T, Ts...)> constexpr T operator()(Ts&&... xs) const noexcept { return T(BOOST_HOF_FORWARD(Ts)(xs)...); } template<class X, BOOST_HOF_ENABLE_IF_CONSTRUCTIBLE(T, std::initializer_list<X>&&)> constexpr T operator()(std::initializer_list<X>&& x) const noexcept { return T(static_cast<std::initializer_list<X>&&>(x)); } template<class X, BOOST_HOF_ENABLE_IF_CONSTRUCTIBLE(T, std::initializer_list<X>&)> constexpr T operator()(std::initializer_list<X>& x) const noexcept { return T(x); } template<class X, BOOST_HOF_ENABLE_IF_CONSTRUCTIBLE(T, const std::initializer_list<X>&)> constexpr T operator()(const std::initializer_list<X>& x) const noexcept { return T(x); } }; template<template<class...> class Template, template<class...> class D> struct construct_template_f { constexpr construct_template_f() noexcept {} template<class... Ts, class Result=BOOST_HOF_JOIN(Template, typename D<Ts>::type...), BOOST_HOF_ENABLE_IF_CONSTRUCTIBLE(Result, Ts...)> constexpr Result operator()(Ts&&... xs) const BOOST_HOF_NOEXCEPT_CONSTRUCTIBLE(Result, Ts&&...) { return construct_f<Result>()(BOOST_HOF_FORWARD(Ts)(xs)...); } }; template<class MetafunctionClass> struct construct_meta_f { constexpr construct_meta_f() noexcept {} template<class... Ts> struct apply : MetafunctionClass::template apply<Ts...> {}; template<class... Ts, class Metafunction=BOOST_HOF_JOIN(apply, Ts...), class Result=typename Metafunction::type, BOOST_HOF_ENABLE_IF_CONSTRUCTIBLE(Result, Ts...)> constexpr Result operator()(Ts&&... xs) const BOOST_HOF_NOEXCEPT_CONSTRUCTIBLE(Result, Ts&&...) { return construct_f<Result>()(BOOST_HOF_FORWARD(Ts)(xs)...); } }; template<template<class...> class MetafunctionTemplate> struct construct_meta_template_f { constexpr construct_meta_template_f() noexcept {} template<class... Ts, class Metafunction=BOOST_HOF_JOIN(MetafunctionTemplate, Ts...), class Result=typename Metafunction::type, BOOST_HOF_ENABLE_IF_CONSTRUCTIBLE(Result, Ts...)> constexpr Result operator()(Ts&&... xs) const BOOST_HOF_NOEXCEPT_CONSTRUCTIBLE(Result, Ts&&...) { return construct_f<Result>()(BOOST_HOF_FORWARD(Ts)(xs)...); } }; template<class T> struct construct_id { typedef T type; }; } template<class T> constexpr detail::construct_f<T> construct() noexcept { return {}; } // These overloads are provide for consistency template<class T> constexpr detail::construct_f<T> construct_forward() noexcept { return {}; } template<class T> constexpr detail::construct_f<T> construct_basic() noexcept { return {}; } template<template<class...> class Template> constexpr detail::construct_template_f<Template, detail::decay_mf> construct() noexcept { return {}; } template<template<class...> class Template> constexpr detail::construct_template_f<Template, detail::construct_id> construct_forward() noexcept { return {}; } template<template<class...> class Template> constexpr detail::construct_template_f<Template, detail::remove_rvalue_reference> construct_basic() noexcept { return {}; } template<class T> constexpr detail::construct_meta_f<T> construct_meta() noexcept { return {}; } template<template<class...> class Template> constexpr detail::construct_meta_template_f<Template> construct_meta() noexcept { return {}; } }} // namespace boost::hof #endif
Save File
Cancel