bslmf_addrvaluereference.h

Go to the documentation of this file.

/// @file bslmf_addrvaluereference.h
///
/// The content of this file has been pre-processed for Doxygen.
///
 
 
// bslmf_addrvaluereference.h                                         -*-C++-*-
#ifndef INCLUDED_BSLMF_ADDRVALUEREFERENCE
#define INCLUDED_BSLMF_ADDRVALUEREFERENCE
 
#include <bsls_ident.h>
BSLS_IDENT("$Id: $")
 
/// @defgroup bslmf_addrvaluereference bslmf_addrvaluereference
/// @brief  Provide a compile-time type transformation to rvalue reference.
/// @addtogroup bsl
/// @{
/// @addtogroup bslmf
/// @{
/// @addtogroup bslmf_addrvaluereference
/// @{
///
/// <h1> Outline </h1>
/// * <a href="#bslmf_addrvaluereference-purpose"> Purpose</a>
/// * <a href="#bslmf_addrvaluereference-classes"> Classes </a>
/// * <a href="#bslmf_addrvaluereference-description"> Description </a>
///   * <a href="#bslmf_addrvaluereference-usage"> Usage </a>
///     * <a href="#bslmf_addrvaluereference-example-1-transform-to-rvalue-reference-types"> Example 1: Transform to Rvalue Reference Types </a>
///
/// # Purpose {#bslmf_addrvaluereference-purpose}
/// Provide a compile-time type transformation to rvalue reference.
///
/// # Classes {#bslmf_addrvaluereference-classes}
///
/// -  bsl::add_rvalue_reference: standard meta-function for transforming types
/// -  bsl::add_rvalue_reference_t: alias to the return type of the meta-function
///
/// @see  bslmf_integralconstant, bslmf_addlvaluereference
///
/// # Description {#bslmf_addrvaluereference-description}
/// This component defines a meta-function,
/// `bsl::add_rvalue_reference`, that may be used to transform a type to its
/// rvalue reference type.
///
/// `bsl::add_rvalue_reference` and `bsl::add_rvalue_reference_t` meet the
/// requirements of the @ref add_rvalue_reference  template defined in the C++11
/// standard [meta.trans.ref].
///
/// ## Usage {#bslmf_addrvaluereference-usage}
///
///
/// In this section we show intended use of this component.
///
/// ### Example 1: Transform to Rvalue Reference Types {#bslmf_addrvaluereference-example-1-transform-to-rvalue-reference-types}
///
///
/// Suppose that we want to transform some types to rvalue reference types.
///
/// Now, for a set of types, we transform each type to the corresponding rvalue
/// reference of that type using `bsl::add_rvalue_reference` and verify the
/// result:
/// @code
/// #if defined(BSLS_COMPILERFEATURES_SUPPORT_RVALUE_REFERENCES)
///   assert(true  ==
///        (bsl::is_same<bsl::add_rvalue_reference<int>::type,   int&&>::value));
///   assert(false ==
///        (bsl::is_same<bsl::add_rvalue_reference<int>::type,   int  >::value));
///   assert(true  ==
///        (bsl::is_same<bsl::add_rvalue_reference<int&>::type,  int& >::value));
///   assert(true  ==
///        (bsl::is_same<bsl::add_rvalue_reference<int&&>::type, int&&>::value));
/// @endcode
/// Finally, if the current compiler supports alias templates C++11 feature, we
/// instantiate the `bsl::add_rvalue_reference_t` template for the same set of
/// types, and use the `bsl::is_same` meta-function to assert the resultant type
/// of each instantiation:
/// @code
/// #ifdef BSLS_COMPILERFEATURES_SUPPORT_ALIAS_TEMPLATES
///   assert(true  ==
///           (bsl::is_same<bsl::add_rvalue_reference_t<int>,   int&&>::value));
///   assert(false ==
///           (bsl::is_same<bsl::add_rvalue_reference_t<int>,   int  >::value));
///   assert(true  ==
///           (bsl::is_same<bsl::add_rvalue_reference_t<int&>,  int& >::value));
///   assert(true ==
///           (bsl::is_same<bsl::add_rvalue_reference_t<int&&>, int&&>::value));
/// #endif
/// #endif
/// @endcode
/// Note that rvalue reference was introduced in C++11 and may not be supported
/// by all compilers.  Note also that according to `reference collapsing`
/// semantics [8.3.2], @ref add_rvalue_reference  does not transform `t_TYPE` to
/// rvalue reference type if `t_TYPE` is an lvalue reference type.
///
/// Also note that the `bsl::add_rvalue_reference_t` avoids the `::type` suffix
/// and `typename` prefix when we want to use the result of
/// `bsl::add_rvalue_reference` meta-function in templates.
/// @}
/** @} */
/** @} */
 
/** @addtogroup bsl
 * @{
 */
/** @addtogroup bslmf
 * @{
 */
/** @addtogroup bslmf_addrvaluereference
 * @{
 */
 
#include <bslscm_version.h>
 
#include <bsls_compilerfeatures.h>
 
namespace bsl {
 
#if defined(BSLS_COMPILERFEATURES_SUPPORT_RVALUE_REFERENCES)
 
/// This `struct` template implements a meta-function to transform the
/// (template parameter) `t_TYPE` to its rvalue reference type.
///
/// See @ref bslmf_addrvaluereference 
template <class t_TYPE>
struct add_rvalue_reference {
 
    // PUBLIC TYPES
 
    /// This `typedef` is an alias to the return type of this meta-function.
    typedef t_TYPE&& type;
};
 
/// This partial specialization of @ref add_rvalue_reference  defines the return
/// type when it is instantiated with the `void` type.
template <>
struct add_rvalue_reference<void> {
 
    // PUBLIC TYPES
 
    /// This `typedef` is an alias to the return type of this meta-function.
    typedef void type;
};
 
/// This partial specialization of @ref add_rvalue_reference  defines the return
/// type when it is instantiated with the `void const` type.
template <>
struct add_rvalue_reference<void const> {
 
    // PUBLIC TYPES
 
    /// This `typedef` is an alias to the return type of this meta-function.
    typedef void const type;
};
 
/// This partial specialization of @ref add_rvalue_reference  defines the return
/// type when it is instantiated with the `void volatile` type.
template <>
struct add_rvalue_reference<void volatile> {
 
    // PUBLIC TYPES
 
    /// This `typedef` is an alias to the return type of this meta-function.
    typedef void volatile type;
};
 
/// This partial specialization of @ref add_rvalue_reference  defines the return
/// type when it is instantiated with the `void const volatile` type.
template <>
struct add_rvalue_reference<void const volatile> {
 
    // PUBLIC TYPES
 
    /// This `typedef` is an alias to the return type of this meta-function.
    typedef void const volatile type;
};
 
#ifdef BSLS_COMPILERFEATURES_SUPPORT_ALIAS_TEMPLATES
 
// ALIASES
 
/// @ref add_rvalue_reference_t  is an alias to the return type of
/// @ref add_rvalue_reference  meta-function.  Note, that the @ref add_const_t 
/// avoids the `::type` suffix and `typename` prefix when we want to use the
/// result of the meta-function in templates.
template <class t_TYPE>
using add_rvalue_reference_t = typename add_rvalue_reference<t_TYPE>::type;
 
#endif  // BSLS_COMPILERFEATURES_SUPPORT_ALIAS_TEMPLATES
#endif  // BSLS_COMPILERFEATURES_SUPPORT_RVALUE_REFERENCES
 
}  // close namespace bsl
 
#endif
 
// ----------------------------------------------------------------------------
// Copyright 2013 Bloomberg Finance L.P.
//
// 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.
// ----------------------------- END-OF-FILE ----------------------------------
 
/** @} */
/** @} */
/** @} */