FM / utils

/usr/include/boost/test/utils

Name	Size	Mode	Actions
basic_cstring/	-	0755	rm
iterator/	-	0755	rm
runtime/	-	0755	rm
algorithm.hpp	13671	0644	edit dl rm
assign_op.hpp	1098	0644	edit dl rm
class_properties.hpp	8164	0644	edit dl rm
custom_manip.hpp	1898	0644	edit dl rm
foreach.hpp	11794	0644	edit dl rm
is_cstring.hpp	4294	0644	edit dl rm
is_forward_iterable.hpp	8456	0644	edit dl rm
lazy_ostream.hpp	4734	0644	edit dl rm
named_params.hpp	14544	0644	edit dl rm
nullstream.hpp	3990	0644	edit dl rm
rtti.hpp	1845	0644	edit dl rm
setcolor.hpp	9315	0644	edit dl rm
string_cast.hpp	2002	0644	edit dl rm
timer.hpp	5018	0644	edit dl rm
wrap_stringstream.hpp	4905	0644	edit dl rm
xml_printer.hpp	4051	0644	edit dl rm

Edit: /usr/include/boost/test/utils/named_params.hpp (14544B)

//  See http://www.boost.org/libs/test for the library home page.
//
//  File        : $RCSfile$
//
//  Version     : $Revision$
//
//  Description : named function parameters library
// ***************************************************************************

#ifndef BOOST_TEST_UTILS_NAMED_PARAM
#define BOOST_TEST_UTILS_NAMED_PARAM

// Boost
#include <boost/config.hpp>
#include <boost/detail/workaround.hpp>

// Boost.Test
#include <boost/test/utils/rtti.hpp>
#include <boost/test/utils/assign_op.hpp>

#include <boost/type_traits/remove_reference.hpp>
#include <boost/type_traits/remove_cv.hpp>

#include <boost/test/detail/throw_exception.hpp>

// Boost
#include <boost/mpl/if.hpp>
#include <boost/mpl/or.hpp>
#include <boost/type_traits/is_same.hpp>
#include <boost/type_traits/remove_cv.hpp>
#include <boost/utility/enable_if.hpp>
#include <boost/mpl/bool.hpp>

#include <boost/test/detail/suppress_warnings.hpp>

//____________________________________________________________________________//

namespace boost {
namespace nfp { // named function parameters

// ************************************************************************** //
// **************             forward declarations             ************** //
// ************************************************************************** //

template<typename unique_id, bool required>                     struct keyword;
template<typename T, typename unique_id, bool required = false> struct typed_keyword;

template<typename T, typename unique_id, typename RefType=T&>   struct named_parameter;
template<typename NP1,typename NP2>                             struct named_parameter_combine;

// ************************************************************************** //
// **************              is_named_param_pack             ************** //
// ************************************************************************** //

/// is_named_param_pack<T>::value is true if T is parameters pack

template<typename T>
struct is_named_param_pack : public mpl::false_ {};

template<typename T, typename unique_id, typename RefType>
struct is_named_param_pack<named_parameter<T,unique_id,RefType> > : public mpl::true_ {};

template<typename NP, typename Rest>
struct is_named_param_pack<named_parameter_combine<NP,Rest> > : public mpl::true_ {};

// ************************************************************************** //
// **************                  param_type                  ************** //
// ************************************************************************** //

/// param_type<Params,Keyword,Default>::type is the type of the parameter
/// corresponding to the Keyword (if parameter is present) or Default

template<typename NP, typename Keyword, typename DefaultType=void>
struct param_type
: mpl::if_<typename is_same<typename NP::id,typename Keyword::id>::type,
           typename remove_cv<typename NP::data_type>::type,
           DefaultType> {};

template<typename NP, typename Rest, typename Keyword, typename DefaultType>
struct param_type<named_parameter_combine<NP,Rest>,Keyword,DefaultType>
: mpl::if_<typename is_same<typename NP::id,typename Keyword::id>::type,
           typename remove_cv<typename NP::data_type>::type,
           typename param_type<Rest,Keyword,DefaultType>::type> {};

// ************************************************************************** //
// **************                  has_param                   ************** //
// ************************************************************************** //

/// has_param<Params,Keyword>::value is true if Params has parameter corresponding
/// to the Keyword

template<typename NP, typename Keyword>
struct has_param : is_same<typename NP::id,typename Keyword::id> {};

template<typename NP, typename Rest, typename Keyword>
struct has_param<named_parameter_combine<NP,Rest>,Keyword>
: mpl::or_<typename is_same<typename NP::id,typename Keyword::id>::type,
           typename has_param<Rest,Keyword>::type> {};

// ************************************************************************** //
// **************          access_to_invalid_parameter         ************** //
// ************************************************************************** //

namespace nfp_detail {

struct access_to_invalid_parameter {};

//____________________________________________________________________________//

inline void
report_access_to_invalid_parameter( bool v )
{
    BOOST_TEST_I_ASSRT( !v, access_to_invalid_parameter() );
}

} // namespace nfp_detail

// ************************************************************************** //
// **************                      nil                     ************** //
// ************************************************************************** //

struct nil {
    template<typename T>
#if defined(__GNUC__) || defined(__HP_aCC) || defined(__EDG__) || defined(__SUNPRO_CC) || defined(BOOST_EMBTC)
    operator T() const
#else
    operator T const&() const
#endif
    { nfp_detail::report_access_to_invalid_parameter(true); static T* v = 0; return *v; }

template<typename T>
    T any_cast() const
    { nfp_detail::report_access_to_invalid_parameter(true); static typename remove_reference<T>::type* v = 0; return *v; }

template<typename Arg1>
    nil operator()( Arg1 const& )
    { nfp_detail::report_access_to_invalid_parameter(true); return nil(); }

template<typename Arg1,typename Arg2>
    nil operator()( Arg1 const&, Arg2 const& )
    { nfp_detail::report_access_to_invalid_parameter(true); return nil(); }

template<typename Arg1,typename Arg2,typename Arg3>
    nil operator()( Arg1 const&, Arg2 const&, Arg3 const& )
    { nfp_detail::report_access_to_invalid_parameter(true); return nil(); }

// Visitation support
    template<typename Visitor>
    void            apply_to( Visitor& /*v*/ ) const {}

static nil&     inst() { static nil s_inst; return s_inst; }
private:
    nil() {}
};

// ************************************************************************** //
// **************             named_parameter_base             ************** //
// ************************************************************************** //

namespace nfp_detail {

template<typename Derived>
struct named_parameter_base {
    template<typename NP>
    named_parameter_combine<NP,Derived>
    operator,( NP const& np ) const { return named_parameter_combine<NP,Derived>( np, *static_cast<Derived const*>(this) ); }
};

} // namespace nfp_detail

// ************************************************************************** //
// **************            named_parameter_combine           ************** //
// ************************************************************************** //

template<typename NP, typename Rest = nil>
struct named_parameter_combine
: Rest
, nfp_detail::named_parameter_base<named_parameter_combine<NP,Rest> > {
    typedef typename NP::ref_type  res_type;
    typedef named_parameter_combine<NP,Rest> self_type;

// Constructor
    named_parameter_combine( NP const& np, Rest const& r )
    : Rest( r )
    , m_param( np )
    {
    }

// Access methods
    res_type    operator[]( keyword<typename NP::id,true> kw ) const    { return m_param[kw]; }
    res_type    operator[]( keyword<typename NP::id,false> kw ) const   { return m_param[kw]; }
    using       Rest::operator[];

bool        has( keyword<typename NP::id,false> kw ) const          { return m_param.has( kw ); }
    using       Rest::has;

void        erase( keyword<typename NP::id,false> kw ) const        { m_param.erase( kw ); }
    using       Rest::erase;

using       nfp_detail::named_parameter_base<named_parameter_combine<NP,Rest> >::operator,;

// Visitation support
    template<typename Visitor>
    void            apply_to( Visitor& V ) const
    {
        m_param.apply_to( V );

Rest::apply_to( V );
    }
private:
    // Data members
    NP          m_param;
};

// ************************************************************************** //
// **************                named_parameter               ************** //
// ************************************************************************** //

template<typename T, typename unique_id, typename RefType>
struct named_parameter
: nfp_detail::named_parameter_base<named_parameter<T,unique_id,RefType> >
{
    typedef T               data_type;
    typedef RefType         ref_type;
    typedef unique_id       id;

// Constructor
    explicit        named_parameter( ref_type v )
    : m_value( v )
    , m_erased( false )
    {}
    named_parameter( named_parameter const& np )
    : m_value( np.m_value )
    , m_erased( np.m_erased )
    {}

// Access methods
    ref_type        operator[]( keyword<unique_id,true> ) const     { return m_erased ? nil::inst().template any_cast<ref_type>() :  m_value; }
    ref_type        operator[]( keyword<unique_id,false> ) const    { return m_erased ? nil::inst().template any_cast<ref_type>() :  m_value; }
    template<typename UnknownId>
    nil             operator[]( keyword<UnknownId,false> ) const    { return nil::inst(); }

bool            has( keyword<unique_id,false> ) const           { return !m_erased; }
    template<typename UnknownId>
    bool            has( keyword<UnknownId,false> ) const           { return false; }

void            erase( keyword<unique_id,false> ) const         { m_erased = true; }
    template<typename UnknownId>
    void            erase( keyword<UnknownId,false> ) const         {}

// Visitation support
    template<typename Visitor>
    void            apply_to( Visitor& V ) const
    {
        V.set_parameter( rtti::type_id<unique_id>(), m_value );
    }

private:
    // Data members
    ref_type        m_value;
    mutable bool    m_erased;
};

// ************************************************************************** //
// **************                   no_params                  ************** //
// ************************************************************************** //

typedef named_parameter<char, struct no_params_type_t,char> no_params_type;

namespace {
no_params_type no_params( '\0' );
} // local namespace

// ************************************************************************** //
// **************                    keyword                   ************** //
// ************************************************************************** //

template<typename unique_id, bool required = false>
struct keyword {
    typedef unique_id id;

template<typename T>
    named_parameter<T const,unique_id>
    operator=( T const& t ) const       { return named_parameter<T const,unique_id>( t ); }

template<typename T>
    named_parameter<T,unique_id>
    operator=( T& t ) const             { return named_parameter<T,unique_id>( t ); }

named_parameter<char const*,unique_id,char const*>
    operator=( char const* t ) const    { return named_parameter<char const*,unique_id,char const*>( t ); }
};

//____________________________________________________________________________//

// ************************************************************************** //
// **************                 typed_keyword                ************** //
// ************************************************************************** //

template<typename T, typename unique_id, bool required>
struct typed_keyword : keyword<unique_id,required> {
    named_parameter<T const,unique_id>
    operator=( T const& t ) const       { return named_parameter<T const,unique_id>( t ); }

named_parameter<T,unique_id>
    operator=( T& t ) const             { return named_parameter<T,unique_id>( t ); }
};

//____________________________________________________________________________//

template<typename unique_id, bool required>
struct typed_keyword<bool,unique_id,required>
: keyword<unique_id,required>
, named_parameter<bool,unique_id,bool> {
    typedef unique_id id;

typed_keyword() : named_parameter<bool,unique_id,bool>( true ) {}

named_parameter<bool,unique_id,bool>
    operator!() const           { return named_parameter<bool,unique_id,bool>( false ); }
};

// ************************************************************************** //
// **************                  opt_assign                  ************** //
// ************************************************************************** //

template<typename T, typename Params, typename Keyword>
inline typename enable_if_c<!has_param<Params,Keyword>::value,void>::type
opt_assign( T& /*target*/, Params const& /*p*/, Keyword /*k*/ )
{
}

//____________________________________________________________________________//

template<typename T, typename Params, typename Keyword>
inline typename enable_if_c<has_param<Params,Keyword>::value,void>::type
opt_assign( T& target, Params const& p, Keyword k )
{
    using namespace unit_test;

assign_op( target, p[k], static_cast<int>(0) );
}

// ************************************************************************** //
// **************                    opt_get                   ************** //
// ************************************************************************** //

template<typename T, typename Params, typename Keyword>
inline T
opt_get( Params const& p, Keyword k, T default_val )
{
    opt_assign( default_val, p, k );

return default_val;
}

template<typename Params, typename NP>
inline typename enable_if_c<!has_param<Params,keyword<typename NP::id> >::value,
named_parameter_combine<NP,Params> >::type
opt_append( Params const& params, NP const& np )
{
    return (params,np);
}

//____________________________________________________________________________//

template<typename Params, typename NP>
inline typename enable_if_c<has_param<Params,keyword<typename NP::id> >::value,Params>::type
opt_append( Params const& params, NP const& )
{
    return params;
}

} // namespace nfp
} // namespace boost

#include <boost/test/detail/enable_warnings.hpp>

#endif // BOOST_TEST_UTILS_NAMED_PARAM

// (C) Copyright Gennadiy Rozental 2001. // 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) // See http://www.boost.org/libs/test for the library home page. // // File : $RCSfile$ // // Version : $Revision$ // // Description : named function parameters library // *************************************************************************** #ifndef BOOST_TEST_UTILS_NAMED_PARAM #define BOOST_TEST_UTILS_NAMED_PARAM // Boost #include #include // Boost.Test #include #include #include #include #include // Boost #include #include #include #include #include #include #include //____________________________________________________________________________// namespace boost { namespace nfp { // named function parameters // ************************************************************************** // // ************** forward declarations ************** // // ************************************************************************** // template struct keyword; template struct typed_keyword; template struct named_parameter; template struct named_parameter_combine; // ************************************************************************** // // ************** is_named_param_pack ************** // // ************************************************************************** // /// is_named_param_pack::value is true if T is parameters pack template struct is_named_param_pack : public mpl::false_ {}; template struct is_named_param_pack > : public mpl::true_ {}; template struct is_named_param_pack > : public mpl::true_ {}; // ************************************************************************** // // ************** param_type ************** // // ************************************************************************** // /// param_type::type is the type of the parameter /// corresponding to the Keyword (if parameter is present) or Default template struct param_type : mpl::if_::type, typename remove_cv::type, DefaultType> {}; template struct param_type,Keyword,DefaultType> : mpl::if_::type, typename remove_cv::type, typename param_type::type> {}; // ************************************************************************** // // ************** has_param ************** // // ************************************************************************** // /// has_param::value is true if Params has parameter corresponding /// to the Keyword template struct has_param : is_same {}; template struct has_param,Keyword> : mpl::or_::type, typename has_param::type> {}; // ************************************************************************** // // ************** access_to_invalid_parameter ************** // // ************************************************************************** // namespace nfp_detail { struct access_to_invalid_parameter {}; //____________________________________________________________________________// inline void report_access_to_invalid_parameter( bool v ) { BOOST_TEST_I_ASSRT( !v, access_to_invalid_parameter() ); } } // namespace nfp_detail // ************************************************************************** // // ************** nil ************** // // ************************************************************************** // struct nil { template #if defined(__GNUC__) || defined(__HP_aCC) || defined(__EDG__) || defined(__SUNPRO_CC) || defined(BOOST_EMBTC) operator T() const #else operator T const&() const #endif { nfp_detail::report_access_to_invalid_parameter(true); static T* v = 0; return *v; } template T any_cast() const { nfp_detail::report_access_to_invalid_parameter(true); static typename remove_reference::type* v = 0; return *v; } template nil operator()( Arg1 const& ) { nfp_detail::report_access_to_invalid_parameter(true); return nil(); } template nil operator()( Arg1 const&, Arg2 const& ) { nfp_detail::report_access_to_invalid_parameter(true); return nil(); } template nil operator()( Arg1 const&, Arg2 const&, Arg3 const& ) { nfp_detail::report_access_to_invalid_parameter(true); return nil(); } // Visitation support template void apply_to( Visitor& /*v*/ ) const {} static nil& inst() { static nil s_inst; return s_inst; } private: nil() {} }; // ************************************************************************** // // ************** named_parameter_base ************** // // ************************************************************************** // namespace nfp_detail { template struct named_parameter_base { template named_parameter_combine operator,( NP const& np ) const { return named_parameter_combine( np, *static_cast(this) ); } }; } // namespace nfp_detail // ************************************************************************** // // ************** named_parameter_combine ************** // // ************************************************************************** // template struct named_parameter_combine : Rest , nfp_detail::named_parameter_base > { typedef typename NP::ref_type res_type; typedef named_parameter_combine self_type; // Constructor named_parameter_combine( NP const& np, Rest const& r ) : Rest( r ) , m_param( np ) { } // Access methods res_type operator[]( keyword kw ) const { return m_param[kw]; } res_type operator[]( keyword kw ) const { return m_param[kw]; } using Rest::operator[]; bool has( keyword kw ) const { return m_param.has( kw ); } using Rest::has; void erase( keyword kw ) const { m_param.erase( kw ); } using Rest::erase; using nfp_detail::named_parameter_base >::operator,; // Visitation support template void apply_to( Visitor& V ) const { m_param.apply_to( V ); Rest::apply_to( V ); } private: // Data members NP m_param; }; // ************************************************************************** // // ************** named_parameter ************** // // ************************************************************************** // template struct named_parameter : nfp_detail::named_parameter_base > { typedef T data_type; typedef RefType ref_type; typedef unique_id id; // Constructor explicit named_parameter( ref_type v ) : m_value( v ) , m_erased( false ) {} named_parameter( named_parameter const& np ) : m_value( np.m_value ) , m_erased( np.m_erased ) {} // Access methods ref_type operator[]( keyword ) const { return m_erased ? nil::inst().template any_cast() : m_value; } ref_type operator[]( keyword ) const { return m_erased ? nil::inst().template any_cast() : m_value; } template nil operator[]( keyword ) const { return nil::inst(); } bool has( keyword ) const { return !m_erased; } template bool has( keyword ) const { return false; } void erase( keyword ) const { m_erased = true; } template void erase( keyword ) const {} // Visitation support template void apply_to( Visitor& V ) const { V.set_parameter( rtti::type_id(), m_value ); } private: // Data members ref_type m_value; mutable bool m_erased; }; // ************************************************************************** // // ************** no_params ************** // // ************************************************************************** // typedef named_parameter no_params_type; namespace { no_params_type no_params( '\0' ); } // local namespace // ************************************************************************** // // ************** keyword ************** // // ************************************************************************** // template struct keyword { typedef unique_id id; template named_parameter operator=( T const& t ) const { return named_parameter( t ); } template named_parameter operator=( T& t ) const { return named_parameter( t ); } named_parameter operator=( char const* t ) const { return named_parameter( t ); } }; //____________________________________________________________________________// // ************************************************************************** // // ************** typed_keyword ************** // // ************************************************************************** // template struct typed_keyword : keyword { named_parameter operator=( T const& t ) const { return named_parameter( t ); } named_parameter operator=( T& t ) const { return named_parameter( t ); } }; //____________________________________________________________________________// template struct typed_keyword : keyword , named_parameter { typedef unique_id id; typed_keyword() : named_parameter( true ) {} named_parameter operator!() const { return named_parameter( false ); } }; // ************************************************************************** // // ************** opt_assign ************** // // ************************************************************************** // template inline typename enable_if_c::value,void>::type opt_assign( T& /*target*/, Params const& /*p*/, Keyword /*k*/ ) { } //____________________________________________________________________________// template inline typename enable_if_c::value,void>::type opt_assign( T& target, Params const& p, Keyword k ) { using namespace unit_test; assign_op( target, p[k], static_cast(0) ); } // ************************************************************************** // // ************** opt_get ************** // // ************************************************************************** // template inline T opt_get( Params const& p, Keyword k, T default_val ) { opt_assign( default_val, p, k ); return default_val; } // ************************************************************************** // // ************** opt_get ************** // // ************************************************************************** // template inline typename enable_if_c >::value, named_parameter_combine >::type opt_append( Params const& params, NP const& np ) { return (params,np); } //____________________________________________________________________________// template inline typename enable_if_c >::value,Params>::type opt_append( Params const& params, NP const& ) { return params; } } // namespace nfp } // namespace boost #include #endif // BOOST_TEST_UTILS_NAMED_PARAM